Repository: AeneasVerif/eurydice
Branch: main
Commit: 4e769f096186
Files: 346
Total size: 5.3 MB

Directory structure:
gitextract_fzr909fs/

├── .github/
│   └── workflows/
│       └── nix.yaml
├── .gitignore
├── .ocamlformat
├── .ocamlformat-ignore
├── LICENSE-APACHE
├── LICENSE-MIT
├── Makefile
├── README.md
├── bin/
│   ├── dune
│   └── main.ml
├── cremepat/
│   ├── Lex.ml
│   ├── Parse.mly
│   ├── ParseTree.ml
│   ├── README.md
│   ├── cremepat.ml
│   └── dune
├── dune
├── dune-project
├── eurydice.opam
├── flake.nix
├── include/
│   └── eurydice_glue.h
├── lib/
│   ├── AstOfLlbc.ml
│   ├── Builtin.ml
│   ├── Bundles.ml
│   ├── Cleanup1.ml
│   ├── Cleanup2.ml
│   ├── Cleanup3.ml
│   ├── LoadLlbc.ml
│   ├── Logging.ml
│   ├── Options.ml
│   ├── PreCleanup.ml
│   ├── Utf8.ml
│   └── dune
├── out/
│   ├── test-array/
│   │   ├── array.c
│   │   └── array.h
│   ├── test-array2d/
│   │   ├── array2d.c
│   │   └── array2d.h
│   ├── test-castunsize/
│   │   ├── castunsize.c
│   │   └── castunsize.h
│   ├── test-closure/
│   │   ├── closure.c
│   │   └── closure.h
│   ├── test-closure_fn_cast/
│   │   ├── closure_fn_cast.c
│   │   └── closure_fn_cast.h
│   ├── test-collision/
│   │   ├── collision.c
│   │   └── collision.h
│   ├── test-const_generics/
│   │   ├── const_generics.c
│   │   └── const_generics.h
│   ├── test-core_num/
│   │   ├── core_num.c
│   │   └── core_num.h
│   ├── test-dst/
│   │   ├── dst.c
│   │   └── dst.h
│   ├── test-dyn_trait_struct_type/
│   │   ├── dyn_trait_struct_type.c
│   │   └── dyn_trait_struct_type.h
│   ├── test-floating_points/
│   │   ├── floating_points.c
│   │   └── floating_points.h
│   ├── test-fn_cast/
│   │   ├── fn_cast.c
│   │   └── fn_cast.h
│   ├── test-fn_higher_order/
│   │   ├── fn_higher_order.c
│   │   └── fn_higher_order.h
│   ├── test-for/
│   │   ├── for.c
│   │   └── for.h
│   ├── test-global_ref/
│   │   ├── global_ref.c
│   │   └── global_ref.h
│   ├── test-i32_shl/
│   │   ├── i32_shl.c
│   │   └── i32_shl.h
│   ├── test-inline_attributes/
│   │   ├── inline_attributes.c
│   │   └── inline_attributes.h
│   ├── test-int_switch/
│   │   ├── int_switch.c
│   │   └── int_switch.h
│   ├── test-issue_102/
│   │   ├── issue_102.c
│   │   └── issue_102.h
│   ├── test-issue_104/
│   │   ├── issue_104.c
│   │   └── issue_104.h
│   ├── test-issue_105/
│   │   ├── issue_105.c
│   │   └── issue_105.h
│   ├── test-issue_106/
│   │   ├── issue_106.c
│   │   └── issue_106.h
│   ├── test-issue_107/
│   │   ├── issue_107.c
│   │   └── issue_107.h
│   ├── test-issue_123/
│   │   ├── issue_123.c
│   │   └── issue_123.h
│   ├── test-issue_128/
│   │   ├── issue_128.c
│   │   └── issue_128.h
│   ├── test-issue_212/
│   │   ├── issue_212.c
│   │   └── issue_212.h
│   ├── test-issue_37/
│   │   ├── issue_37.c
│   │   └── issue_37.h
│   ├── test-issue_49/
│   │   ├── issue_49.c
│   │   └── issue_49.h
│   ├── test-issue_96/
│   │   ├── issue_96.c
│   │   └── issue_96.h
│   ├── test-issue_k630/
│   │   ├── issue_k630.c
│   │   └── issue_k630.h
│   ├── test-issue_shift/
│   │   ├── issue_shift.c
│   │   └── issue_shift.h
│   ├── test-libcrux-ml-dsa/
│   │   ├── internal/
│   │   │   ├── libcrux_mldsa_avx2.h
│   │   │   ├── libcrux_mldsa_core.h
│   │   │   ├── libcrux_mldsa_portable.h
│   │   │   ├── libcrux_sha3_avx2.h
│   │   │   └── libcrux_sha3_internal.h
│   │   ├── libcrux_mldsa44_avx2.c
│   │   ├── libcrux_mldsa44_avx2.h
│   │   ├── libcrux_mldsa44_portable.c
│   │   ├── libcrux_mldsa44_portable.h
│   │   ├── libcrux_mldsa65_avx2.c
│   │   ├── libcrux_mldsa65_avx2.h
│   │   ├── libcrux_mldsa65_portable.c
│   │   ├── libcrux_mldsa65_portable.h
│   │   ├── libcrux_mldsa87_avx2.c
│   │   ├── libcrux_mldsa87_avx2.h
│   │   ├── libcrux_mldsa87_portable.c
│   │   ├── libcrux_mldsa87_portable.h
│   │   ├── libcrux_mldsa_avx2.c
│   │   ├── libcrux_mldsa_avx2.h
│   │   ├── libcrux_mldsa_core.c
│   │   ├── libcrux_mldsa_core.h
│   │   ├── libcrux_mldsa_portable.c
│   │   ├── libcrux_mldsa_portable.h
│   │   ├── libcrux_sha3.h
│   │   ├── libcrux_sha3_avx2.c
│   │   ├── libcrux_sha3_avx2.h
│   │   └── libcrux_sha3_internal.h
│   ├── test-libcrux-ml-kem/
│   │   ├── internal/
│   │   │   ├── libcrux_core.h
│   │   │   ├── libcrux_mlkem1024_avx2.h
│   │   │   ├── libcrux_mlkem1024_portable.h
│   │   │   ├── libcrux_mlkem512_avx2.h
│   │   │   ├── libcrux_mlkem512_portable.h
│   │   │   ├── libcrux_mlkem768_avx2.h
│   │   │   ├── libcrux_mlkem768_portable.h
│   │   │   ├── libcrux_mlkem_avx2.h
│   │   │   ├── libcrux_mlkem_portable.h
│   │   │   └── libcrux_sha3_internal.h
│   │   ├── libcrux_core.c
│   │   ├── libcrux_core.h
│   │   ├── libcrux_mlkem1024.h
│   │   ├── libcrux_mlkem1024_avx2.c
│   │   ├── libcrux_mlkem1024_avx2.h
│   │   ├── libcrux_mlkem1024_portable.c
│   │   ├── libcrux_mlkem1024_portable.h
│   │   ├── libcrux_mlkem512.h
│   │   ├── libcrux_mlkem512_avx2.c
│   │   ├── libcrux_mlkem512_avx2.h
│   │   ├── libcrux_mlkem512_portable.c
│   │   ├── libcrux_mlkem512_portable.h
│   │   ├── libcrux_mlkem768.h
│   │   ├── libcrux_mlkem768_avx2.c
│   │   ├── libcrux_mlkem768_avx2.h
│   │   ├── libcrux_mlkem768_portable.c
│   │   ├── libcrux_mlkem768_portable.h
│   │   ├── libcrux_mlkem_avx2.c
│   │   ├── libcrux_mlkem_avx2.h
│   │   ├── libcrux_mlkem_portable.c
│   │   ├── libcrux_mlkem_portable.h
│   │   ├── libcrux_sha3_avx2.c
│   │   ├── libcrux_sha3_avx2.h
│   │   ├── libcrux_sha3_internal.h
│   │   ├── libcrux_sha3_portable.c
│   │   └── libcrux_sha3_portable.h
│   ├── test-libcrux-ml-kem-no-const/
│   │   ├── internal/
│   │   │   ├── libcrux_core.h
│   │   │   ├── libcrux_mlkem1024_avx2.h
│   │   │   ├── libcrux_mlkem1024_portable.h
│   │   │   ├── libcrux_mlkem512_avx2.h
│   │   │   ├── libcrux_mlkem512_portable.h
│   │   │   ├── libcrux_mlkem768_avx2.h
│   │   │   ├── libcrux_mlkem768_portable.h
│   │   │   ├── libcrux_mlkem_avx2.h
│   │   │   ├── libcrux_mlkem_portable.h
│   │   │   └── libcrux_sha3_internal.h
│   │   ├── libcrux_core.c
│   │   ├── libcrux_core.h
│   │   ├── libcrux_mlkem1024.h
│   │   ├── libcrux_mlkem1024_avx2.c
│   │   ├── libcrux_mlkem1024_avx2.h
│   │   ├── libcrux_mlkem1024_portable.c
│   │   ├── libcrux_mlkem1024_portable.h
│   │   ├── libcrux_mlkem512.h
│   │   ├── libcrux_mlkem512_avx2.c
│   │   ├── libcrux_mlkem512_avx2.h
│   │   ├── libcrux_mlkem512_portable.c
│   │   ├── libcrux_mlkem512_portable.h
│   │   ├── libcrux_mlkem768.h
│   │   ├── libcrux_mlkem768_avx2.c
│   │   ├── libcrux_mlkem768_avx2.h
│   │   ├── libcrux_mlkem768_portable.c
│   │   ├── libcrux_mlkem768_portable.h
│   │   ├── libcrux_mlkem_avx2.c
│   │   ├── libcrux_mlkem_avx2.h
│   │   ├── libcrux_mlkem_portable.c
│   │   ├── libcrux_mlkem_portable.h
│   │   ├── libcrux_sha3_avx2.c
│   │   ├── libcrux_sha3_avx2.h
│   │   ├── libcrux_sha3_internal.h
│   │   ├── libcrux_sha3_portable.c
│   │   └── libcrux_sha3_portable.h
│   ├── test-lvalue/
│   │   ├── lvalue.c
│   │   └── lvalue.h
│   ├── test-mismatch/
│   │   ├── mismatch.c
│   │   └── mismatch.h
│   ├── test-more_dst/
│   │   ├── more_dst.c
│   │   └── more_dst.h
│   ├── test-more_primitive_types/
│   │   ├── more_primitive_types.c
│   │   └── more_primitive_types.h
│   ├── test-more_str/
│   │   ├── more_str.c
│   │   └── more_str.h
│   ├── test-names/
│   │   ├── names.c
│   │   └── names.h
│   ├── test-nested_arrays/
│   │   ├── nested_arrays.c
│   │   └── nested_arrays.h
│   ├── test-nested_arrays2/
│   │   ├── nested_arrays2.c
│   │   └── nested_arrays2.h
│   ├── test-option/
│   │   ├── option.c
│   │   └── option.h
│   ├── test-parentparent/
│   │   ├── parentparent.c
│   │   └── parentparent.h
│   ├── test-partial_eq/
│   │   ├── partial_eq.c
│   │   └── partial_eq.h
│   ├── test-raw_pointers/
│   │   ├── raw_pointers.c
│   │   └── raw_pointers.h
│   ├── test-reborrow/
│   │   ├── reborrow.c
│   │   └── reborrow.h
│   ├── test-recursion/
│   │   ├── recursion.c
│   │   └── recursion.h
│   ├── test-repeat/
│   │   ├── repeat.c
│   │   └── repeat.h
│   ├── test-result/
│   │   ├── result.c
│   │   └── result.h
│   ├── test-signed_wrapping/
│   │   ├── signed_wrapping.c
│   │   └── signed_wrapping.h
│   ├── test-slice_array/
│   │   ├── slice_array.c
│   │   └── slice_array.h
│   ├── test-step_by/
│   │   ├── step_by.c
│   │   └── step_by.h
│   ├── test-substr/
│   │   ├── substr.c
│   │   └── substr.h
│   ├── test-symcrust/
│   │   ├── internal/
│   │   │   └── Eurydice.h
│   │   ├── symcrust.c
│   │   └── symcrust.h
│   ├── test-trait_generics/
│   │   ├── trait_generics.c
│   │   └── trait_generics.h
│   ├── test-traits/
│   │   ├── traits.c
│   │   └── traits.h
│   ├── test-traits2/
│   │   ├── traits2.c
│   │   └── traits2.h
│   ├── test-traits3/
│   │   ├── traits3.c
│   │   └── traits3.h
│   ├── test-we_need_charon_monomorphization/
│   │   ├── we_need_charon_monomorphization.c
│   │   └── we_need_charon_monomorphization.h
│   ├── test-where_clauses_closures/
│   │   ├── where_clauses_closures.c
│   │   └── where_clauses_closures.h
│   ├── test-where_clauses_fncg/
│   │   ├── where_clauses_fncg.c
│   │   └── where_clauses_fncg.h
│   ├── test-where_clauses_simple/
│   │   ├── where_clauses_simple.c
│   │   └── where_clauses_simple.h
│   └── testxx-result/
│       ├── result.cc
│       └── result.h
├── scripts/
│   ├── check-dependency.sh
│   ├── ci-check-charon-pin-is-forward.sh
│   ├── ci-check-charon-pin-is-merged.sh
│   ├── format.sh
│   └── update-charon-pin.sh
└── test/
    ├── array.rs
    ├── array2d.rs
    ├── castunsize.rs
    ├── chunks.rs
    ├── closure.rs
    ├── closure_fn_cast.rs
    ├── collision.rs
    ├── const_generics.rs
    ├── core_cmp_lib.c
    ├── core_num.rs
    ├── core_str_lib.c
    ├── dst.rs
    ├── dyn_trait_struct_type.rs
    ├── floating_points.rs
    ├── fn_cast.rs
    ├── fn_higher_order.rs
    ├── for.rs
    ├── global_ref.rs
    ├── i32_shl.rs
    ├── inline_attributes.rs
    ├── int_switch.rs
    ├── issue_102.rs
    ├── issue_104.rs
    ├── issue_105.rs
    ├── issue_106.rs
    ├── issue_107.rs
    ├── issue_123.rs
    ├── issue_128.rs
    ├── issue_14.rs
    ├── issue_212.rs
    ├── issue_311.rs
    ├── issue_37.rs
    ├── issue_49.rs
    ├── issue_96.rs
    ├── issue_99.rs
    ├── issue_k630.rs
    ├── issue_shift.rs
    ├── libcrux-ml-dsa/
    │   ├── CMakeLists.txt
    │   ├── c.yaml
    │   └── tests/
    │       ├── mldsa65.cc
    │       ├── nistkats-65.json
    │       └── nistkats_pre_hashed-65.json
    ├── libcrux-ml-kem/
    │   ├── CMakeLists.txt
    │   ├── c.yaml
    │   ├── intrinsics/
    │   │   └── libcrux_intrinsics_avx2.h
    │   └── tests/
    │       ├── mlkem768.cc
    │       ├── mlkem768_nistkats.json
    │       └── sha3.cc
    ├── lvalue.rs
    ├── main.c
    ├── mismatch.rs
    ├── more_dst.rs
    ├── more_primitive_types.rs
    ├── more_primitive_types.yaml
    ├── more_str.rs
    ├── mutable_slice_range.rs
    ├── names.rs
    ├── nested_arrays.rs
    ├── nested_arrays2.rs
    ├── option.rs
    ├── parentparent.rs
    ├── partial_eq.rs
    ├── partial_eq_stubs.c
    ├── println.rs
    ├── raw_pointers.rs
    ├── reborrow.rs
    ├── recursion.rs
    ├── repeat.rs
    ├── result.rs
    ├── signed_wrapping.rs
    ├── slice_array.rs
    ├── step_by.rs
    ├── substr.rs
    ├── substr.yaml
    ├── substr_impl.c
    ├── substr_stubs.h
    ├── symcrust.rs
    ├── trait_generics.rs
    ├── traits.rs
    ├── traits2.rs
    ├── traits3.rs
    ├── we_need_charon_monomorphization.rs
    ├── where_clauses.rs
    ├── where_clauses_closures.rs
    ├── where_clauses_fncg.rs
    └── where_clauses_simple.rs

================================================
FILE CONTENTS
================================================

================================================
FILE: .github/workflows/nix.yaml
================================================
name: Build Eurydice and run tests

on:
  push:
    branches:
      - main
  pull_request:
  workflow_dispatch:

# Cancel previous versions of this job that are still running.
concurrency:
  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
  cancel-in-progress: true

jobs:
  check:
    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v3
      - name: Build and test
        run: nix flake check -L

  charon-pin-is-forward:
    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # deep clone in order to get access to other commits
      - run: nix develop '.#ci' --command ./scripts/ci-check-charon-pin-is-forward.sh

  charon-pin-is-merged:
    runs-on: self-hosted
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0 # deep clone in order to get access to other commits
      - run: nix develop '.#ci' --command ./scripts/ci-check-charon-pin-is-merged.sh


================================================
FILE: .gitignore
================================================
/karamel
/charon
/libcrux

_build
test/*/target
out/*/a.out
*.DS_Store
*.orig
*.llbc
eurydice
/.vscode
.charon_version

test/libcrux-*/build
_opam
.cache


================================================
FILE: .ocamlformat
================================================
profile = default
version = 0.27.0
margin = 100

break-cases = fit-or-vertical
exp-grouping = preserve
if-then-else = vertical
parens-tuple = multi-line-only
parens-tuple-patterns = multi-line-only


================================================
FILE: .ocamlformat-ignore
================================================
lib/charon/**
lib/krml/**


================================================
FILE: LICENSE-APACHE
================================================
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

   1. Definitions.

      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

   END OF TERMS AND CONDITIONS

   APPENDIX: How to apply the Apache License to your work.

      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

   Copyright 2024 Eurydice Contributors

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.


================================================
FILE: LICENSE-MIT
================================================
MIT License

Copyright (c) 2024 Eurydice Contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: Makefile
================================================
CHARON_HOME 	?= $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/charon
KRML_HOME 	?= $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/karamel
LIBCRUX_HOME 	?= $(dir $(abspath $(lastword $(MAKEFILE_LIST))))/libcrux
EURYDICE	?= ./eurydice $(EURYDICE_FLAGS)
CHARON		?= $(CHARON_HOME)/bin/charon

BROKEN_TESTS		= where_clauses println chunks mutable_slice_range issue_99 issue_14 issue_311
TEST_DIRS		= $(filter-out $(BROKEN_TESTS),$(basename $(notdir $(wildcard test/*.rs))))

# Warn on old versions of bash
_ := $(shell bash -c '(( $${BASH_VERSION%%.*} >= 4 ))')
ifneq ($(.SHELLSTATUS),0)
_: $(error "bash version is too old; hint: brew install bash")
endif

# Warn on old versions of make
ifeq (3.81,$(MAKE_VERSION))
  $(error You seem to be using the OSX antiquated Make version. Hint: brew \
    install make, then invoke gmake instead of make)
endif

# Enable `foo/**` glob syntax
SHELL := bash -O globstar 

ifeq ($(shell uname -s),Darwin)
  ifeq (,$(shell which gsed))
    $(error gsed not found; try brew install gnu-sed)
  endif
  SED=gsed
else
  SED=sed
endif

ifneq ($(shell $(CHARON) version), $(shell cat .charon_version &>/dev/null || true))
  _ := $(shell $(CHARON) version > .charon_version)
endif

.PHONY: all
all: format-check
	@ocamlfind list | grep -q charon || test -L lib/charon || echo "⚠️⚠️⚠️ Charon not found; we suggest run 'make setup-charon'"
	@ocamlfind list | grep -q krml || test -L lib/krml || echo "⚠️⚠️⚠️ krml not found; we suggest run 'make setup-karamel'"
	$(MAKE) build

.PHONY: build
build: check-karamel check-charon
	dune build && ln -sf _build/default/bin/main.exe eurydice

CFLAGS		:= -Wall -Werror -Wno-unused-variable -Wno-unused-but-set-variable $(CFLAGS) -I$(KRML_HOME)/include
CXXFLAGS	:= -std=c++17

test: $(addprefix test-,$(TEST_DIRS)) custom-test-libcrux-ml-kem-no-const custom-test-array custom-test-for testxx-result check-charon check-libcrux test-libcrux-ml-kem

clean-and-test:
	$(MAKE) clean-llbc
	$(MAKE) test

.PRECIOUS: %.llbc
%.llbc: %.rs .charon_version
	# --mir elaborated --add-drop-bounds 
	$(CHARON) rustc --preset=eurydice --dest-file "$@" $(CHARON_EXTRA) -- -Aunused $<

out/test-%/main.c: test/main.c
	mkdir -p out/test-$*
	sed 's/__NAME__/$*/g' $< > $@

test/issue_99.llbc: CHARON_EXTRA = \
  --include=core::option::*::as_ref

test/issue_105.llbc: CHARON_EXTRA = \
  --include=core::result::*::branch \
  --include=core::result::*::from_residual \
  --include=core::result::*::eq \
  --include=core::cmp::* \
  --include=core::convert::*

test/array2d.llbc: CHARON_EXTRA = --include=core::array::equality::*

test/core_num.llbc: CHARON_EXTRA = \
  --include=core::num::*::BITS \
  --include=core::num::*::MAX

test/println.llbc: CHARON_EXTRA = \
  --include=core::fmt::Arguments --include=core::fmt::rt::*::new_const \
  --include=core::fmt::rt::Argument

test/option.llbc: CHARON_EXTRA = \
  --include=core::option::*

test/lvalue.llbc: CHARON_EXTRA = \
  --mir elaborated

test-substr: EXTRA_C = -I../../test ../../test/substr_impl.c
test-substr: EXTRA = --config test/substr.yaml
test-partial_eq: EXTRA_C = ../../test/partial_eq_stubs.c
test-nested_arrays: EXTRA = -funroll-loops 0
test-array: EXTRA = -fcomments
test-symcrust: CFLAGS += -Wno-unused-function
test-more_str: EXTRA_C = ../../test/core_str_lib.c
test-more_primitive_types: EXTRA = --config test/more_primitive_types.yaml
test-global_ref: EXTRA_C = ../../test/core_cmp_lib.c
test-lvalue: CFLAGS += -Wno-unused-but-set-variable
test-issue_shift: CFLAGS += -fsanitize=undefined


test-%: test/%.llbc out/test-%/main.c | all
	$(EURYDICE) $(EXTRA) --output out/test-$* $<
	$(SED) -i 's/  KaRaMeL version: .*//' out/test-$*/**/*.{c,h} # This changes on every commit
	$(SED) -i 's/  KaRaMeL invocation: .*//' out/test-$*/**/*.{c,h} # This changes between local and CI
	cd out/test-$* && $(CC) $(CFLAGS) -I. -I../../include $(EXTRA_C) $*.c main.c && ./a.out

# C++ tests

out/testxx-%/main.cc: test/main.c
	mkdir -p out/testxx-$*
	sed 's/__NAME__/$*/g' $< > $@

testxx-%: test/%.llbc out/testxx-%/main.cc | all
	$(EURYDICE) $(EXTRA) -fc++17-compat --output out/testxx-$* $<
	$(SED) -i 's/  KaRaMeL version: .*//' out/testxx-$*/**/*.{c,h} # This changes on every commit
	$(SED) -i 's/  KaRaMeL invocation: .*//' out/testxx-$*/**/*.{c,h} # This changes between local and CI
	mv out/testxx-$*/$*.c out/testxx-$*/$*.cc
	cd out/testxx-$* && $(CXX) $(CXXFLAGS) $(CFLAGS) -I. -I../../include $(EXTRA_C) $*.cc main.cc && ./a.out

custom-test-array: test-array
	grep -q XXX1 out/test-array/array.c && \
	grep -q XXX2 out/test-array/array.c && \
	true

custom-test-for: test-for
	! grep -q while out/test-for/for.c

# libcrux tests

custom-test-libcrux-ml-kem-no-const: test/libcrux-ml-kem.llbc
	mkdir -p out/test-libcrux-ml-kem-no-const
	$(EURYDICE) --config test/libcrux-ml-kem/c.yaml -funroll-loops 16 \
	  $< --keep-going --output out/test-libcrux-ml-kem-no-const --no-const
	$(SED) -i 's/  KaRaMeL version: .*//' out/test-libcrux-ml-kem-no-const/**/*.{c,h} # This changes on every commit
	$(SED) -i 's/  KaRaMeL invocation: .*//' out/test-libcrux-ml-kem-no-const/**/*.{c,h} # This changes between local and CI

test-libcrux-%: test/libcrux-%.llbc
	mkdir -p out/test-libcrux-$*
	$(EURYDICE) --config test/libcrux-$*/c.yaml -funroll-loops 16 \
	  $< --keep-going --output out/test-libcrux-$*
	$(SED) -i 's/  KaRaMeL version: .*//' out/test-libcrux-$*/**/*.{c,h} # This changes on every commit
	$(SED) -i 's/  KaRaMeL invocation: .*//' out/test-libcrux-$*/**/*.{c,h} # This changes between local and CI
	cd test/libcrux-$*/ && cmake $(CMAKE_FLAGS) -B build -G "Ninja Multi-Config" && cmake --build build --config Debug
	cd test/libcrux-$*/ && ./build/Debug/$(subst -,_,$*)_test
	cd test/libcrux-$*/ && if [ -x ./build/Debug/sha3_test ]; then ./build/Debug/sha3_test; fi


.PHONY: .FORCE

test/libcrux-%.llbc: .FORCE
	@# Use our committed `Cargo.lock` by default.
	cp libcrux-Cargo.lock $(LIBCRUX_HOME)/Cargo.lock
	RUSTFLAGS="-Cdebug-assertions=no --cfg eurydice" $(CHARON) cargo --preset eurydice \
	  --include 'libcrux_sha3' \
	  --include 'libcrux_secrets' \
	  --include=core::option::* \
	  --rustc-arg='-Aunused' \
	  --start-from libcrux_$(subst -,_,$*) --start-from libcrux_sha3 \
	  --include 'core::num::*::BITS' --include 'core::num::*::MAX' \
	  --dest-file $$PWD/$@ -- \
	  --manifest-path $(LIBCRUX_HOME)/libcrux-$*/Cargo.toml \
	  --target=x86_64-apple-darwin
	@# Commit the `Cargo.lock` so that the nix CI can use it
	cp $(LIBCRUX_HOME)/Cargo.lock libcrux-Cargo.lock

.PRECIOUS: out/%
out/%:
	mkdir -p $@

.PHONY: check-dependencies
check-dependencies: check-karamel check-charon check-libcrux
# % can be "charon", "karamel" or "libcrux".
.PHONY: check-%
check-%:
	@bash ./scripts/check-dependency.sh "$*"
.PHONY: setup-%
setup-%:
	bash ./scripts/check-dependency.sh "$*" --force

.PHONY: nix-magic
nix-magic:
	nix flake update karamel charon libcrux --extra-experimental-features nix-command --extra-experimental-features flakes

nix-update-%:
	PROJECT_REMOTE=$(shell cd $* && git config --get remote.origin.url | cut -d ':' -f 2 | sed s/.git//g); \
	PROJECT_REV=$(shell cd $* && git rev-parse head); \
	nix flake update $* --override-input $* "github:$$PROJECT_REMOTE/$$PROJECT_REV"

# Updates `flake.lock` with the latest commit from our local charon clone (the one that is symlinked into `lib/charon`).
.PHONY: update-charon-pin
update-charon-pin:
	nix-shell -p jq --run ./scripts/update-charon-pin.sh

FORMAT_FILE=include/eurydice_glue.h

.PHONY: format-check
format-check:
	FORMAT_FILE=$(FORMAT_FILE) ./scripts/format.sh check

.PHONY: format-apply
format-apply:
	FORMAT_FILE=$(FORMAT_FILE) ./scripts/format.sh apply

.PHONY: clean-llbc
clean-llbc:
	rm test/*.llbc || true

debug-ppx-%: lib/%
	dune describe pp $<


================================================
FILE: README.md
================================================
<p><div style="text-align: center">
<img src="static/poussin.jpg"
     alt="Orphée et Eurydice" title="Orphée et Eurydice"
     style=""/>
<figcaption>
Nicolas Poussin, <i>Orphée et Eurydice</i>.
Musée du Louvre.
<a href="https://commons.wikimedia.org/wiki/File:Orph%C3%A9e_et_Eurydice_-_Nicolas_Poussin_-_Mus%C3%A9e_du_Louvre_Peintures_INV_7307.jpg">Source</a>
</figcaption>
</div></p>

# Eurydice

Eurydice is a compiler from Rust to C. The purpose of Eurydice is to provide a
backwards-compatibility story as the verification ecosystem gradually
transitions to Rust. New programs can be written in Rust, in turn making them
safer and easier to verify; but for legacy environments that cannot yet take a
dependency on the Rust toolchain, Eurydice allows generating C code as a stopgap
measure.

## Guarantee

Eurydice's informal guarantee is: if the Rust program terminates without
panicking, then the Eurydice-compiled C code computes the same result without
undefined behavior. If the Rust program panics (e.g., on signed integer
overflow, out-of-bounds array access), no guarantees are made about the behavior
of the generated C code.

Currently (late 2023), the flagship example for Eurydice is Kyber, a
Post-Quantum cryptographic algorithm authored and
verified in Rust for the general public, and [compiled to C via
Eurydice](https://github.com/cryspen/hacl-packages/tree/7a7bfbb17d1d912bdb1a80e86a917e1eec8b6264/libcrux/src)
for Mozilla's NSS library.

In terms of software architecture, Eurydice consumes Rust programs via the
[Charon](https://github.com/AeneasVerif/charon) infrastructure, then extracts
Rust to [KaRaMeL](https://github.com/FStarLang/karamel)'s internal AST via a
type-driven translation. Once in the KaRaMeL AST, 30+ nano-passes allow going
from Rust down to C code. About half of these passes were already implemented
for KaRaMeL, the rest of the passes reuse the KaRaMeL infrastructure but were
freshly written for Eurydice.

If you want to contribute or ask questions, we strongly encourage you to join
the [Zulip](https://aeneas-verif.zulipchat.com/).

# Install

We recommend using Nix to easily ensure you are running the right versions of the tools and
libraries. With nix, you can run:
```bash
$ nix run 'github:aeneasverif/eurydice#charon' -- [CHARON_OPTIONS]
$ nix run 'github:aeneasverif/eurydice' -- [EURYDICE_OPTIONS] <llbc_file>
```

Alternatively, you can do a local setup as follows.

```bash
# Step 1: install OCaml environment. Follow instructions, reload your shell, and make sure 
# `eval $(opam env)` has been suitably added to your shell profile.
sudo apt install opam cargo # or brew on OSX
opam init

# Step 2: clone eurydice
git clone https://github.com/AeneasVerif/eurydice
cd eurydice

# Step 3: install dependent projects
# This will clone karamel, charon and libcrux. If you intend to also develop on one of these
# projects, you can symlink your working copy (e.g. `ln -s ../my-charon charon`) instead.
# Note: the invocation for karamel might fail, in which case you want to install all the packages
# in the `depends` field of karamel.opam except fstar. At the time of writing, this means typing:
# opam install ocamlfind batteries zarith stdint yojson ocamlbuild fileutils menhir pprint ulex process fix visitors wasm ppx_deriving ppx_deriving_yojson uucp
make setup-karamel
make setup-charon
make setup-libcrux

# Step 4: ready!
make test
```

# Submitting a successful PR

The C output of the test suite is under version control, and your PR will fail CI if running `make
test` generates a diff for the C files in `out/`. The reason for this is that we need to assess the
impact of a PR on the shape of the generated C code. To make sure the output of the tests is
up-to-date, you can run `make -B test` to force regeneration of the C files.

Our CI will also check that your OCaml and C files have proper formatting -- the target `make
format-apply` reformats your source code to conform to our style guide. It might sometimes be
difficult to have the exact right versions of ocamlformat and clang-format -- in case your PR still
fails, we recommend running `nix develop` followed by `make format-apply`.


================================================
FILE: bin/dune
================================================
(executable
 (public_name eurydice)
 (name main)
 (libraries eurydice terminal))

(env
 (_
  (flags
   (:standard -w @1-2@3-7@8..12@14..21@23..29-30@31..38-39-40-41@43@57))))


================================================
FILE: bin/main.ml
================================================
let () =
  let usage =
    Printf.sprintf
      {|Eurydice: from Rust to C

Usage: %s [OPTIONS] FILES

FILES are .llbc files produced by Charon. Eurydice will generate one C file per
llbc file.

Supported options:|}
      Sys.argv.(0)
  in
  let module O = Eurydice.Options in
  let debug s =
    Krml.Options.debug_modules := Krml.KString.split_on_char ',' s @ !Krml.Options.debug_modules;
    if List.mem "backtrace" !Krml.Options.debug_modules then
      Krml.Options.backtrace := true
  in
  let funroll_loops = ref 16 in
  let spec =
    [
      "--log", Arg.Set_string O.log_level, " log level, use * for everything";
      "--debug", Arg.String debug, " debug options, to be passed to krml";
      "--output", Arg.Set_string Krml.Options.tmpdir, " output directory in which to write files";
      ( "--header",
        Arg.Set_string Krml.Options.header,
        " path to a header file to be prepended to the generated C" );
      "--config", Arg.Set_string O.config, " YAML configuration file";
      ( "--keep-going",
        Arg.Set O.keep_going,
        " keep going even though extracting some definitions might fail" );
      "--no-const", Arg.Set O.no_const, " do not introduce the const keyword for pointers";
      "-fcomments", Arg.Set O.comments, " keep inline comments";
      "-funroll-loops", Arg.Set_int funroll_loops, " unrool loops up to N";
      ( "-fc++17-compat",
        Arg.Set Krml.Options.cxx17_compat,
        " instead of generating C11/C++20 code (default), generate C++17-only code" );
    ]
  in
  let spec = Arg.align spec in
  let files = ref [] in
  let fatal_error =
    Printf.ksprintf (fun s ->
        print_endline s;
        exit 255)
  in
  let anon_fun f =
    if Filename.check_suffix f ".llbc" then
      files := f :: !files
    else
      fatal_error "Unknown file extension for %s" f
  in
  begin
    try Arg.parse spec anon_fun usage
    with e ->
      Printf.printf "Error parsing command-line: %s\n%s\n" (Printexc.get_backtrace ())
        (Printexc.to_string e);
      fatal_error "Incorrect invocation, was: %s\n" (String.concat "␣" (Array.to_list Sys.argv))
  end;

  if !files = [] then
    fatal_error "%s" (Arg.usage_string spec usage);

  let terminal_width =
    Terminal.Size.(
      match get_dimensions () with
      | Some d -> d.columns
      | None -> 80)
  in
  let pfiles b files =
    PPrint.(ToBuffer.pretty 0.95 terminal_width b (Krml.PrintAst.print_files files ^^ hardline))
  in
  let fail file line =
    Printf.printf "%s:%d exiting\n" file line;
    exit 1
  in

  (* This is where the action happens *)
  Eurydice.Logging.enable_logging !O.log_level;
  (* Type applications are compiled as a regular external type. *)
  Krml.(
    Options.(
      allow_tapps := true;
      minimal := true;
      curly_braces := true;
      add_very_early_include := [ All, "\"eurydice_glue.h\"" ];
      parentheses := true;
      no_shadow := true;
      extern_c := true;
      cxx_compat := true;
      unroll_loops := !funroll_loops;
      static_header :=
        [
          Bundle.Prefix [ "core"; "convert" ];
          Bundle.Prefix [ "core"; "num" ];
          Bundle.Prefix [ "Eurydice"; "Int128" ];
        ];
      Warn.parse_warn_error (!warn_error ^ "+8"));
    Monomorphization.NameGen.short_names := true;
    Monomorphization.NameGen.distinguished := Eurydice.Cleanup3.distinguished_names;
    AstToCStar.no_return_type_lids :=
      [
        [ "Eurydice" ], "slice_index_shared";
        [ "Eurydice" ], "slice_index_mut";
        [ "Eurydice" ], "slice_len";
        [ "Eurydice" ], "slice_copy";
        [ "Eurydice" ], "array_eq";
      ]);

  (* Some logic for more precisely tracking readonly functions, so as to remove
     excessive uu__ variables. *)
  let readonly_lids = Hashtbl.create 41 in
  let readonly_map = Hashtbl.create 41 in
  let fill_readonly_table files =
    List.iter
      (fun (_, decls) ->
        List.iter
          (function
            | Krml.Ast.DFunction (_, _, _, _, _, name, _, body) ->
                Hashtbl.add readonly_map name body
            | _ -> ())
          decls)
      files
  in

  Krml.(
    Helpers.is_readonly_builtin_lid_ :=
      let is_readonly_pure_lid_ = !Helpers.is_readonly_builtin_lid_ in
      fun lid t ->
        let ret_t, _ = Helpers.flatten_arrow t in
        is_readonly_pure_lid_ lid t
        || (match lid with
           | "libcrux_intrinsics" :: _, _ -> ret_t <> TUnit
           | [ "Eurydice" ], "vec_len"
           | [ "Eurydice" ], "vec_index"
           | [ "Eurydice" ], "slice_index_shared"
           | [ "Eurydice" ], "slice_index_mut"
           | [ "Eurydice" ], "slice_len"
           | [ "Eurydice" ], "slice_to_ref_array"
           | [ "Eurydice" ], "slice_to_ref_array2"
           | [ "Eurydice" ], "slice_subslice_shared"
           | [ "Eurydice" ], "slice_subslice_mut"
           | [ "Eurydice" ], "slice_subslice_to_shared"
           | [ "Eurydice" ], "slice_subslice_to_mut"
           | [ "Eurydice" ], "slice_subslice_from_shared"
           | [ "Eurydice" ], "slice_subslice_from_mut"
           | [ "Eurydice" ], "array_to_slice_shared"
           | [ "Eurydice" ], "array_to_slice_mut"
           | [ "Eurydice" ], "array_to_subslice_shared"
           | [ "Eurydice" ], "array_to_subslice_mut"
           | [ "Eurydice" ], "array_repeat"
           | [ "core"; "mem" ], "size_of"
           | "core" :: "slice" :: _, "as_mut_ptr"
           | "core" :: "num" :: _, ("rotate_left" | "from_le_bytes" | "wrapping_add") -> true
           | _ -> false)
        || Hashtbl.mem readonly_lids lid
        ||
        match Hashtbl.find_opt readonly_map lid with
        | Some body ->
            let ro = Helpers.is_readonly_c_expression body in
            if ro then
              Hashtbl.add readonly_lids lid ();
            ro
        | _ -> false);

  let files =
    Eurydice.Builtin.files
    @ [
        Eurydice.PreCleanup.merge
          (List.map
             (fun filename ->
               let llbc = Eurydice.LoadLlbc.load_file filename in
               Eurydice.AstOfLlbc.file_of_crate llbc)
             !files);
      ]
  in

  if !O.no_const then
    Printf.printf "⚠️  Not using 'const' for pointer types\n";
  Printf.printf "1️⃣ LLBC ➡️  AST\n";
  Eurydice.Logging.log "Phase0" "%a" pfiles files;
  let files = Eurydice.PreCleanup.precleanup files in

  Eurydice.Logging.log "Phase1" "%a" pfiles files;
  let errors, files = Krml.Checker.check_everything ~warn:true files in
  if errors then
    fail __FILE__ __LINE__;

  Printf.printf "2️⃣ Cleanup\n";
  let config =
    if !O.config = "" then
      None
    else
      Some (Eurydice.Bundles.parse_config (Eurydice.Bundles.load_config !O.config))
  in
  let files =
    match config with
    | None -> files
    | Some config ->
        let files = Eurydice.Bundles.bundle files config in
        let files = Eurydice.Bundles.libraries files in
        let files = Krml.Bundles.topological_sort files in
        Krml.KPrint.bprintf "File order after topological sort: %s\n"
          (String.concat ", " (List.map fst files));
        files
  in
  let files = Eurydice.Cleanup1.cleanup files in
  let files = Eurydice.Cleanup2.rewrite_signed_shifts files in

  Eurydice.Logging.log "Phase2" "%a" pfiles files;
  let errors, files = Krml.Checker.check_everything ~warn:true files in
  if errors then
    fail __FILE__ __LINE__;

  Printf.printf "3️⃣ Monomorphization, datatypes\n";
  let files = Eurydice.Cleanup2.cosmetic#visit_files () files in
  let files = Eurydice.Cleanup2.resugar_loops#visit_files () files in
  let files = Eurydice.Cleanup1.remove_terminal_returns#visit_files true files in
  let files = Eurydice.Cleanup1.remove_terminal_continues#visit_files false files in
  Eurydice.Logging.log "Phase2.1" "%a" pfiles files;
  (* Sanity check for the big rewriting above. *)
  let errors, files = Krml.Checker.check_everything ~warn:true files in
  if errors then
    fail __FILE__ __LINE__;
  Eurydice.Logging.log "Phase2.11" "%a" pfiles files;
  let files = Eurydice.Cleanup2.improve_names files in
  let files = Eurydice.Cleanup2.recognize_asserts#visit_files () files in
  (* Temporary workaround until Aeneas supports nested loops *)
  let files = Eurydice.Cleanup2.inline_loops#visit_files () files in
  (* Following the krml order of phases here *)
  let files = Krml.Inlining.inline_type_abbrevs files in
  let files = Krml.Monomorphization.functions files in
  Eurydice.Logging.log "Phase2.12" "%a" pfiles files;
  let files = Krml.Simplify.optimize_lets files in
  let files = Krml.DataTypes.simplify files in
  (* Must happen now, before Monomorphization.datatypes, because otherwise
     MonomorphizationState.state gets filled with lids that later on get eliminated on the basis
     that they were empty structs to begin with, which would send Checker off the rails *)
  let files = Krml.DataTypes.remove_empty_structs files in
  let files = Krml.Monomorphization.datatypes files in
  (* Cannot use remove_unit_buffers as it is technically incorrect *)
  let tbl = Hashtbl.create 41 in
  let files = (Krml.DataTypes.build_unit_field_table tbl)#visit_files () files in
  let files = (Krml.DataTypes.remove_unit_fields tbl)#visit_files () files in
  Eurydice.Logging.log "Phase2.13" "%a" pfiles files;
  let files = Krml.Inlining.inline files in
  let files =
    match config with
    | None -> files
    | Some config -> (
        let files = Eurydice.Bundles.reassign_monomorphizations files config in
        Eurydice.Logging.log "Phase2.15" "%a" pfiles files;
        try
          let files = Krml.Bundles.topological_sort files in
          files
        with e ->
          flush stdout;
          flush stderr;
          Krml.KPrint.bprintf "Error trying to topologically sort files:\n%s\n\n"
            (Printexc.to_string e);
          Krml.KPrint.bprintf "Consider passing --log Reassign to Eurydice\n";
          Krml.KPrint.bprintf "Internal AST before the error:\n%a\n" pfiles files;
          fail __FILE__ __LINE__)
  in
  Eurydice.Logging.log "Phase2.2" "%a" pfiles files;
  (* Sanity check for the big rewriting above. *)
  let errors, files = Krml.Checker.check_everything ~warn:true files in
  if errors then
    fail __FILE__ __LINE__;
  let files = Krml.Inlining.drop_unused files in
  let files = Eurydice.Cleanup2.remove_array_temporaries#visit_files () files in
  Eurydice.Logging.log "Phase2.25" "%a" pfiles files;
  let files = Eurydice.Cleanup2.remove_array_repeats#visit_files false files in
  Eurydice.Logging.log "Phase2.26" "%a" pfiles files;
  let ((map, _, _) as map3), files = Krml.DataTypes.everything files in
  Eurydice.Cleanup2.fixup_monomorphization_map map;
  let files = Eurydice.Cleanup2.remove_discriminant_reads map3 files in
  Eurydice.Logging.log "Phase2.3" "%a" pfiles files;
  let files = Eurydice.Cleanup2.remove_trivial_ite#visit_files () files in
  Eurydice.Logging.log "Phase2.4" "%a" pfiles files;
  let files = Eurydice.Cleanup2.remove_trivial_into#visit_files () files in
  Eurydice.Logging.log "Phase2.5" "%a" pfiles files;
  let files = Eurydice.Cleanup2.remove_literals files in
  (* Eurydice does something more involved than krml and performs a conservative
     approximation of functions that are known to be pure readonly (i.e.,
     functions that do not write to memory). *)
  fill_readonly_table files;
  let files = Krml.Simplify.optimize_lets files in
  Eurydice.Logging.log "Phase2.55" "%a" pfiles files;
  let files = Eurydice.Cleanup2.remove_array_from_fn files in
  Eurydice.Logging.log "Phase2.6" "%a" pfiles files;
  (* remove_array_from_fn, above, creates further opportunities for removing unused functions. *)
  let files = Krml.Inlining.drop_unused files in
  let files = Eurydice.Cleanup2.remove_implicit_array_copies#visit_files () files in
  (* Creates opportunities for removing unused variables *)
  let files = Eurydice.Cleanup2.remove_assign_return#visit_files () files in
  (* These two need to come before... *)
  let files = Krml.Inlining.cross_call_analysis files in
  let files = Krml.Simplify.remove_unused files in
  Eurydice.Logging.log "Phase2.7" "%a" pfiles files;
  (* This chunk which reuses key elements of simplify2 *)
  let files = Eurydice.Cleanup2.check_addrof#visit_files () files in
  let files = Krml.Simplify.sequence_to_let#visit_files () files in
  let files = Eurydice.Cleanup2.hoist#visit_files [] files in
  let files = Eurydice.Cleanup2.fixup_hoist#visit_files () files in
  Eurydice.Logging.log "Phase2.75" "%a" pfiles files;
  let files = Eurydice.Cleanup2.globalize_global_locals files in
  Eurydice.Logging.log "Phase2.8" "%a" pfiles files;
  let files = Eurydice.Cleanup2.reconstruct_for_loops#visit_files () files in
  let files = Krml.Simplify.misc_cosmetic#visit_files () files in
  let files = Krml.Simplify.let_to_sequence#visit_files () files in
  Eurydice.Logging.log "Phase2.9" "%a" pfiles files;
  let files = Eurydice.Cleanup2.float_comments files in
  Eurydice.Logging.log "Phase2.95" "%a" pfiles files;
  let files = Eurydice.Cleanup2.bonus_cleanups#visit_files [] files in
  (* Macros stemming from globals -- FIXME why is this not Krml.AstToCStar.mk_macros_set? *)
  let files, macros = Eurydice.Cleanup2.build_macros files in

  Eurydice.Logging.log "Phase3" "%a" pfiles files;
  (* debug "checker"; *)
  let errors, files = Krml.Checker.check_everything ~warn:true files in
  if errors then
    fail __FILE__ __LINE__;

  let scope_env = Krml.Simplify.allocate_c_env files in
  Eurydice.Cleanup3.(also_skip_prefix_for_external_types scope_env)#visit_files () files;
  let files = Eurydice.Cleanup3.decay_cg_externals#visit_files (scope_env, false) files in
  let files = Eurydice.Cleanup3.remove_builtin_decls files in
  Eurydice.Logging.log "Phase3.1" "%a" pfiles files;
  let c_name_map = Krml.GlobalNames.mapping (fst scope_env) in

  let open Krml in
  let file_of_map = Bundle.mk_file_of files in
  let deps = Bundles.direct_dependencies_with_internal files file_of_map in
  let files =
    List.map
      (fun (f, ds) ->
        let is_fine = function
          | [ "LowStar"; "Ignore" ], "ignore" | "Eurydice" :: _, _ ->
              (* | "core" :: _, _ -> *)
              true
          | _ -> false
        in
        ( f,
          List.filter_map
            (fun d ->
              match d with
              | Krml.Ast.DExternal (_, _, _, _, lid, t, _)
                when Krml.Monomorphization.(
                       (has_variables [ t ] || has_cg_array [ t ]) && not (is_fine lid)) ->
                  KPrint.bprintf
                    "Warning: %a is a type/const-polymorphic assumed function, must be implemented \
                     with a macro, dropping it\n"
                    Krml.PrintAst.Ops.plid lid;
                  None
              | _ -> Some d)
            ds ))
      files
  in
  Eurydice.Logging.log "Phase3.2" "%a" pfiles files;

  (* The following phase reads the "target" parameter for each file, if any, from the config
     and if set, then it adds the attribute `KRML_ATTRIBUTE_TARGET(target)` to each function
     in the generated C file. This is used, in particular, to mark certain functions as only
     to be compiled on target architectures like `avx2` *)
  let files =
    List.map
      (fun (f, ds) ->
        let open Eurydice.Bundles in
        let target_attribute =
          match config with
          | None -> ""
          | Some c -> (
              match List.find_opt (fun (x : file) -> x.name = f) c with
              | None -> ""
              | Some f -> f.target)
        in
        ( f,
          List.filter_map
            (fun d ->
              match d with
              | Krml.Ast.DFunction (cc, fl, x, y, t, l, b, e) when target_attribute <> "" ->
                  Some (Krml.Ast.DFunction (cc, fl @ [ Target target_attribute ], x, y, t, l, b, e))
              | _ -> Some d)
            ds ))
      files
  in

  Eurydice.Logging.log "Phase3.3" "%a" pfiles files;
  let files =
    List.map
      (fun (f, ds) ->
        ( f,
          List.filter
            (fun d -> not (Krml.Idents.LidSet.mem (Krml.Ast.lid_of_decl d) Eurydice.Builtin.skip))
            ds ))
      files
  in
  let files = AstToCStar.mk_files files c_name_map Idents.LidSet.empty macros in

  (* Uncomment to debug C* AST *)
  (* List.iter *)
  (*   (fun (f, p) -> *)
  (*     print_endline f; *)
  (*     print_endline (CStar.show_program p); *)
  (*     print_endline "") *)
  (*   files; *)
  let headers = CStarToC11.mk_headers c_name_map files in
  let deps = CStarToC11.drop_empty_headers deps headers in
  let internal_headers =
    Bundles.StringSet.of_list
      (List.filter_map
         (function
           | name, C11.Internal _ -> Some name
           | _ -> None)
         headers)
  in
  let public_headers =
    Bundles.StringSet.of_list
      (List.filter_map
         (function
           | name, C11.Public _ -> Some name
           | _ -> None)
         headers)
  in
  let files = CStarToC11.mk_files c_name_map files in
  let files = List.filter (fun (_, decls) -> List.length decls > 0) files in
  Krml.Output.maybe_create_internal_dir headers;
  Krml.Driver.fstar := "dummy";
  ignore (Output.write_c files internal_headers deps);
  ignore (Output.write_h headers public_headers deps);

  Printf.printf "✅ Done\n"


================================================
FILE: cremepat/Lex.ml
================================================
open Sedlexing
open Parse

let digit = [%sedlex.regexp? '0' .. '9']
let integer = [%sedlex.regexp? Plus digit]
let low_alpha = [%sedlex.regexp? 'a' .. 'z']
let up_alpha = [%sedlex.regexp? 'A' .. 'Z']
let anyident = [%sedlex.regexp? up_alpha | low_alpha | '_' | '-' | digit]
let lident = [%sedlex.regexp? low_alpha, Star anyident]
let uident = [%sedlex.regexp? up_alpha, Star anyident]
let uvar = [%sedlex.regexp? '?', Star anyident]
let uvarlist = [%sedlex.regexp? '?', Star anyident, '.', '.']
let locate _ tok = tok, Lexing.dummy_pos, Lexing.dummy_pos

let keywords =
  [
    "match", MATCH;
    "true", TRUE;
    "break", BREAK;
    "false", FALSE;
    "while", WHILE;
    "let", LET;
    "abort", ABORT;
  ]

let lines = ref 1
let cur_line = ref 0

let rec token lexbuf =
  match%sedlex lexbuf with
  | integer ->
      let l = Utf8.lexeme lexbuf in
      locate lexbuf (INT (int_of_string l))
  | uident ->
      let l = Utf8.lexeme lexbuf in
      locate lexbuf (UIDENT l)
  | lident ->
      let l = Utf8.lexeme lexbuf in
      begin
        try locate lexbuf (List.assoc l keywords) with Not_found -> locate lexbuf (LIDENT l)
      end
  | uvar ->
      let l = Utf8.lexeme lexbuf in
      let l = String.sub l 1 (String.length l - 1) in
      locate lexbuf (UVAR l)
  | uvarlist ->
      let l = Utf8.lexeme lexbuf in
      let l = String.sub l 1 (String.length l - 3) in
      locate lexbuf (UVARLIST l)
  | "&" -> locate lexbuf AMP
  | ";" -> locate lexbuf SEMI
  | "->" -> locate lexbuf ARROW
  | "," -> locate lexbuf COMMA
  | "=" -> locate lexbuf EQUALS
  | "[#" -> locate lexbuf LBRACKHASH
  | "[" -> locate lexbuf LBRACK
  | "]" -> locate lexbuf RBRACK
  | "<" -> locate lexbuf LANGLE
  | ">" -> locate lexbuf RANGLE
  | "{" -> locate lexbuf LCURLY
  | "}" -> locate lexbuf RCURLY
  | "(#" -> locate lexbuf LPARENHASH
  | "(" -> locate lexbuf LPAREN
  | ")" -> locate lexbuf RPAREN
  (* | "_" -> locate lexbuf UNDERSCORE *)
  | "::" -> locate lexbuf COLONCOLON
  | ":" -> locate lexbuf COLON
  | "\n" ->
      incr lines;
      cur_line := fst (loc lexbuf);
      token lexbuf
  | eof -> locate lexbuf EOF
  | white_space -> token lexbuf
  | any ->
      let l = Utf8.lexeme lexbuf in
      failwith (Printf.sprintf "unhandled token: %s, len=%d" l (String.length l))
  | _ -> assert false


================================================
FILE: cremepat/Parse.mly
================================================
%{
  open ParseTree
%}

%token<int>     INT
%token<string>  UIDENT LIDENT UVAR UVARLIST
%token          EOF COMMA EQUALS LBRACK RBRACK LBRACKHASH LANGLE RANGLE LCURLY RCURLY
%token          COLON COLONCOLON AMP LPAREN RPAREN LPARENHASH SEMI
%token          MATCH TRUE FALSE LET WHILE BREAK ARROW ABORT

%type <expr> expr
%type <path_item> path_item
%type <pat> pat
%type <typ> typ
%start <expr> fragment

%%

(* Identifiers *)

%inline
uident:
| u = UIDENT
  { u }

%inline
lident:
| l = LIDENT
  { l }

%inline
ident:
| s = LIDENT
  { s }
| s = UIDENT
  { s }

(* Paths *)

path_item:
| i = ident
  { Name i }
| p = UVAR
  { if p = "" then Wild else Var p }
| _p = UVARLIST
  { failwith "TODO" }

%inline
path:
| p = iseparated_twoplus_list(COLONCOLON, path_item)
  { p }

(* Helpers *)
%inline iseparated_twoplus_list(separator, X):
  x1 = X; separator; x2 = X
    { [ x1; x2 ] }
| x1 = X; separator; x2 = X; separator; xs = separated_nonempty_list(separator, X)
    { x1 :: x2 :: xs }

%inline
with_vars(X):
| x = UVAR
  { PatternVar (if x = "" then "_" ^ gensym () else x) }
| x = UVARLIST
  { ListPatternVar (if x = "" then "_" ^ gensym () else x) }
| x = X
  { Fixed x }

%inline
fixed(X):
| x = X
  { Fixed x }

(* Types *)

pre_typ:
| t = typ ts = delimited(LANGLE, separated_list(COMMA, typ), RANGLE)
  { TApp (t, ts) }
| p = path
  { TQualified p }

typ:
| t = with_vars(pre_typ)
  { t }

(* Patterns *)

pre_pat:
| u = uident
  { Cons (u, []) }
| u = uident p = delimited(LPAREN, separated_list(COMMA, pat), RPAREN)
  { Cons (u, p) }
| u = uident p = pat
  { Cons (u, [ p ]) }

pat:
| t = with_vars(pre_pat)
  { t }

(* Expressions *)

expr:
| e = fixed(pre_expr)
  { e }
| e = seq_expr
  { e }

pre_expr:
| LET b = lident EQUALS e1 = app_expr SEMI e2 = expr
  { Let (b, e1, e2) }

seq_expr:
| e = fixed(pre_seq_expr)
  { e }
| e = app_expr
  { e }

pre_seq_expr:
| e1 = app_expr SEMI e2 = seq_expr
  { match e2 with Fixed (Sequence e2) -> Sequence (e1 :: e2) | _ -> Sequence [ e1; e2 ] }

app_expr:
| e = fixed(pre_app_expr)
  { e }
| e = index_expr
  { e }

pre_app_expr:
| head = app_expr
  cgs = ioption(delimited(LBRACKHASH, separated_list(COMMA, expr), RBRACK))
  methods = ioption(delimited(LPARENHASH, separated_list(COMMA, expr), RPAREN))
  ts = ioption(delimited(LANGLE, separated_list(COMMA, typ), RANGLE))
  args = delimited(LPAREN, separated_list(COMMA, expr), RPAREN)
  {
    let cgs = Option.value ~default:[] cgs in
    let methods = Option.value ~default:[] methods in
    let ts = Option.value ~default:[] ts in
    App { head; cgs; methods; ts; args }
  }
| AMP e = index_expr
  { Addr e }

index_expr:
| e = fixed(pre_index_expr)
  { e }
| e = atomic_expr
  { e }

pre_index_expr:
| e1 = index_expr e2 = delimited(LBRACK, expr, RBRACK)
  { Index (e1, e2) }

atomic_expr:
| e = with_vars(pre_atomic_expr)
  { e }
| e = delimited(LPAREN, expr, RPAREN)
  { e }

pre_atomic_expr:
| WHILE e1 = index_expr e2 = delimited(LCURLY, expr, RCURLY)
  { While (e1, e2) }
| MATCH e = index_expr bs = delimited(LCURLY, separated_list(COMMA, separated_pair(pat, ARROW, expr)), RCURLY)
  { Match (e, bs) }
| e = delimited(LCURLY, separated_nonempty_list(COMMA, separated_pair(lident, COLON, expr)), RCURLY)
  { Record e }
| i = INT 
  { Int i }
| p = path
  { Qualified p }
| x = lident
  { BoundVar x }
| BREAK
  { Break }
| ABORT
  { Abort }
| FALSE
  { Bool false }
| TRUE
  { Bool true }

(* Entry point *)
fragment:
| e = expr EOF
  { e }



================================================
FILE: cremepat/ParseTree.ml
================================================
(* Strictly a parse tree *)
type pre_expr =
  (* Binding most loosely *)
  | Let of string * expr * expr
  | Sequence of expr list
  | App of { head : expr; cgs : expr list; methods : expr list; ts : typ list; args : expr list }
  | Addr of expr
  | Index of expr * expr
  (* Atomic -- we terminate matches and loops using braces, we are not barbarians. *)
  | While of expr * expr
  | Match of expr * branch list
  | Record of (string * expr) list
  | Int of int
  | Qualified of path
  | BoundVar of string
  | Break
  | Abort
  | Bool of bool

and expr = pre_expr with_vars
and 'a with_vars = PatternVar of string | ListPatternVar of string | Fixed of 'a
and path = path_item list
and path_item = Name of string | Wild | Var of string
and branch = pat * expr
and pre_pat = Cons of string * pat list
and pat = pre_pat with_vars
and pre_typ = TQualified of path | TApp of typ * typ list
and typ = pre_typ with_vars

let gensym =
  let r = ref 0 in
  fun () ->
    incr r;
    "$x" ^ string_of_int !r


================================================
FILE: cremepat/README.md
================================================
CREMEPAT: CREdible, Meta-Extensible PATterns
--------------------------------------------

Write concrete syntax instead of 50 lines of deeply-embedded pattern matches. See lib/Cleanup2.ml


================================================
FILE: cremepat/cremepat.ml
================================================
module Terminal = struct
  let mkcolor x = Printf.sprintf "\x1b[38;5;%dm" x
  let green = mkcolor 119
  let red = mkcolor 203
  let blue = mkcolor 81
  let yellow = mkcolor 227
  let orange = mkcolor 202
  let underline = "\x1b[4m"
  let reset = "\x1b[0m"
end

let fail fmt =
  let b = Buffer.create 256 in
  Printf.kbprintf (fun b -> failwith (Buffer.contents b)) b fmt

let parse arg =
  let the_parser = MenhirLib.Convert.Simplified.traditional2revised Parse.fragment in
  let lexbuf = Sedlexing.Utf8.from_string arg in
  try the_parser (fun _ -> Lex.token lexbuf) with
  | (Sedlexing.MalFormed | Sedlexing.InvalidCodepoint _) as e ->
      Printf.eprintf "Lexing error in: %s\n" arg;
      raise e
  | Parse.Error as e ->
      let start, end_ = Sedlexing.loc lexbuf in
      let start = start - !Lex.cur_line in
      let end_ = end_ - !Lex.cur_line in
      let buf = Buffer.create 256 in
      List.iteri
        (fun i line ->
          Buffer.add_string buf line;
          Buffer.add_char buf '\n';
          if i + 1 = !Lex.lines then begin
            Buffer.add_string buf Terminal.red;
            for _j = 0 to start do
              Buffer.add_char buf ' '
            done;
            for _j = start to end_ - 1 do
              Buffer.add_char buf '^'
            done;
            Buffer.add_string buf Terminal.reset;
            Buffer.add_char buf '\n'
          end)
        (String.split_on_char '\n' arg);
      Printf.eprintf "Parse error, line %d, characters %d-%d: %s\n" !Lex.lines start end_
        (Buffer.contents buf);
      raise e

open Ppxlib

(* Environments for the compile-time compilation of parse trees to OCaml pattern ASTs *)

type env = string list

let empty = []
let push env x = x :: env

let find env x =
  let exception Found of int in
  try
    List.iteri
      (fun i x' ->
        if x = x' then
          raise (Found i))
      env;
    raise Not_found
  with Found i -> i

(* Helpers to build nodes *)

let lident ~loc x = { txt = Lident x; loc }

let rec ppat_list ~loc pats =
  let open Ast_builder.Default in
  List.fold_right
    (fun pat acc -> ppat_construct ~loc (lident ~loc "::") (Some (ppat_tuple ~loc [ pat; acc ])))
    pats
    (ppat_construct ~loc (lident ~loc "[]") None)

(* Variants for things that are not expressions (i.e. not 'a nodes) *)

let ppat_cons_many' ~loc cons args =
  let open Ast_builder.Default in
  ppat_construct ~loc (lident ~loc cons) (Some (ppat_tuple ~loc args))

let ppat_cons_one' ~loc cons arg =
  let open Ast_builder.Default in
  ppat_construct ~loc (lident ~loc cons) (Some arg)

let ppat_cons_zero' ~loc cons =
  let open Ast_builder.Default in
  ppat_construct ~loc (lident ~loc cons) None

let ppat_string ~loc s =
  let open Ast_builder.Default in
  ppat_constant ~loc (Pconst_string (s, loc, None))

let ppat_int ~loc s =
  let open Ast_builder.Default in
  ppat_constant ~loc (Pconst_integer (string_of_int s, None))

let ppat_bool ~loc s = ppat_cons_zero' ~loc (string_of_bool s)

(* Variants that produce the { node = ...; _ } part automatically *)

let ppat_node ~loc pat =
  let open Ast_builder.Default in
  ppat_record ~loc [ lident ~loc "node", pat ] Open

let ppat_cons_many ~loc cons args = ppat_node ~loc (ppat_cons_many' ~loc cons args)
let ppat_cons_one ~loc cons arg = ppat_node ~loc (ppat_cons_one' ~loc cons arg)
let ppat_cons_zero ~loc cons = ppat_node ~loc (ppat_cons_zero' ~loc cons)

let compile_parse_tree (env : env) loc
    (pt : ParseTree.expr) (* : Astlib.Ast_503.Parsetree.pattern *) =
  let open Ast_builder.Default in
  (* Helpers *)

  (* Compiling a node where only non-list unification variables may appear *)
  let rec compile_with_var : 'a. env -> 'a ParseTree.with_vars -> (env -> 'a -> _) -> _ =
   fun env pt compile_pre ->
    match pt with
    | Fixed e -> compile_pre env e
    | PatternVar txt -> ppat_var ~loc { txt; loc }
    | ListPatternVar s -> fail "[cremepat]: list pattern ?%s.. appears in unexpected position" s
  (* Special treatment for lists of 'a that are allowed to contain list unification variables --
     recurse into one of the specialized variants of this for AST positions that admit lists. Note
     that the syntax does not enforce that list unification variables only appear where allowed --
     there is some implicit typing depending on whether you recurse via compile_with_var or
     compile_list_pattern. *)
  and compile_list_pattern : 'a. env -> 'a ParseTree.with_vars list -> (env -> 'a -> _) -> _ =
   fun env pts compile_pre ->
    match pts with
    | [] -> ppat_construct ~loc (lident ~loc "[]") None
    | ListPatternVar txt :: [] -> ppat_var ~loc { txt; loc }
    | ListPatternVar s :: _ ->
        fail "[cremepat]: list pattern ?%s.. should only appear in tail position" s
    | PatternVar txt :: pts ->
        ppat_construct ~loc (lident ~loc "::")
          (Some
             (ppat_tuple ~loc
                [ ppat_var ~loc { txt; loc }; compile_list_pattern env pts compile_pre ]))
    | Fixed pt :: pts ->
        ppat_construct ~loc (lident ~loc "::")
          (Some (ppat_tuple ~loc [ compile_pre env pt; compile_list_pattern env pts compile_pre ]))
  and compile env pt = compile_with_var env pt compile_pre_expr
  and compile_expr_list_pattern env pt = compile_list_pattern env pt compile_pre_expr
  and compile_pre_expr env pt =
    match pt with
    | ParseTree.Let (b, e1, e2) ->
        let p1 = compile env e1 in
        let env = push env b in
        let p2 = compile env e2 in
        (* ELet (_, p1, p2) *)
        ppat_cons_many ~loc "ELet" [ ppat_any ~loc; p1; p2 ]
    | Sequence ps -> ppat_cons_one ~loc "ESequence" (compile_expr_list_pattern env ps)
    | App { head; cgs; methods; ts; args } ->
        (* EApp (ETApp (e, ts), es) *)
        ppat_cons_many ~loc "EApp"
          [
            ppat_cons_many ~loc "ETApp"
              [
                compile env head;
                compile_expr_list_pattern env cgs;
                compile_expr_list_pattern env methods;
                compile_typ_list_pattern env ts;
              ];
            ppat_list ~loc (List.map (compile env) args);
          ]
    | Addr e -> ppat_cons_one ~loc "EAddrOf" (compile env e)
    | Index (e1, e2) ->
        let p1 = compile env e1 in
        let p2 = compile env e2 in
        ppat_cons_many ~loc "EBufRead" [ p1; p2 ]
    | While (e1, e2) ->
        let p1 = compile env e1 in
        let p2 = compile env e2 in
        ppat_cons_many ~loc "EWhile" [ p1; p2 ]
    | Match (e, bs) ->
        let e = compile env e in
        ppat_cons_many ~loc "EMatch"
          [
            ppat_any ~loc;
            (* no syntax to match on match flavor *)
            e;
            ppat_list ~loc
              (List.map
                 (fun (p, e) ->
                   let p = compile_pat env p in
                   let e = compile env e in
                   ppat_tuple ~loc
                     [ ppat_any ~loc; (* no syntax to match on binders in patterns *) p; e ])
                 bs);
          ]
    | Record es ->
        ppat_cons_one ~loc "EFlat"
          (ppat_list ~loc
             (List.map
                (fun (f, e) ->
                  ppat_tuple ~loc [ ppat_cons_one' ~loc "Some" (ppat_string ~loc f); compile env e ])
                es))
    | Int i ->
        ppat_cons_many ~loc "EConstant"
          [
            ppat_any ~loc;
            (* no syntax to match on width of constants *)
            ppat_string ~loc (string_of_int i);
          ]
    | Qualified path -> ppat_cons_one ~loc "EQualified" (compile_path env path)
    | BoundVar s ->
        let i = find env s in
        ppat_cons_one ~loc "EBound" (ppat_int ~loc i)
    | Break -> ppat_cons_zero ~loc "EBreak"
    | Bool b -> ppat_cons_one ~loc "EBool" (ppat_bool ~loc b)
    | Abort -> ppat_cons_many ~loc "EAbort" [ ppat_any ~loc; ppat_any ~loc ]
  (* Paths *)
  and compile_path env (pt : ParseTree.path) =
    let m, n =
      match List.rev pt with
      | n :: m -> List.rev m, n
      | _ -> failwith "impossible"
    in
    ppat_tuple ~loc [ ppat_list ~loc (List.map (compile_path_item env) m); compile_path_item env n ]
  and compile_path_item _env (pt : ParseTree.path_item) =
    match pt with
    | Wild -> ppat_any ~loc
    | Name s -> ppat_string ~loc s
    | Var txt -> ppat_var ~loc { txt; loc }
  (* Types *)
  and _compile_typ env pt = compile_with_var env pt compile_pre_typ
  and compile_typ_list_pattern env (es : ParseTree.typ list) =
    compile_list_pattern env es compile_pre_typ
  and compile_pre_typ env (pt : ParseTree.pre_typ) =
    match pt with
    | TQualified path -> ppat_cons_one' ~loc "TQualified" (compile_path env path)
    | TApp (Fixed (TQualified p), ts) ->
        ppat_cons_many' ~loc "TApp" [ compile_path env p; compile_typ_list_pattern env ts ]
    | TApp (PatternVar p, ts) ->
        ppat_cons_many' ~loc "TApp"
          [ ppat_var ~loc { txt = p; loc }; compile_typ_list_pattern env ts ]
    | TApp (_, _) -> failwith "incorrect type application left-hand side"
  (* Patterns *)
  and compile_pat env pt = compile_with_var env pt compile_pre_pat
  and compile_pat_list_pattern env (es : ParseTree.pat list) =
    compile_list_pattern env es compile_pre_pat
  and compile_pre_pat env (pt : ParseTree.pre_pat) =
    match pt with
    | Cons (cons, ps) ->
        ppat_cons_many ~loc "PCons" [ ppat_string ~loc cons; compile_pat_list_pattern env ps ]
  in

  compile env pt

let expand ~ctxt (payload : string) =
  let pt = parse payload in
  let loc = Expansion_context.Extension.extension_point_loc ctxt in
  compile_parse_tree empty loc pt

let my_extension =
  Extension.V3.declare "cremepat" Pattern Ast_pattern.(single_expr_payload (estring __)) expand

let rule = Ppxlib.Context_free.Rule.extension my_extension
let () = Driver.register_transformation ~rules:[ rule ] "cremepat"


================================================
FILE: cremepat/dune
================================================
(library
 (name cremepat)
 (kind ppx_rewriter)
 (libraries ppxlib menhirLib)
 (preprocess
  (pps sedlex.ppx))
 (flags
  (:standard
   -warn-error
   -A
   -w
   @1-2@3-7@8..12@14..21@23..29-30@31..38-39-40-41@43@57)))

(menhir
 (modules Parse))

; (flags --trace))


================================================
FILE: dune
================================================
(data_only_dirs charon karamel libcrux)


================================================
FILE: dune-project
================================================
(lang dune 3.13)

(name eurydice)

(generate_opam_files true)

(source
 (github AeneasVerif/eurydice))

(authors "Son Ho" "Jonathan Protzenko")

(maintainers "Son Ho" "Jonathan Protzenko")

(license Apache-2.0)

(package
 (name eurydice)
 (synopsis "A Rust to C translator")
 (description "Eurydice builds upon Charon to take existing Rust code and
              translate it to C")
 (depends
  ocaml
  dune
  yaml
  (terminal (>= 0.4.0))
 )
)

(using menhir 3.0)


================================================
FILE: eurydice.opam
================================================
# This file is generated by dune, edit dune-project instead
opam-version: "2.0"
synopsis: "A Rust to C translator"
description: """
Eurydice builds upon Charon to take existing Rust code and
              translate it to C"""
maintainer: ["Son Ho" "Jonathan Protzenko"]
authors: ["Son Ho" "Jonathan Protzenko"]
license: "Apache-2.0"
homepage: "https://github.com/AeneasVerif/eurydice"
bug-reports: "https://github.com/AeneasVerif/eurydice/issues"
depends: [
  "ocaml"
  "dune" {>= "3.13"}
  "yaml"
  "terminal" {>= "0.4.0"}
  "odoc" {with-doc}
]
build: [
  ["dune" "subst"] {dev}
  [
    "dune"
    "build"
    "-p"
    name
    "-j"
    jobs
    "@install"
    "@runtest" {with-test}
    "@doc" {with-doc}
  ]
]
dev-repo: "git+https://github.com/AeneasVerif/eurydice.git"


================================================
FILE: flake.nix
================================================
{
  inputs = {
    nixpkgs.follows = "charon/nixpkgs";
    flake-utils.follows = "karamel/flake-utils";
    karamel.url = "github:FStarLang/karamel";
    karamel.inputs.nixpkgs.follows = "nixpkgs";

    charon.url = "github:AeneasVerif/charon";
    crane.follows = "charon/crane";

    libcrux.url = "github:cryspen/libcrux";
    googletest.follows = "libcrux/googletest";
    benchmark.follows = "libcrux/benchmark";
    json.follows = "libcrux/json";
  };
  outputs =
    { self
    , flake-utils
    , nixpkgs
    , ...
    } @ inputs:
    flake-utils.lib.eachDefaultSystem (system:
    let
      pkgs = import nixpkgs { inherit system; };

      karamel = inputs.karamel.packages.${system}.default.override {
        ocamlPackages = pkgs.ocamlPackages;
      };
      krml = karamel.passthru.lib;

      charon-packages = inputs.charon.packages.${system};
      charon-ml = charon-packages.charon-ml.override {
        ocamlPackages = pkgs.ocamlPackages;
      };
      charon = charon-packages.default;
      craneLib = (inputs.crane.mkLib pkgs).overrideToolchain charon-packages.rustToolchain;

      package =
        { ocamlPackages
        , removeReferencesTo
        , clangStdenv
        , symlinks
        , version
        , which
        , z3
        , cmake
        , git
        , mold-wrapped
        , ninja
        , gnugrep
        , charon
        , charon-ml
        , krml
        , symlinkJoin
        , clang
        , craneLib
        }:
        let
          eurydice = ocamlPackages.buildDunePackage {
            pname = "eurydice";
            inherit version;

            src = ./.;

            nativeBuildInputs = [ gnugrep ] ++ (with ocamlPackages; [ menhir ]);

            propagatedBuildInputs = [ krml charon-ml ocamlPackages.terminal ocamlPackages.yaml ] ++ (with ocamlPackages; [ menhirLib ]);

            postInstall = ''
              ln -s ${charon}/bin/charon $out/bin/charon
            '';

            passthru = {
              tests = clangStdenv.mkDerivation rec {
                name = "tests";
                src = ./.;
                IN_CI = 1; # Tell the `check-dependency` script to not check for charon/karamel commit hashes.
                KRML_HOME = karamel.src;
                EURYDICE = "${eurydice}/bin/eurydice";
                CHARON = "${charon}/bin/charon";
                CMAKE_FLAGS = [
                  "-DFETCHCONTENT_SOURCE_DIR_GOOGLETEST=${inputs.googletest}"
                  "-DFETCHCONTENT_SOURCE_DIR_BENCHMARK=${inputs.benchmark}"
                  "-DFETCHCONTENT_SOURCE_DIR_JSON=${inputs.json}"
                  "-DFETCHCONTENT_FULLY_DISCONNECTED=ON"
                ];

                # Pre-build the cargo dependencies; required for `cargo` to
                # work inside nix since nix builders don't have network
                # access.
                cargoVendorDir = craneLib.vendorCargoDeps { cargoLock = ./libcrux-Cargo.lock; };
                cargoArtifacts = craneLib.buildDepsOnly {
                  src = inputs.libcrux.sourceInfo.outPath;
                  inherit cargoVendorDir;
                  # Only build the libcrux-ml-kem package.
                  cargoExtraArgs = "-p libcrux-ml-kem";
                  # Run `cargo check` too, to make sure we include the dev-dependencies.
                  doCheck = true;
                };

                nativeBuildInputs = [
                  cmake
                  git
                  mold-wrapped
                  ninja
                  # Crane hooks that will use the
                  # `cargoArtifacts`/`cargoVendorDir` to tell cargo where to
                  # find its dependencies.
                  craneLib.configureCargoCommonVarsHook
                  craneLib.configureCargoVendoredDepsHook
                  craneLib.inheritCargoArtifactsHook
                  pkgs.zstd # For the inheritCargoArtifactsHook hooks.
                ];
                buildInputs = [ eurydice ];

                dontUseCmakeConfigure = true;
                buildPhase = ''
                  # Prepare the libcrux directory.
                  cp --no-preserve=mode,ownership -rf ${inputs.libcrux.sourceInfo.outPath} libcrux
                  # Symlink karamel so we find its headers.
                  ln -s $KRML_HOME karamel

                  # Run the tests
                  make -o all test

                  # Remove generated files that we don't want to compare.
                  shopt -s globstar
                  rm -f out/**/a.out
                  # Check that there are no differences between the generated
                  # outputs and the committed outputs.
                  if diff -rq "${./out}" out; then
                    echo "Ok: the regenerated files are the same as the checked out files"
                  else
                    echo "Error: the regenerated files differ from the checked out files"
                    diff -ru "${./out}" out
                    exit 1
                  fi
                '';
                installPhase = ''touch $out'';
              };
            };
          };
        in
        eurydice;
    in
    rec {
      packages = {
        default = pkgs.callPackage package {
          inherit charon charon-ml krml craneLib;
          version = self.rev or "dirty";
        };
        inherit charon karamel;
      };
      checks = {
        default = packages.default.tests;
        format = pkgs.runCommand "format-check"
          {
            src = ./.;
            nativeBuildInputs = [
              pkgs.bash
              pkgs.gnumake
              pkgs.llvmPackages_18.clang-tools # For clang-format
              pkgs.ocamlPackages.ocaml
              pkgs.ocamlPackages.ocamlformat_0_27_0
              pkgs.ocamlPackages.dune_3
            ];
          } ''
          cp -r $src src
          chmod u+w src
          cd src
          bash ./scripts/format.sh check
          touch $out
        '';
      };
      devShells.ci = pkgs.mkShell { packages = [ pkgs.jq ]; };
      devShells.default = (pkgs.mkShell.override { stdenv = pkgs.clangStdenv; }) {
        OCAMLRUNPARAM = "b"; # Get backtrace on exception
        packages = [
          pkgs.jq
          pkgs.llvmPackages_18.clang-tools # For clang-format
          pkgs.ocamlPackages.ocaml
          pkgs.ocamlPackages.ocamlformat_0_27_0
          pkgs.ocamlPackages.menhir
          # ocaml-lsp's version must match the ocaml version used. Pinning
          # this here to save me a headache.
          pkgs.ocamlPackages.ocaml-lsp
          pkgs.rustup
        ];
        buildInputs = [ charon.buildInputs ];
        nativeBuildInputs = [ charon.nativeBuildInputs pkgs.clang ];

        inputsFrom = [
          packages.default
          packages.default.tests
          charon-ml
        ];
      };
    });
}


================================================
FILE: include/eurydice_glue.h
================================================
#pragma once

#include <inttypes.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifdef _MSC_VER
// For __popcnt
#include <intrin.h>
#endif

#include "krml/internal/target.h"
#include "krml/lowstar_endianness.h"

// C++ HELPERS

#if defined(__cplusplus)

#ifndef KRML_HOST_EPRINTF
#define KRML_HOST_EPRINTF(...) fprintf(stderr, __VA_ARGS__)
#endif

#include <utility>

#ifndef __cpp_lib_type_identity
template <class T> struct type_identity {
  using type = T;
};

template <class T> using type_identity_t = typename type_identity<T>::type;
#else
using std::type_identity_t;
#endif

#define KRML_UNION_CONSTRUCTOR(T)                                              \
  template <typename V>                                                        \
  constexpr T(int t, V U::*m, type_identity_t<V> v) : tag(t) {                 \
    val.*m = std::move(v);                                                     \
  }                                                                            \
  T() = default;

#endif

// GENERAL-PURPOSE STUFF

#define LowStar_Ignore_ignore(e, t, _ret_t) ((void)e)

#define EURYDICE_ASSERT(test, msg)                                             \
  do {                                                                         \
    if (!(test)) {                                                             \
      fprintf(stderr, "assertion \"%s\" failed: file \"%s\", line %d\n", msg,  \
              __FILE__, __LINE__);                                             \
      exit(255);                                                               \
    }                                                                          \
  } while (0)

// SIZEOF, ALIGNOF

#define Eurydice_sizeof(t) sizeof(t)

#define Eurydice_alignof(t) alignof(t)

// SLICES, ARRAYS, ETC.

// For convenience, we give these common slice types, below, a distinguished
// status and rather than emit them in the client code, we skip their
// code-generation in Cleanup3.ml and write them by hand here. This makes it
// easy to write interop code that brings those definitions in scope.

// &[u8]
typedef struct Eurydice_borrow_slice_u8_s {
  const uint8_t *ptr;
  size_t meta;
} Eurydice_borrow_slice_u8;

// &[u16]
typedef struct Eurydice_borrow_slice_i16_s {
  const int16_t *ptr;
  size_t meta;
} Eurydice_borrow_slice_i16;

// &mut [u8]
typedef struct Eurydice_mut_borrow_slice_u8_s {
  uint8_t *ptr;
  size_t meta;
} Eurydice_mut_borrow_slice_u8;

// &mut [u16]
typedef struct Eurydice_mut_borrow_slice_i16_s {
  int16_t *ptr;
  size_t meta;
} Eurydice_mut_borrow_slice_i16;

#if defined(__cplusplus)
#define KRML_CLITERAL(type) type
#else
#define KRML_CLITERAL(type) (type)
#endif

#if defined(__cplusplus) && defined(__cpp_designated_initializers) ||          \
    !(defined(__cplusplus))
#define EURYDICE_CFIELD(X) X
#else
#define EURYDICE_CFIELD(X)
#endif

#define Eurydice_array_repeat(dst, len, init, t)                               \
  ERROR "should've been desugared"

// Copy a slice with memcopy
#define Eurydice_slice_copy(dst, src, t)                                       \
  memcpy(dst.ptr, src.ptr, dst.meta * sizeof(t))

#define core_array___T__N___as_slice(len_, ptr_, t, ret_t)                     \
  (KRML_CLITERAL(ret_t){EURYDICE_CFIELD(.ptr =)(ptr_)->data,                   \
                        EURYDICE_CFIELD(.meta =) len_})

#define core_array__core__clone__Clone_for__T__N___clone(len, src, elem_type,  \
                                                         _ret_t)               \
  (*(src))
#define TryFromSliceError uint8_t
#define core_array_TryFromSliceError uint8_t

// Distinguished support for some PartialEq trait implementations
//
// core::cmp::PartialEq<@Array<U, N>> for @Array<T, N>
#define Eurydice_array_eq(sz, a1, a2, t)                                       \
  (memcmp((a1)->data, (a2)->data, sz * sizeof(t)) == 0)
// core::cmp::PartialEq<&0 (@Slice<U>)> for @Array<T, N>
#define Eurydice_array_eq_slice_shared(sz, a1, s2, t, _)                       \
  (memcmp((a1)->data, (s2)->ptr, sz * sizeof(t)) == 0)
#define Eurydice_array_eq_slice_mut(sz, a1, s2, t, _)                          \
  Eurydice_array_eq_slice_shared(sz, a1, s2, t, _)

// DEPRECATED -- should no longer be generated
#define core_array_equality__core__cmp__PartialEq__Array_U__N___for__Array_T__N___eq( \
    sz, a1, a2, t, _, _ret_t)                                                         \
  Eurydice_array_eq(sz, a1, a2, t)
#define core_array_equality__core__cmp__PartialEq__0___Slice_U____for__Array_T__N___eq( \
    sz, a1, a2, t, _, _ret_t)                                                           \
  Eurydice_array_eq(sz, a1, ((a2)->ptr), t)
#define core_cmp_impls__core__cmp__PartialEq__0_mut__B___for__1_mut__A___eq(   \
    _m0, _m1, src1, src2, _0, _1, T)                                           \
  Eurydice_slice_eq(src1, src2, _, _, T, _)

#define Eurydice_slice_split_at(slice, mid, element_type, ret_t)               \
  KRML_CLITERAL(ret_t) {                                                       \
    EURYDICE_CFIELD(.fst =){EURYDICE_CFIELD(.ptr =)((slice).ptr),              \
                            EURYDICE_CFIELD(.meta =) mid},                     \
        EURYDICE_CFIELD(.snd =) {                                              \
      EURYDICE_CFIELD(.ptr =)                                                  \
      ((slice).ptr + mid), EURYDICE_CFIELD(.meta =)((slice).meta - mid)        \
    }                                                                          \
  }

#define Eurydice_slice_split_at_mut(slice, mid, element_type, ret_t)           \
  KRML_CLITERAL(ret_t) {                                                       \
    EURYDICE_CFIELD(.fst =){EURYDICE_CFIELD(.ptr =)((slice).ptr),              \
                            EURYDICE_CFIELD(.meta =) mid},                     \
        EURYDICE_CFIELD(.snd =) {                                              \
      EURYDICE_CFIELD(.ptr =)                                                  \
      ((slice).ptr + mid), EURYDICE_CFIELD(.meta =)((slice).meta - mid)        \
    }                                                                          \
  }

// Conversion of slice to an array, rewritten (by Eurydice) to name the
// destination array, since arrays are not values in C.
// N.B.: see note in karamel/lib/Inlining.ml if you change this.

#define Eurydice_slice_to_ref_array2(len_, src, arr_ptr, t_ptr, t_arr, t_err,  \
                                     t_res)                                    \
  (src.meta >= len_                                                            \
       ? ((t_res){.tag = core_result_Ok, .val = {.case_Ok = arr_ptr}})         \
       : ((t_res){.tag = core_result_Err, .val = {.case_Err = 0}}))

// CORE STUFF (conversions, endianness, ...)

// We slap extern "C" on declarations that intend to implement a prototype
// generated by Eurydice, because Eurydice prototypes are always emitted within
// an extern "C" block, UNLESS you use -fcxx17-compat, in which case, you must
// pass -DKRML_CXX17_COMPAT="" to your C++ compiler.
#if defined(__cplusplus) && !defined(KRML_CXX17_COMPAT)
extern "C" {
#endif

#define core_hint_black_box(X, _0, _1) (X)

// [ u8; 2 ]
typedef struct Eurydice_array_u8x2_s {
  uint8_t data[2];
} Eurydice_array_u8x2;

// [ u8; 4 ]
typedef struct Eurydice_array_u8x4_s {
  uint8_t data[4];
} Eurydice_array_u8x4;

// [ u8; 8 ]
typedef struct Eurydice_array_u8x8_s {
  uint8_t data[8];
} Eurydice_array_u8x8;

static inline uint16_t core_num__u16__from_le_bytes(Eurydice_array_u8x2 buf) {
  return load16_le(buf.data);
}

static inline Eurydice_array_u8x4 core_num__u32__to_be_bytes(uint32_t src) {
  // TODO: why not store32_be?
  Eurydice_array_u8x4 a;
  uint32_t x = htobe32(src);
  memcpy(a.data, &x, 4);
  return a;
}

static inline Eurydice_array_u8x4 core_num__u32__to_le_bytes(uint32_t src) {
  Eurydice_array_u8x4 a;
  store32_le(a.data, src);
  return a;
}

static inline uint32_t core_num__u32__from_le_bytes(Eurydice_array_u8x4 buf) {
  return load32_le(buf.data);
}

static inline Eurydice_array_u8x8 core_num__u64__to_le_bytes(uint64_t v) {
  Eurydice_array_u8x8 a;
  store64_le(a.data, v);
  return a;
}

static inline uint64_t core_num__u64__from_le_bytes(Eurydice_array_u8x8 buf) {
  return load64_le(buf.data);
}

static inline int64_t
core_convert_num__core__convert__From_i32__for_i64__from(int32_t x) {
  return x;
}

static inline uint64_t
core_convert_num__core__convert__From_u8__for_u64__from(uint8_t x) {
  return x;
}

static inline uint64_t
core_convert_num__core__convert__From_u16__for_u64__from(uint16_t x) {
  return x;
}

static inline size_t
core_convert_num__core__convert__From_u16__for_usize__from(uint16_t x) {
  return x;
}

static inline uint32_t core_num__u8__count_ones(uint8_t x0) {
#ifdef _MSC_VER
  return __popcnt(x0);
#else
  return __builtin_popcount(x0);
#endif
}

static inline uint32_t core_num__u32__count_ones(uint32_t x0) {
#ifdef _MSC_VER
  return __popcnt(x0);
#else
  return __builtin_popcount(x0);
#endif
}

static inline uint32_t core_num__i32__count_ones(int32_t x0) {
#ifdef _MSC_VER
  return __popcnt(x0);
#else
  return __builtin_popcount(x0);
#endif
}

static inline size_t core_cmp_impls__core__cmp__Ord_for_usize__min(size_t a,
                                                                   size_t b) {
  if (a <= b)
    return a;
  else
    return b;
}

// unsigned overflow wraparound semantics in C
static inline uint8_t core_num__u8__wrapping_sub(uint8_t x, uint8_t y) {
  return x - y;
}
static inline uint8_t core_num__u8__wrapping_add(uint8_t x, uint8_t y) {
  return x + y;
}
static inline uint8_t core_num__u8__wrapping_mul(uint8_t x, uint8_t y) {
  return x * y;
}
static inline uint16_t core_num__u16__wrapping_sub(uint16_t x, uint16_t y) {
  return x - y;
}
static inline uint16_t core_num__u16__wrapping_add(uint16_t x, uint16_t y) {
  return x + y;
}
static inline uint16_t core_num__u16__wrapping_mul(uint16_t x, uint16_t y) {
  return x * y;
}
static inline uint32_t core_num__u32__wrapping_sub(uint32_t x, uint32_t y) {
  return x - y;
}
static inline uint32_t core_num__u32__wrapping_add(uint32_t x, uint32_t y) {
  return x + y;
}
static inline uint32_t core_num__u32__wrapping_mul(uint32_t x, uint32_t y) {
  return x * y;
}
static inline uint64_t core_num__u64__wrapping_sub(uint64_t x, uint64_t y) {
  return x - y;
}
static inline uint64_t core_num__u64__wrapping_add(uint64_t x, uint64_t y) {
  return x + y;
}
static inline uint64_t core_num__u64__wrapping_mul(uint64_t x, uint64_t y) {
  return x * y;
}
static inline size_t core_num__usize__wrapping_sub(size_t x, size_t y) {
  return x - y;
}
static inline size_t core_num__usize__wrapping_add(size_t x, size_t y) {
  return x + y;
}
static inline size_t core_num__usize__wrapping_mul(size_t x, size_t y) {
  return x * y;
}

static inline int8_t core_num__i8__wrapping_add(int8_t x, int8_t y) {
  return (int8_t)((uint8_t)x + (uint8_t)y);
}
static inline int8_t core_num__i8__wrapping_sub(int8_t x, int8_t y) {
  return (int8_t)((uint8_t)x - (uint8_t)y);
}
static inline int8_t core_num__i8__wrapping_mul(int8_t x, int8_t y) {
  return (int8_t)((uint8_t)x * (uint8_t)y);
}
static inline int16_t core_num__i16__wrapping_add(int16_t x, int16_t y) {
  return (int16_t)((uint16_t)x + (uint16_t)y);
}
static inline int16_t core_num__i16__wrapping_sub(int16_t x, int16_t y) {
  return (int16_t)((uint16_t)x - (uint16_t)y);
}
static inline int16_t core_num__i16__wrapping_mul(int16_t x, int16_t y) {
  return (int16_t)((uint16_t)x * (uint16_t)y);
}
static inline int32_t core_num__i32__wrapping_add(int32_t x, int32_t y) {
  return (int32_t)((uint32_t)x + (uint32_t)y);
}
static inline int32_t core_num__i32__wrapping_sub(int32_t x, int32_t y) {
  return (int32_t)((uint32_t)x - (uint32_t)y);
}
static inline int32_t core_num__i32__wrapping_mul(int32_t x, int32_t y) {
  return (int32_t)((uint32_t)x * (uint32_t)y);
}
static inline int64_t core_num__i64__wrapping_add(int64_t x, int64_t y) {
  return (int64_t)((uint64_t)x + (uint64_t)y);
}
static inline int64_t core_num__i64__wrapping_sub(int64_t x, int64_t y) {
  return (int64_t)((uint64_t)x - (uint64_t)y);
}
static inline int64_t core_num__i64__wrapping_mul(int64_t x, int64_t y) {
  return (int64_t)((uint64_t)x * (uint64_t)y);
}
static inline int8_t core_num__i8__wrapping_neg(int8_t x) {
  return (int8_t)(-(uint8_t)x);
}
static inline int16_t core_num__i16__wrapping_neg(int16_t x) {
  return (int16_t)(-(uint16_t)x);
}
static inline int32_t core_num__i32__wrapping_neg(int32_t x) {
  return (int32_t)(-(uint32_t)x);
}
static inline int64_t core_num__i64__wrapping_neg(int64_t x) {
  return (int64_t)(-(uint64_t)x);
}

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1) {
  return (x0 << x1) | (x0 >> ((-x1) & 63));
}

static inline void core_ops_arith__i32__add_assign(int32_t *x0, int32_t *x1) {
  *x0 = *x0 + *x1;
}

static inline uint8_t Eurydice_bitand_pv_u8(const uint8_t *p, uint8_t v) {
  return (*p) & v;
}
static inline uint8_t Eurydice_shr_pv_u8(const uint8_t *p, int32_t v) {
  return (*p) >> v;
}
static inline uint32_t Eurydice_min_u32(uint32_t x, uint32_t y) {
  return x < y ? x : y;
}

static inline uint8_t
core_ops_bit__core__ops__bit__BitAnd_u8__u8__for__0__u8___bitand(
    const uint8_t *x0, uint8_t x1) {
  return Eurydice_bitand_pv_u8(x0, x1);
}

static inline uint8_t
core_ops_bit__core__ops__bit__Shr_i32__u8__for__0__u8___shr(const uint8_t *x0,
                                                            int32_t x1) {
  return Eurydice_shr_pv_u8(x0, x1);
}

#define core_num_nonzero_private_NonZeroUsizeInner size_t
static inline core_num_nonzero_private_NonZeroUsizeInner
core_num_nonzero_private___core__clone__Clone_for_core__num__nonzero__private__NonZeroUsizeInner___clone(
    core_num_nonzero_private_NonZeroUsizeInner *x0) {
  return *x0;
}

#if defined(__cplusplus) && !defined(KRML_CXX17_COMPAT)
}
#endif

// ITERATORS

#define Eurydice_range_iter_next(iter_ptr, t, ret_t)                           \
  (((iter_ptr)->start >= (iter_ptr)->end)                                      \
       ? (KRML_CLITERAL(ret_t){EURYDICE_CFIELD(.tag =) 0,                      \
                               EURYDICE_CFIELD(.f0 =) 0})                      \
       : (KRML_CLITERAL(ret_t){EURYDICE_CFIELD(.tag =) 1,                      \
                               EURYDICE_CFIELD(.f0 =)(iter_ptr)->start++}))

#define core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next \
  Eurydice_range_iter_next

// See note in karamel/lib/Inlining.ml if you change this
#define Eurydice_into_iter(x, t, _ret_t, _) (x)
#define core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter \
  Eurydice_into_iter

// STRINGS

typedef char Eurydice_c_char_t;
typedef const Eurydice_c_char_t *Prims_string;
typedef void Eurydice_c_void_t;

// UNSAFE CODE

#define core_slice___Slice_T___as_mut_ptr(x, t, _) (x.ptr)
#define core_mem_size_of(t, _) (sizeof(t))
#define core_slice_raw_from_raw_parts_mut(ptr, len, _0, _1)                    \
  (KRML_CLITERAL(Eurydice_slice){(void *)(ptr), len})
#define core_slice_raw_from_raw_parts(ptr, len, _0, _1)                        \
  (KRML_CLITERAL(Eurydice_slice){(void *)(ptr), len})

// FIXME: add dedicated extraction to extract NonNull<T> as T*
#define core_ptr_non_null_NonNull void *

// PRINTING
//
// This is temporary. Ultimately we want to be able to extract all of this.

typedef void *core_fmt_Formatter;
#define core_fmt_rt__core__fmt__rt__Argument__a___new_display(x1, x2, x3, x4)  \
  NULL

// BOXES

#ifndef EURYDICE_MALLOC
#define EURYDICE_MALLOC malloc
#endif

#ifndef EURYDICE_REALLOC
#define EURYDICE_REALLOC realloc
#endif

static inline char *malloc_and_init(size_t sz, char *init) {
  char *ptr = (char *)EURYDICE_MALLOC(sz);
  if (ptr != NULL)
    memcpy(ptr, init, sz);
  return ptr;
}

#define Eurydice_box_new(init, t, t_dst)                                       \
  ((t_dst)(malloc_and_init(sizeof(t), (char *)(&init))))

// Initializer for array of size zero
#define Eurydice_empty_array(dummy, t, t_dst) ((t_dst){.data = {}})

#define Eurydice_box_new_array(len, ptr, t, t_dst)                             \
  ((t_dst)(malloc_and_init(len * sizeof(t), (char *)(ptr))))

// FIXME this needs to handle allocation failure errors, but this seems hard to
// do without evaluating malloc_and_init twice...
#define alloc_boxed__alloc__boxed__Box_T___try_new(init, t, t_ret)             \
  ((t_ret){.tag = core_result_Ok,                                              \
           .f0 = (t *)malloc_and_init(sizeof(t), (char *)(&init))})

// VECTORS

// We adapt the layout of https://doc.rust-lang.org/std/vec/struct.Vec.html,
// dispensing with the nested RawVec -- basically, we follow what the
// documentation says. Just like Eurydice_slice, we keep sizes in number of
// elements. This means we pass three words by value whenever we carry a vector
// around. Things that modify the vector take &mut's in Rust, or a Eurydice_vec*
// in C.
//
// Another design choice: just like Eurydice_slice, we treat Eurydice_vec as an
// opaque type, and rely on macros receiving their type arguments at call-site
// to perform necessary casts. A downside is that anything that looks into the
// definition of Eurydice_vec must be exposed (from the eurydice point of view)
// as an external -- see, for instance, Eurydice_vec_failed, below.
typedef struct {
  char *ptr;
  size_t len;      /* current length, in elements */
  size_t capacity; /* the size of the allocation, in number of elements */
} Eurydice_vec, alloc_vec_Vec;

// This is a helper that Eurydice has special knowledge about. Essentially,
// allocation functions return a result type that has been monomorphized, say,
// Result_XY; this means we need to do something like:
//   Eurydice_vec v = try_with_capacity(len, sz);
//   Result_XY r = v.ptr == NULL ? (Result_XY) { .tag = core_result_Ok, .case_Ok
//   = v }
//     : (Result_XY) { .tag = core_result_Error, .case_Error = ... };
// but with a macro (since we don't have templates).
// However, unless we allow statement-expressions (GCC extension), we cannot do
// the above with an expression, since we need to name the result of
// try_with_capacity to avoid evaluating it twice.
static inline Eurydice_vec Eurydice_vec_alloc2(size_t len, size_t element_sz) {
  return ((Eurydice_vec){.ptr = (char *)EURYDICE_MALLOC(len * element_sz),
                         .len = len,
                         .capacity = len});
}

#define Eurydice_vec_alloc(len, t, _) (Eurydice_vec_alloc2((len), sizeof(t)))
#define Eurydice_vec_overflows(len, t, _) (!((len) <= SIZE_MAX / (sizeof(t))))
#define Eurydice_vec_failed(v, _, _1) ((v).ptr == NULL)
#define Eurydice_layout(t, _)                                                  \
  ((core_alloc_layout_Layout){.size = sizeof(t), .align = _Alignof(t)})

#define alloc_vec__alloc__vec__Vec_T___resize(                                 \
    /* Eurydice_vec * */ v, /* size_t */ new_len, /* T */ elt, T, _0, _1)      \
  do {                                                                         \
    if (new_len <= (v)->capacity)                                              \
      (v)->len = new_len;                                                      \
    else {                                                                     \
      (v)->ptr = EURYDICE_REALLOC((v)->ptr, new_len * sizeof(T));              \
      /* TODO: check success? Rust function is infallible */                   \
      for (size_t i = (v)->len; i < new_len; i++)                              \
        ((T *)(v)->ptr)[i] = elt;                                              \
      (v)->len = new_len;                                                      \
      (v)->capacity = new_len;                                                 \
    }                                                                          \
  } while (0)

#define alloc_vec__alloc__vec__Vec_T___into_boxed_slice(/* Eurydice_vec */ v,  \
                                                        T, _0, _1)             \
  ((Eurydice_slice){.ptr = (v).ptr, .len = (v).len})

#define alloc_boxed__alloc__boxed__Box_T___from_raw(x, _0, _1) (x)
#define alloc_boxed__alloc__boxed__Box_T___into_raw(x, _0, _1) (x)


================================================
FILE: lib/AstOfLlbc.ml
================================================
(* C for Charon *)
module C = struct
  include Charon.GAst
  include Charon.LlbcAst
  include Charon.Types
  include Charon.TypesUtils
  include Charon.Expressions
  include Charon.Values
  include Charon.GAstUtils

  (* Fails if the variable is bound *)
  let expect_free_var = function
    | Free id -> id
    | Bound _ -> failwith "Found unexpected bound variable"

  let tsubst cgs ts ty =
    begin
      object
        inherit [_] map_ty
        method! visit_TVar _ v = TypeVarId.nth ts (expect_free_var v)
        method! visit_CVar _ v = ConstGenericVarId.nth cgs (expect_free_var v)
        method visit_'r _ x = x
      end
    end
      #visit_ty
      () ty
end

module LidMap = Krml.Idents.LidMap
module K = Krml.Ast
module L = Logging
open Krml.PrintAst.Ops

let fail fmt =
  let b = Buffer.create 256 in
  Printf.kbprintf (fun b -> failwith (Buffer.contents b)) b fmt

(** Environment *)

(* The various kinds of binders we insert in the expression scope. Usually come
   in this order, the first three being only ever inserted upon entering a function
   definition. *)
type var_id =
  | TraitClauseMethod of {
      clause_id : C.trait_ref_kind;
      method_id : C.trait_method_id;
      item_name : string;
      pretty_name : string;
      ts : K.type_scheme;
    }
  | TraitClauseConstant of {
      clause_id : C.trait_ref_kind;
      item_name : string;
      pretty_name : string;
    }
  | ConstGenericVar of C.const_generic_var_id
  | Var of C.local_id * C.ety (* the ety aids code-generation, sometimes *)

type env = {
  (* Lookup functions to resolve various id's into actual declarations. *)
  get_nth_function : C.FunDeclId.id -> C.fun_decl;
  get_nth_type : C.TypeDeclId.id -> C.type_decl;
  get_nth_global : C.GlobalDeclId.id -> C.global_decl;
  get_nth_trait_impl : C.TraitImplId.id -> C.trait_impl;
  get_nth_trait_decl : C.TraitDeclId.id -> C.trait_decl;
  crate : C.crate;
  (* Needed by the name matching logic *)
  name_ctx : Charon.NameMatcher.ctx;
  generic_params : C.generic_params;
  (* We have three lists of binders, which allow us to go from a Rust variable
     to a corresponding krml AST variable; everything is in De Bruijn, so
     looking up a variable is essentially List.nth. To understand why we have
     three lists here, we review the binding structure of the target (krml) AST.

     The target AST has three binding scopes: cg vars, type vars and expression
     vars. Type vars and type expressions are standard and have their own
     scopes, and corresponding variable nodes (TBound for type variables, Bound
     for expression variables). Const-generic variables are more complicted,
     because they appear in *both* types and expressions; there is a *third*
     scope of cg variables, with the following behavior:
     - in types, CgVar and TCgArray contain DeBruijn indices referring to the cg
       scope (standard), while
     - in expressions, there is no ECgVar, so we repeat cg vars at the beginning
       of the expression scope, and we rely on a regular EBound node to refer to
       cg variables (trick). This trick avoids a combinatorial explosion of
       substitution functions and makes sure all 60+ existing passes of krml do
       *not* need to be aware of the addition of const-generics (except for
       monomorphization, of course).
     In short, the third scope for cg variables only applies for CgVar and
     TCgArray; for expressions, cg variables masquerade as expression variables
     and live as the first N variables of that scope.

     To implement this, we rely on the corresponding three lists of binders,
     with the additional caveat that push_cg_binder pushes in both cg_binders
     and binders (see rationale above).

     Example: fn f<const N: usize, T: Copy>(x: [T; N]) -> usize { N }
     Upon entering the body of f, we have:
     - cg_binders: [ N, usize ]
     - type_binders: [ T ]
     - binders: [ `Cg (N, usize); `Clause (T: Copy, "copy"); `Var (x: [T; N]) ]

     After translation, we get:
     DFunction (..., 1 (* one type var *), 2 (* one cg var *), [
       "N": TInt usize;
       "x": TCgArray (TBound 0, 0); (* types use the cg scope *)
     ], EBound 2 (* expressions refer to the copy of the cg var as an expression var *)
  *)
  cg_binders : (C.const_generic_var_id * K.typ) list;
  type_binders : C.type_var_id list;
  binders : (var_id * K.typ) list;
  (* For printing. *)
  format_env : Charon.Print.fmt_env;
  (* For picking pretty names *)
  crate_name : string;
}

let debug env =
  L.log "DebugEnv" "\n# Debug Env";
  List.iteri
    (fun i v ->
      L.log "DebugEnv" "type_binders[%d]: %s\n" i (Charon.Print.type_var_id_to_pretty_string v))
    env.type_binders

(* Environment: types *)

let findi p l =
  let rec findi i l =
    match l with
    | hd :: tl ->
        if p hd then
          i, hd
        else
          findi (i + 1) tl
    | [] -> raise Not_found
  in
  findi 0 l

let fst3 (x, _, _) = x
let snd3 (_, x, _) = x
let thd3 (_, _, x) = x

(* Suitable in types -- in expressions, use lookup_cg_in_expressions. *)
let lookup_cg_in_types env v1 =
  let i, (_, t) = findi (fun (v2, _) -> v1 = v2) env.cg_binders in
  i, t

let lookup_typ env (v1 : C.type_var_id) =
  let i, _ = findi (( = ) v1) env.type_binders in
  i

let push_type_binder env (t : C.type_param) =
  { env with type_binders = t.index :: env.type_binders }

let push_type_binders env (ts : C.type_param list) = List.fold_left push_type_binder env ts

(** Helpers: types *)

let with_any = K.(with_type TAny)
let is_dst_ref lid = Builtin.(lid = dst_ref_mut || lid = dst_ref_shared)

let assert_slice (t : K.typ) =
  match t with
  | TApp (lid, [ t; u ]) when is_dst_ref lid && u = TInt SizeT -> t
  | _ -> fail "Not a slice: %a" ptyp t

let string_of_path_elem (env : env) (p : Charon.Types.path_elem) : string =
  Charon.Print.path_elem_to_string env.format_env p

let string_of_name env ps = String.concat "::" (List.map (string_of_path_elem env) ps)

let mk_field_name f i =
  match f with
  | Some f -> f
  | None -> "f" ^ string_of_int i

let is_enum (env : env) (id : C.type_decl_id) : bool =
  let decl = env.get_nth_type id in
  match decl.C.kind with
  | Enum branches -> List.for_all (fun v -> v.C.fields = []) branches
  | _ -> false

let mk_enum_case lid c = fst lid @ [ snd lid ], c

(* Helpers: traits finding & matching *)

module RustNames = struct
  open Charon.NameMatcher

  let config =
    {
      map_vars_to_vars = false;
      match_with_trait_decl_refs = true;
      (* use_trait_decl_refs = true; *)
    }

  let vec = parse_pattern "alloc::vec::Vec<@>"
  let range = parse_pattern "core::ops::range::Range<@>"
  let option = parse_pattern "core::option::Option<@>"

  (* Just to have a uniform view of the table of distinguished declarations *)
  let builtin_of_function decl : Builtin.builtin =
    match decl with
    | Krml.Ast.DFunction (_, _, n_cgs, n_type_args, ret_t, name, binders, _) ->
        if n_cgs > List.length binders then
          Krml.Warn.fatal_error "n_cgs=%d, but List.length binders=%d for %a\n" n_cgs
            (List.length binders) Krml.PrintAst.Ops.plid name;
        let cg_args, rest = Krml.KList.split n_cgs binders in
        {
          name;
          typ = Krml.Helpers.fold_arrow (List.map (fun (x : Krml.Ast.binder) -> x.typ) rest) ret_t;
          n_type_args;
          cg_args = List.map (fun (x : Krml.Ast.binder) -> x.typ) cg_args;
          arg_names = List.map (fun (x : Krml.Ast.binder) -> x.node.name) rest;
        }
    | _ -> failwith "impossible"

  let known_builtins no_const =
    let ( || ) no_const_variant default =
      if no_const then
        no_const_variant
      else
        default
    in
    [
    (* slices *)
    parse_pattern "SliceIndexShared<'_, @T>", Builtin.(slice_index_mut || slice_index_shared);
    parse_pattern "SliceIndexMut<'_, @T>", Builtin.slice_index_mut;

    parse_pattern "core::slice::index::{core::ops::index::Index<[@T], @I, @Clause2_Output>}::index<'_, @, core::ops::range::Range<usize>, [@]>", builtin_of_function Builtin.(slice_subslice_func_mut || slice_subslice_func_shared);
    parse_pattern "core::slice::index::{core::ops::index::IndexMut<[@T], @I, @Clause2_Output>}::index_mut<'_, @, core::ops::range::Range<usize>, [@]>", builtin_of_function Builtin.slice_subslice_func_mut;
    parse_pattern "core::slice::index::{core::ops::index::Index<[@T], @I, @Clause2_Output>}::index<'_, @, core::ops::range::RangeTo<usize>, [@]>", builtin_of_function Builtin.(slice_subslice_to_func_mut || slice_subslice_to_func_shared);
    parse_pattern "core::slice::index::{core::ops::index::IndexMut<[@T], @I, @Clause2_Output>}::index_mut<'_, @, core::ops::range::RangeTo<usize>, [@]>", builtin_of_function Builtin.slice_subslice_to_func_mut;
    parse_pattern "core::slice::index::{core::ops::index::Index<[@T], @I, @Clause2_Output>}::index<'_, @, core::ops::range::RangeFrom<usize>, [@]>", builtin_of_function Builtin.(slice_subslice_from_func_mut || slice_subslice_from_func_shared);
    parse_pattern "core::slice::index::{core::ops::index::IndexMut<[@T], @I, @Clause2_Output>}::index_mut<'_, @, core::ops::range::RangeFrom<usize>, [@]>", builtin_of_function Builtin.slice_subslice_from_func_mut;

    (* arrays *)
    parse_pattern "core::array::{core::ops::index::Index<[@T; @N], @I, @Clause2_Clause0_Output>}::index<'_, @, core::ops::range::Range<usize>, [@], @>", builtin_of_function Builtin.(array_to_subslice_func_mut || array_to_subslice_func_shared);
    parse_pattern "core::array::{core::ops::index::IndexMut<[@T; @N], @I, @Clause2_Clause0_Output>}::index_mut<'_, @, core::ops::range::Range<usize>, [@], @>", builtin_of_function Builtin.array_to_subslice_func_mut;
    parse_pattern "core::array::{core::ops::index::Index<[@T; @N], @I, @Clause2_Clause0_Output>}::index<'_, @, core::ops::range::RangeTo<usize>, [@], @>", builtin_of_function Builtin.(array_to_subslice_to_func_mut || array_to_subslice_to_func_shared);
    parse_pattern "core::array::{core::ops::index::IndexMut<[@T; @N], @I, @Clause2_Clause0_Output>}::index_mut<'_, @, core::ops::range::RangeTo<usize>, [@], @>", builtin_of_function Builtin.array_to_subslice_to_func_mut;
    parse_pattern "core::array::{core::ops::index::Index<[@T; @N], @I, @Clause2_Clause0_Output>}::index<'_, @, core::ops::range::RangeFrom<usize>, [@], @>", builtin_of_function Builtin.(array_to_subslice_from_func_mut || array_to_subslice_from_func_shared);
    parse_pattern "core::array::{core::ops::index::IndexMut<[@T; @N], @I, @Clause2_Clause0_Output>}::index_mut<'_, @, core::ops::range::RangeFrom<usize>, [@], @>", builtin_of_function Builtin.array_to_subslice_from_func_mut;

    (* slices <-> arrays *)
    parse_pattern "ArrayToSliceShared<'_, @T, @N>", builtin_of_function Builtin.(array_to_slice_func_mut || array_to_slice_func_shared);
    parse_pattern "ArrayToSliceMut<'_, @T, @N>", builtin_of_function Builtin.array_to_slice_func_mut;
    parse_pattern "core::convert::{core::convert::TryInto<@T, @U, @Clause2_Error>}::try_into<&'_ [@T], [@T; @], core::array::TryFromSliceError>", Builtin.slice_to_array;
    parse_pattern "core::convert::{core::convert::TryInto<@T, @U, @Clause2_Error>}::try_into<&'_ mut [@T], [@T; @], core::array::TryFromSliceError>", Builtin.slice_to_array;
    parse_pattern "core::convert::{core::convert::TryInto<@T, @U, @Clause2_Error>}::try_into<&'_ [@T], &'_ [@T; @], core::array::TryFromSliceError>", Builtin.slice_to_ref_array;
    parse_pattern "core::convert::{core::convert::TryInto<@T, @U, @Clause2_Error>}::try_into<&'_ mut [@T], &'_ mut [@T; @], core::array::TryFromSliceError>", Builtin.slice_to_ref_array;

    (* bitwise & arithmetic operations *)
    parse_pattern "core::ops::bit::BitAnd<&'_ u8, u8>::bitand", Builtin.bitand_pv_u8;
    parse_pattern "core::ops::bit::Shr<&'_ u8, i32>::shr", Builtin.shr_pv_u8;

    (* misc *)
    parse_pattern "core::cmp::Ord<u32>::min", Builtin.min_u32;

    (* boxes *)
    parse_pattern "alloc::boxed::{alloc::boxed::Box<@T>}::new<@>", Builtin.box_new;
  ]
  [@ocamlformat "disable"]

  let from_u16 = parse_pattern "core::convert::From<u16, @U>::from"
  let from_u32 = parse_pattern "core::convert::From<u32, @U>::from"
  let from_u64 = parse_pattern "core::convert::From<u64, @U>::from"
  let from_u128 = parse_pattern "core::convert::From<u128, @U>::from"
  let from_i16 = parse_pattern "core::convert::From<i16, @U>::from"
  let from_i32 = parse_pattern "core::convert::From<i32, @U>::from"
  let from_i64 = parse_pattern "core::convert::From<i64, @U>::from"
  let from_i128 = parse_pattern "core::convert::From<i128, @U>::from"
  let from = parse_pattern "core::convert::From<@T, @U>::from"
  let into_u16 = parse_pattern "core::convert::Into<@U, u16>::into"
  let into_u32 = parse_pattern "core::convert::Into<@U, u32>::into"
  let into_u64 = parse_pattern "core::convert::Into<@U, u64>::into"
  let into_u128 = parse_pattern "core::convert::Into<@U, u128>::into"
  let into_i16 = parse_pattern "core::convert::Into<@U, i16>::into"
  let into_i32 = parse_pattern "core::convert::Into<@U, i32>::into"
  let into_i64 = parse_pattern "core::convert::Into<@U, i64>::into"
  let into_i128 = parse_pattern "core::convert::Into<@U, i128>::into"
  let into = parse_pattern "core::convert::Into<@U, @T>::into"
  let is_vec env = match_pattern_with_type_id env.name_ctx config (mk_empty_maps ()) vec
  let is_range env = match_pattern_with_type_id env.name_ctx config (mk_empty_maps ()) range
  let is_option env = match_pattern_with_type_id env.name_ctx config (mk_empty_maps ()) option
end

let string_of_pattern pattern = Charon.NameMatcher.(pattern_to_string { tgt = TkPattern } pattern)

let pattern_of_fn_ptr env fn_ptr =
  Charon.NameMatcher.(
    fn_ptr_to_pattern env.name_ctx
      { tgt = TkPattern; use_trait_decl_refs = true }
      Charon.TypesUtils.empty_generic_params fn_ptr)

let pattern_of_name env name =
  Charon.NameMatcher.(
    name_to_pattern env.name_ctx { tgt = TkPattern; use_trait_decl_refs = true } name)

let string_of_fn_ptr env fn_ptr = string_of_pattern (pattern_of_fn_ptr env fn_ptr)

(** Translation of types *)

let lid_of_name (env : env) (name : Charon.Types.name) : K.lident =
  let prefix, name = Krml.KList.split_at_last name in
  List.map (string_of_path_elem env) prefix, string_of_path_elem env name

let width_of_integer_type (t : Charon.Types.integer_type) : K.width =
  match t with
  | Signed Isize -> PtrdiffT
  | Signed I8 -> Int8
  | Signed I16 -> Int16
  | Signed I32 -> Int32
  | Signed I64 -> Int64
  | Signed I128 ->
      failwith "Internal error: `i128` should not be handled in `width_of_integer_type`."
  | Unsigned Usize -> SizeT
  | Unsigned U8 -> UInt8
  | Unsigned U16 -> UInt16
  | Unsigned U32 -> UInt32
  | Unsigned U64 -> UInt64
  | Unsigned U128 ->
      failwith "Internal error: `u128` should not be handled in `width_of_integer_type`."

let lid_of_type_decl_id (env : env) (id : C.type_decl_id) =
  let { C.item_meta; _ } = env.get_nth_type id in
  lid_of_name env item_meta.name

let constant_of_scalar_value sv =
  let w = width_of_integer_type (Charon.Scalars.get_ty sv) in
  w, Z.to_string (Charon.Scalars.get_val sv)

let assert_cg_scalar : C.constant_expr -> C.scalar_value = function
  | { kind = C.CLiteral (VScalar n); _ } -> n
  | cg -> failwith ("Unsupported: non-constant const generic: " ^ C.show_constant_expr cg)

let cg_of_const_generic env (cg : C.constant_expr) =
  match cg.kind with
  | C.CVar var -> K.CgVar (fst (lookup_cg_in_types env (C.expect_free_var var)))
  | C.CLiteral (VScalar sv) -> CgConst (constant_of_scalar_value sv)
  | _ -> failwith ("cg_of_const_generic: " ^ Charon.Print.constant_expr_to_string env.format_env cg)

let float_width float_ty : K.width =
  match float_ty with
  | C.F32 -> Float32
  | C.F64 -> Float64
  | C.F16 | C.F128 -> failwith "TODO: f16 & f128 are not supported."

let typ_of_literal_ty (_env : env) (ty : Charon.Types.literal_type) : K.typ =
  match ty with
  | TBool -> K.TBool
  | TChar -> Builtin.char_t
  | TFloat f -> K.TInt (float_width f)
  | TInt C.I128 -> Builtin.int128_t
  | TUInt C.U128 -> Builtin.uint128_t
  | _ -> K.TInt (width_of_integer_type (Charon.TypesUtils.literal_as_integer ty))

let const_of_ref_kind kind =
  if !Options.no_const then
    false
  else
    match kind with
    | C.RMut -> false
    | C.RShared -> true

let const_of_borrow_kind bk =
  if !Options.no_const then
    false
  else
    match bk with
    | C.BShared -> true
    | C.BShallow -> true
    | _ -> false

let const_of_tbuf b =
  if !Options.no_const then
    false
  else
    match b with
    | K.TBuf (_, const) -> const
    | _ -> failwith "not a tbuf"

(* e: Eurydice_dst<t> *)
let mk_dst_deref _env t e =
  (* ptr_field: t* *)
  (* XXX need proper const here *)
  let ptr_field = K.(with_type (TBuf (t, true)) (EField (e, "ptr"))) in
  K.(with_type t (EBufRead (ptr_field, Krml.Helpers.zero_usize)))

let ensure_named i name =
  match name, i with
  | None, 0 -> "fst"
  | None, 1 -> "snd"
  | None, 2 -> "thd"
  | None, _ -> Printf.sprintf "field%d" i
  | Some name, _ -> name

let lookup_field env typ_id field_id =
  let ty_decl = env.get_nth_type typ_id in
  let fields =
    match ty_decl.kind with
    | Struct fields -> fields
    | _ -> failwith "not a struct"
  in
  let i = C.FieldId.to_int field_id in
  let field = List.nth fields i in
  ensure_named i field.field_name

let mk_expr_arr_struct (expr_array : K.expr) = K.EFlat [ Some "data", expr_array ]

(** A vtable type is actually just a struct type, this function takes out the hinted ID of the
    vtable struct from the dynamic predicate and then translate it, returns a reference to the
    struct type itself.

    Notably, a dynamic predicate is of the form:
    [dyn Trait<TraitArgs, AssocTy=T, ...> + AutoTraits + 'a]. Namely, it has the arguments to the
    unique non-auto trait and the assignments to each associated types as the **principal trait**
    [Trait<...>], and then some additional auto-traits having no methods and finally a region
    constraint. Here we care only about the principal trait. *)
let rec vtable_typ_of_dyn_pred (env : env) (pred : C.dyn_predicate) : K.typ =
  let binder_params = pred.binder.binder_params in
  match binder_params.trait_clauses with
  | [] -> failwith "DynTrait has empty clause! Please report this to Charon."
  (* As guaranteed by Rustc and hence Charon, the first clause must be the principal trait *)
  | principal_clause :: _ -> (
      let tref = principal_clause.trait in
      let decl = env.get_nth_trait_decl tref.binder_value.id in
      match decl.vtable with
      | None ->
          failwith "Fetching vtable from a trait without vtable! Please report this to Charon."
      | Some ty_ref ->
          (* The ty_ref here is of the form: `{vtable}<TraitParams, AssocTys>` *)
          (* Hence we need to firstly substitute `TraitParams` with the actual types provided by the dynamic predicate's `TraitArgs` *)
          (* And then substitute `AssocTys` with the actual types provided by the dynamic predicate's assignments to these associated types *)
          (* The trait ref is guaranteed to be with empty binding values in the principal clause *)
          (* Yet, we will need to move shift the internal DeBruijn indices with `extract_from_binder` *)
          let tref = Charon.Substitute.(extract_from_binder trait_decl_ref_substitute tref) in
          (* First step: get the `TraitArgs` *)
          let base_args =
            let generics = tref.generics in
            { generics with types = List.tl generics.types }
          in
          (* Second step: find from the assignments of assoc tys *)
          let assoc_tys =
            let base_removal = fun l -> snd (Krml.KList.split (List.length base_args.types) l) in
            let find_assoc_ty_arg = function
              | C.TTraitType (tref, name) ->
                  (* We match by the trait-ID and the assoc-ty name, which should be unique *)
                  let target_id = tref.trait_decl_ref.binder_value.id in
                  let assoc_ty_assns = binder_params.trait_type_constraints in
                  let finder (binded_assn : C.trait_type_constraint C.region_binder) =
                    let assn =
                      Charon.Substitute.(
                        extract_from_binder trait_type_constraint_substitute binded_assn)
                    in
                    if
                      assn.trait_ref.trait_decl_ref.binder_value.id = target_id
                      && assn.type_name = name
                    then
                      Some assn.ty
                    else
                      None
                  in
                  begin
                    match List.find_map finder assoc_ty_assns with
                    | Some ty -> ty
                    | None ->
                        fail "Could not find associated type assignment for associated type %s" name
                  end
              | _ ->
                  failwith
                    "This should not happen: the rest of the generic types in a vtable-ref in a \
                     trait-decl should all be referring to associated types."
            in
            ty_ref.generics.types
            (* Remove the base param types from it, leaving the associated types params *)
            |> base_removal
            (* For each assoc type param, find the corresponding arg from the dyn predicate *)
            |> List.map find_assoc_ty_arg
          in
          let args = { base_args with types = base_args.types @ assoc_tys } in
          let ty_args_ref = { ty_ref with generics = args } in
          typ_of_ty env (C.TAdt ty_args_ref))

(* This functions takes a Charon type, and returns the associated metadata as a krml type,
   or None if there is no metadata *)
and metadata_typ_of_ty (env : env) (ty : Charon.Types.ty) : K.typ option =
  match ty with
  | C.TAdt ty_decl_ref -> begin
      match ty_decl_ref.id with
      | C.TAdtId decl_id -> begin
          let decl = env.get_nth_type decl_id in
          match decl.ptr_metadata with
          | C.NoMetadata -> None
          | C.Length -> Some Krml.Helpers.usize
          | C.VTable ty_ref ->
              let ty_ref = { ty_ref with generics = ty_decl_ref.generics } in
              Some (K.TBuf (typ_of_ty env (C.TAdt ty_ref), false))
          | C.InheritFrom (C.TVar (C.Free var)) ->
              let ty = List.nth ty_decl_ref.generics.types (C.TypeVarId.to_int var) in
              metadata_typ_of_ty env ty
          | C.InheritFrom _ ->
              failwith
                "Eurydice does not handle PtrMetadata inheritance, please consider using \
                 monomorphized LLBC"
        end
      | C.TTuple -> begin
          match List.rev @@ ty_decl_ref.generics.types with
          (* Empty metadata for empty tuple *)
          | [] -> None
          (* For tuple, the type of metadata is the last element *)
          | last :: _ -> metadata_typ_of_ty env last
        end
      | C.TBuiltin C.TBox -> None
      | C.TBuiltin C.TStr -> Some Krml.Helpers.usize
    end
  | C.TArray _ -> None
  | C.TSlice _ -> Some Krml.Helpers.usize
  | C.TVar _ ->
      (* TEMPORARY:  this needs to be enabled once the monomorphization PR lands --
    for now, there are still polymorphic type definitions of the form type
    Foo<T: ?Sized> = ... in the AST (those will be monomorphized away, eventually) *)
      let _var_is_sized (clause : C.trait_param) =
        let trait = clause.trait.binder_value in
        match trait.generics.types with
        | [] -> failwith "Unexpected empty `Self` from trait clause."
        (* The variable here in C.TVar should be free variable, hence no need to adjust the DB id. *)
        | self :: _ ->
            self = ty
            &&
            let decl = env.get_nth_trait_decl trait.id in
            (* It has the Sized marker, which is of lang_item "sized" *)
            decl.item_meta.lang_item = Some "sized"
      in
      let var_is_sized =
        true
        (*List.exists var_is_sized env.generic_params.trait_clauses*)
      in
      if var_is_sized then
        None
      else
        failwith
          "Eurydice does not handle taking metadata from non-Sized type vars, please consider \
           using monomorphized LLBC."
  | C.TTraitType (_, _) ->
      failwith
        "Eurydice does not handle taking metadata from assoc types, please consider using \
         monomorphized LLBC."
  (* The metadata of a &dyn Trait object is a pointer to its vtable *)
  | C.TDynTrait pred -> Some (K.TBuf (vtable_typ_of_dyn_pred env pred, false))
  | C.TLiteral _ | C.TRef (_, _, _) | C.TRawPtr (_, _) | C.TFnPtr _ | C.TFnDef _ -> None
  (* The metadata must not have ptr metadata as they must be Sized. *)
  | C.TPtrMetadata _ -> None
  | C.TNever | C.TError _ -> failwith "Error types to fetch metadata"

(* Translate Charon type &T as a krml type -- this handles special cases
 where address-taking in Rust creates a DST, which we represent as instances
  of the dst_ref type. There are many such cases: slices, &str, etc. *)
and ptr_typ_of_ty (env : env) ~const (ty : Charon.Types.ty) : K.typ =
  (* Handle special cases first *)
  match ty with
  (* Special case to handle slice : &[T] *)
  | TSlice t -> Builtin.mk_slice ~const (typ_of_ty env t)
  (* Special case to handle &str *)
  | TAdt { id = TBuiltin TStr; _ } -> Builtin.str_t ~const
  (* Special case to handle DynTrait *)
  | TDynTrait pred ->
      Builtin.mk_dst_ref ~const Builtin.c_void_t (K.TBuf (vtable_typ_of_dyn_pred env pred, false))
  (* General case, all &T is turned to either thin T* or fat Eurydice::DstRef<T,Meta> *)
  | _ -> (
      let typ = typ_of_ty env ty in
      match metadata_typ_of_ty env ty with
      | None -> K.TBuf (typ, const)
      | Some meta -> Builtin.mk_dst_ref ~const typ meta)

and typ_of_ty (env : env) (ty : Charon.Types.ty) : K.typ =
  match ty with
  | TVar var -> K.TBound (lookup_typ env (C.expect_free_var var))
  | TLiteral t -> typ_of_literal_ty env t
  | TNever -> failwith "Impossible: Never"
  | TDynTrait _ -> failwith "TODO: dyn Trait"
  | TAdt { id = TBuiltin TBox; generics = { types = [ t ]; _ } } -> ptr_typ_of_ty ~const:false env t
  | TRef (_, t, rk) | TRawPtr (t, rk) ->
      let const = const_of_ref_kind rk in
      ptr_typ_of_ty env ~const t
  | TAdt { id; generics = { types = [ t ]; _ } as generics } when RustNames.is_vec env id generics
    -> Builtin.mk_vec (typ_of_ty env t)
  | TAdt { id = TAdtId id; generics = { types = args; const_generics = generic_args; _ } } ->
      let ts = List.map (typ_of_ty env) args in
      let cgs = List.map (cg_of_const_generic env) generic_args in
      let lid = lid_of_type_decl_id env id in
      K.fold_tapp (lid, ts, cgs)
  | TAdt { id = TTuple; generics = { types = args; const_generics; _ } } ->
      assert (const_generics = []);
      begin
        match args with
        | [] -> TUnit
        | [ t ] -> typ_of_ty env t (* charon issue #205 *)
        | _ -> TTuple (List.map (typ_of_ty env) args)
      end
  | TArray (t, cg) -> typ_of_struct_arr env t cg
  | TSlice t ->
      (* Appears in instantiations of patterns and generics, so we translate it to a placeholder. *)
      TApp (Builtin.derefed_slice, [ typ_of_ty env t ])
  | TAdt { id = TBuiltin TStr; generics = { types = []; _ } } -> Builtin.deref_str_t
  | TAdt { id = TBuiltin f; generics = { types = args; const_generics; _ } } ->
      List.iter (fun x -> print_endline (C.show_constant_expr x)) const_generics;
      fail "TODO: Adt/Builtin %s (%d) %d " (C.show_builtin_ty f) (List.length args)
        (List.length const_generics)
  | TTraitType _ -> failwith ("TODO: TraitTypes " ^ Charon.Print.ty_to_string env.format_env ty)
  | TFnPtr fn_sig ->
      let { C.inputs = ts; output = t; _ } = fn_sig.binder_value in
      let typs = List.map (typ_of_ty env) ts in
      let typs =
        match typs with
        | [] -> [ K.TUnit ]
        | typs -> typs
      in
      begin
        match typ_of_ty env t with
        | TArrow _ ->
            failwith
              "Function pointer `fn` currying is not supported, consider using `&'static dyn Fn` \
               instead."
        | typ -> Krml.Helpers.fold_arrow typs typ
      end
  | TFnDef bound_fn_ref -> begin
      match Charon.Substitute.lookup_fndef_sig env.crate bound_fn_ref with
      | None -> failwith "Missing function declaration"
      | Some fn_sig -> typ_of_ty env (TFnPtr fn_sig)
    end
  | TPtrMetadata _ ->
      failwith
        "The type-level computation `PtrMetadata(t)` should be handled by Charon, consider using \
         monomorphised LLBC."
  | TError _ -> failwith "Found type error in charon's output"

and typ_of_struct_arr (env : env) (t : C.ty) (cg : C.constant_expr) : K.typ =
  let typ_t = typ_of_ty env t in
  let cg = cg_of_const_generic env cg in
  Builtin.mk_arr typ_t cg

let maybe_cg_array (env : env) (t : C.ty) (cg : C.constant_expr) =
  match cg.kind with
  | CLiteral _ -> K.TArray (typ_of_ty env t, constant_of_scalar_value (assert_cg_scalar cg))
  | CVar var ->
      let id, cg_t = lookup_cg_in_types env (C.expect_free_var var) in
      assert (cg_t = K.TInt SizeT);
      K.TCgArray (typ_of_ty env t, id)
  | _ -> failwith "TODO: CgGlobal"

(* Environment: expressions *)

let is_var v2 v1 =
  match v2 with
  | Var (v2, _) -> v2 = v1
  | _ -> false

let assert_var = function
  | Var (v2, ty) -> v2, ty
  | _ -> assert false

let assert_trait_clause_method = function
  | TraitClauseMethod { ts; _ } -> ts
  | _ -> assert false

(* Regular binders *)

let lookup env v1 =
  let i, (_, t) = findi (fun (v2, _) -> is_var v2 v1) env.binders in
  i, t

let lookup_with_original_type env v1 =
  let i, (v, t) = findi (fun (v2, _) -> is_var v2 v1) env.binders in
  let _, ty = assert_var v in
  i, t, ty

(* Const generic binders *)

let push_cg_binder env (t : C.const_generic_param) =
  {
    env with
    cg_binders = (t.index, typ_of_ty env t.ty) :: env.cg_binders;
    binders = (ConstGenericVar t.index, typ_of_ty env t.ty) :: env.binders;
  }

let push_cg_binders env (ts : C.const_generic_param list) = List.fold_left push_cg_binder env ts

let push_binder env (t : C.local) =
  { env with binders = (Var (t.index, t.local_ty), typ_of_ty env t.local_ty) :: env.binders }

let push_binders env (ts : C.local list) = List.fold_left push_binder env ts

(* Clause binders, which only appear as function parameters, and hold an unknown
   trait method (dictionary-style). *)
let push_clause_binder env b = { env with binders = b :: env.binders }
let push_clause_binders env bs = List.fold_left push_clause_binder env bs

let lookup_clause_method env clause_id method_id =
  let i, (v, t) =
    try
      findi
        (function
          | TraitClauseMethod { clause_id = clause_id2; method_id = method_id2; _ }, _ ->
              clause_id2 = clause_id && method_id2 = method_id
          | _ -> false)
        env.binders
    with Not_found ->
      Krml.KPrint.bprintf "Error looking up %s.%s\n" (C.show_trait_ref_kind clause_id)
        (C.show_trait_method_id method_id);
      raise Not_found
  in
  i, t, assert_trait_clause_method v

let lookup_clause_constant env clause_id item_name =
  let i, (_, t) =
    try
      findi
        (function
          | TraitClauseConstant { clause_id = clause_id2; item_name = item_name2; _ }, _ ->
              clause_id2 = clause_id && item_name2 = item_name
          | _ -> false)
        env.binders
    with Not_found ->
      Krml.KPrint.bprintf "Error looking up %s.%s\n" (C.show_trait_ref_kind clause_id) item_name;
      raise Not_found
  in
  i, t

(** Translation of expressions (statements, operands, rvalues, places) *)

let uu =
  let r = ref 0 in
  fun () ->
    let suffix = string_of_int !r in
    incr r;
    "uu____" ^ suffix

let binder_of_var (env : env) (l : C.local) : K.binder =
  let name = Option.value ~default:(uu ()) l.name in
  let meta =
    match name with
    | "left_val" | "right_val" -> [ K.AttemptInline ]
    | _ -> []
  in
  let binder = Krml.Helpers.fresh_binder ~mut:true name (typ_of_ty env l.local_ty) in
  { binder with node = { binder.node with meta = meta @ binder.node.meta } }

let find_nth_variant (env : env) (typ : C.type_decl_id) (var : C.variant_id) =
  match env.get_nth_type typ with
  | { kind = Enum variants; _ } -> Charon.Types.VariantId.nth variants var
  | _ -> failwith "impossible: type is not a variant"

let rec with_locals (env : env) (t : K.typ) (locals : C.local list) (k : env -> 'a) : 'a =
  match locals with
  | [] -> k env
  | l :: locals ->
      let env = push_binder env l in
      let b = binder_of_var env l in
      K.(with_type t (ELet (b, Krml.Helpers.any, with_locals env t locals k)))

let lookup_cg_in_expressions (env : env) (v1 : C.const_generic_var_id) =
  let i, (_, t) = findi (fun (v2, _) -> v2 = ConstGenericVar v1) env.binders in
  i, t

let expression_of_cg_var_id env v =
  let i, t = lookup_cg_in_expressions env v in
  K.(with_type t (EBound i))

let expression_of_var_id (env : env) (v : C.local_id) : K.expr =
  let i, t = lookup env v in
  K.(with_type t (EBound i))

(** Assume here the maximum length is 128-bit -- will throw away the larger if larger. This is a
    helper function to split a 128-bit integer into two 64-bit integers and is not assumed to be
    used in other contexts. Returns the **expr** pair (high64bits, low64bits) *)
let split_128bit (value : Z.t) =
  let mask128 = Z.sub (Z.shift_left Z.one 128) Z.one in
  let mask64 = Z.sub (Z.shift_left Z.one 64) Z.one in
  (* Always truncate to 128 bits using bitwise AND *)
  let value = Z.logand value mask128 in
  (* Extract low 64 bits *)
  let low64 = Z.logand mask64 value in
  (* Shift right without sign extension (use logical shift) *)
  let high64 = Z.shift_right value 64 in
  let to_expr_u64bits v =
    let print_Z z = Z.format "%#x" z in
    K.with_type (K.TInt UInt64) @@ K.EConstant (UInt64, print_Z v)
  in
  to_expr_u64bits high64, to_expr_u64bits low64

let expression_of_int128_t (value : Z.t) =
  let i128_max = Z.sub (Z.shift_left Z.one 127) Z.one in
  if value > i128_max then
    failwith "value is larger than the maximum value of i128";
  let i128_min = Z.neg (Z.shift_left Z.one 127) in
  if value < i128_min then
    failwith "value is smaller than the minimum value of i128";
  let high64, low64 = split_128bit value in
  K.(with_type Builtin.int128_t (EApp (Builtin.(get_128_op ("i", "from_bits")), [ high64; low64 ])))

let expression_of_uint128_t (value : Z.t) =
  let u128_max = Z.sub (Z.shift_left Z.one 128) Z.one in
  if value > u128_max then
    failwith "value is larger than the maximum value of u128";
  let high64, low64 = split_128bit value in
  K.(
    with_type Builtin.uint128_t (EApp (Builtin.(get_128_op ("u", "from_bits")), [ high64; low64 ])))

let expression_of_scalar_value sv : K.expr =
  let int_ty = Charon.Scalars.get_ty sv in
  let value = Charon.Scalars.get_val sv in
  match int_ty with
  | C.Signed C.I128 -> expression_of_int128_t value
  | C.Unsigned C.U128 -> expression_of_uint128_t value
  | _ ->
      let w = width_of_integer_type int_ty in
      K.(with_type (TInt w) (EConstant (constant_of_scalar_value sv)))

let expression_of_literal (_env : env) (l : C.literal) : K.expr =
  match l with
  | VScalar sv -> expression_of_scalar_value sv
  | VBool b -> K.(with_type TBool (EBool b))
  | VStr s ->
      let ascii = Utf8.ascii_of_utf8_str s in
      let len = String.length s in
      K.(
        with_type (Builtin.str_t ~const:true)
          (EFlat
             [
               Some "ptr", with_type Krml.Checker.c_string (EString ascii);
               Some "meta", with_type Krml.Helpers.usize (EConstant (SizeT, string_of_int len));
             ]))
  | VChar c -> K.(with_type Builtin.char_t (EConstant (UInt32, string_of_int @@ Uchar.to_int c)))
  | VByteStr lst ->
      let str = List.map (Printf.sprintf "%#x") lst |> String.concat "" in
      K.(with_type Krml.Checker.c_string (EString str))
  | VFloat { C.float_ty; float_value } ->
      let w = float_width float_ty in
      K.(with_type (TInt w) (EConstant (w, float_value)))

let expression_of_const_generic env (cg : C.constant_expr) =
  match cg.kind with
  | C.CGlobal _ -> failwith "TODO: CgGLobal"
  | C.CVar var -> expression_of_cg_var_id env (C.expect_free_var var)
  | C.CLiteral l -> expression_of_literal env l
  | _ -> failwith "TODO: CgExpr"

let has_unresolved_generic (ty : K.typ) : bool =
  (object
     inherit [_] Krml.Ast.reduce
     method zero = false
     method plus = ( || )
     method! visit_TBound _ _ = true
  end)
    #visit_typ
    false ty

let rec expression_of_place (env : env) (p : C.place) : K.expr =
  (* We construct a target expression. Callers may still use the original type to tell arrays
     and references apart, since their *uses* (e.g. addr-of) compile in a type-directed way based on
     the *original* rust type *)
  match p.kind with
  | PlaceLocal var_id ->
      let i, t = lookup env var_id in
      K.(with_type t (EBound i))
  | PlaceGlobal { id; _ } ->
      let global = env.get_nth_global id in
      K.with_type (typ_of_ty env p.ty) (K.EQualified (lid_of_name env global.item_meta.name))
  | PlaceProjection (sub_place, PtrMetadata) -> begin
      let e = expression_of_place env sub_place in
      match e.typ with
      | TApp (lid, [ _; meta_ty ]) when is_dst_ref lid ->
          (* XXX need to adjust *)
          K.(with_type meta_ty (EField (e, "meta")))
      (* In cases like `PtrMetadata(T)` when `T` is a type variable or some types with unresolved type variable,
       We cannot tell the correct metadata type from it until fully monomorphized.
       But we can surely rely on monomorphized LLBC, and we ignore handling such cases in Eurydice. *)
      | ty when has_unresolved_generic ty ->
          failwith
            "Eurydice do not handle ptr-metadata for generic types. Consider using monomorphized \
             LLBC."
      (* Otherwise, fetching ptr-metadata from a non-DST simply results in `()`
       When a type is fully resolved and it is not `Eurydice::DstRef`, we can be confident that it is not a DST. *)
      | _ -> K.with_type TUnit K.EUnit
    end
  | PlaceProjection (sub_place, pe) -> begin
      (* Can't evaluate this here because of the special case for DSTs. *)
      let sub_e = lazy (expression_of_place env sub_place) in
      let ( !* ) = Lazy.force in
      (* L.log "AstOfLlbc" "e=%a\nty=%s\npe=%s\n" pexpr sub_e (C.show_ty sub_place.ty) *)
      (*   (C.show_projection_elem pe); *)
      match pe, sub_place, sub_place.ty with
      (* slices simply cannot be dereferenced into places which have unknown size.
         They are supposed to be reborrowed again directly after the deref which is handled in expression_of_rvalue *)
      | C.Deref, _, TRef (_, TSlice _, _) | C.Deref, _, TRawPtr (TSlice _, _) -> assert false
      | ( C.Deref,
          _,
          (TRawPtr _ | TRef _ | TAdt { id = TBuiltin TBox; generics = { types = [ _ ]; _ } }) ) ->
          (* All types represented as a pointer at run-time, compiled to a C pointer *)
          begin
            match !*sub_e.K.typ with
            | TBuf (t_pointee, _) ->
                let const =
                  match sub_place.ty with
                  | TRef (_, _, k) -> const_of_ref_kind k
                  | _ -> false
                in
                Krml.Helpers.(mk_deref ~const t_pointee !*sub_e.K.node)
            | t ->
                L.log "AstOfLlbc" "UNHANDLED DEREFERENCE\ne=%a\nt=%a\nty=%s\npe=%s\n" pexpr !*sub_e
                  ptyp t (C.show_ty sub_place.ty) (C.show_projection_elem pe);
                failwith "unhandled dereference"
          end
      | ( Field (ProjAdt (typ_id, None), field_id),
          { kind = PlaceProjection (sub_place, C.Deref); _ },
          C.TAdt _ ) ->
          let field_name = lookup_field env typ_id field_id in
          let sub_e = expression_of_place env sub_place in
          let place_typ = typ_of_ty env p.ty in
          let const =
            match sub_place.ty with
            | TRef (_, _, k) -> const_of_ref_kind k
            | _ -> false
          in
          begin
            match sub_e.K.typ with
            | K.TApp (dst_ref_hd, [ dst_t; _meta ]) when is_dst_ref dst_ref_hd ->
                (* getting field from a fat pointer of DST  *)
                (* XXX need to adjust *)
                K.with_type place_typ (K.EField (mk_dst_deref env dst_t sub_e, field_name))
            | _ ->
                (* Same as below *)
                K.with_type place_typ
                  (K.EField
                     ( Krml.Helpers.(
                         mk_deref ~const
                           (Krml.Helpers.assert_tbuf_or_tarray sub_e.K.typ)
                           sub_e.K.node),
                       field_name ))
          end
      | Field (ProjAdt (typ_id, variant_id), field_id), _, C.TAdt _ -> begin
          let place_typ = typ_of_ty env p.ty in
          match variant_id with
          | None ->
              let field_name = lookup_field env typ_id field_id in
              K.with_type place_typ (K.EField (!*sub_e, field_name))
          | Some variant_id ->
              let variant = find_nth_variant env typ_id variant_id in
              let field_id = C.FieldId.to_int field_id in
              let field = List.nth variant.fields field_id in
              let b =
                Krml.Helpers.fresh_binder (mk_field_name field.C.field_name field_id) place_typ
              in
              K.with_type place_typ
                K.(
                  EMatch
                    ( Unchecked,
                      !*sub_e,
                      [
                        ( [ b ],
                          with_type !*sub_e.typ
                            (PCons
                               ( variant.C.variant_name,
                                 List.init (List.length variant.fields) (fun i ->
                                     if i = field_id then
                                       with_type place_typ (PBound 0)
                                     else
                                       with_type TAny PWild) )),
                          with_type place_typ (EBound 0) );
                      ] ))
        end
      | ( Field (ProjTuple n, i),
          _,
          C.TAdt { id = _; generics = { types = tys; const_generics = cgs; _ } } ) ->
          let place_typ = typ_of_ty env p.ty in
          assert (cgs = []);
          (* match e with (_, ..., _, x, _, ..., _) -> x *)
          let i = Charon.Types.FieldId.to_int i in
          if List.length tys = 1 then begin
            assert (i = 0);
            (* Normalized one-element tuple *)
            !*sub_e
          end
          else
            let ts =
              match !*sub_e.typ with
              | TTuple ts -> ts
              | _ -> assert false
            in
            assert (List.length ts = n);
            let binders = [ Krml.Helpers.fresh_binder (uu ()) place_typ ] in
            let pattern =
              K.with_type !*sub_e.typ
                (K.PTuple
                   (List.mapi
                      (fun i' t ->
                        K.with_type t
                          (if i = i' then
                             K.PBound 0
                           else
                             PWild))
                      ts))
            in
            let expr = K.with_type place_typ (K.EBound 0) in
            K.with_type place_typ (K.EMatch (Unchecked, !*sub_e, [ binders, pattern, expr ]))
      (* | PlaceProjection () *)
      | _ -> fail "unexpected / ill-typed projection"
    end

let expression_of_place (env : env) (p : C.place) : K.expr =
  L.log "AstOfLlbc" "expression of place: %s" (C.show_place p);
  expression_of_place env p

(* We produce bit-wise operators first, then when the type is of booleans, we
   change into the non-B variants (Rust does not distinguish between bitwise and
   boolean operators) *)
let op_of_unop (op : C.unop) : Krml.Constant.op =
  match op with
  | C.Not -> BNot
  | C.Neg _ -> Neg
  | _ -> failwith (C.show_unop op)

let op_of_binop (op : C.binop) : Krml.Constant.op =
  match op with
  | C.BitXor -> BXor
  | C.BitAnd -> BAnd
  | C.BitOr -> BOr
  | C.Eq -> Eq
  | C.Lt -> Lt
  | C.Le -> Lte
  | C.Ne -> Neq
  | C.Ge -> Gte
  | C.Gt -> Gt
  | C.Div _ -> Div
  | C.Rem _ -> Mod
  | C.Add _ -> Add
  | C.Sub _ -> Sub
  | C.Mul _ -> Mult
  | C.Shl _ -> BShiftL
  | C.Shr _ -> BShiftR
  | _ -> fail "unsupported operator: %s" (C.show_binop op)

let op_128_of_op kind (op : K.op) : K.expr =
  let op_name =
    match op with
    | Add -> "add"
    | Sub -> "sub"
    | Mult -> "mul"
    | Div -> "div"
    | AddW -> "add"
    | SubW -> "sub"
    | MultW -> "mul"
    | DivW -> "div"
    | Mod -> "mod"
    | BShiftL -> "shl"
    | BShiftR -> "shr"
    | BAnd -> "band"
    | BOr -> "bor"
    | BXor -> "bxor"
    | Eq -> "eq"
    | Neq -> "neq"
    | Lt -> "lt"
    | Lte -> "lte"
    | Gt -> "gt"
    | Gte -> "gte"
    | Neg -> "neg"
    | BNot -> "bnot"
    | _ -> failwith "Unsupported operation for uint128"
  in
  Builtin.get_128_op (kind, op_name)

let mk_op_app (op : K.op) (first : K.expr) (rest : K.expr list) : K.expr =
  (* For 128-bit integers, the case is different: convert the operator & match the case here *)
  let op, ret_t =
    if first.typ = Builtin.int128_t || first.typ = Builtin.uint128_t then
      let op =
        if first.typ = Builtin.int128_t then
          op_128_of_op "i" op
        else
          op_128_of_op "u" op
      in
      let ret_t, _ = Krml.Helpers.flatten_arrow op.typ in
      op, ret_t
    else
      (* Otherwise, simply the normal case *)
      let op =
        if first.typ = K.TBool then
          match op with
          | BNot -> Krml.Constant.Not
          | BAnd -> And
          | BOr -> Or
          | BXor -> Xor
          | op -> op
        else
          op
      in
      let op_t = Krml.Helpers.type_of_op op first.typ in
      let op = K.(with_type op_t (EOp (op, first.typ))) in
      let ret_t, _ = Krml.Helpers.flatten_arrow op_t in
      op, ret_t
  in
  (* Rust is super lenient regarding the type of shift operators, we impose u32 -- see
     https://doc.rust-lang.org/std/ops/trait.Shl.html
  *)
  (* Additionally, if the op is `shift` (BShiftL/R for usual, (u)int128_shl/r for 128 bits)
    then the `rest` should be with a single element of type `uint32_t`
    if it is not, turn to type casting. *)
  (* Helper functions for this process *)
  let is_128_bit_shift_lident lident =
    [ Krml.Constant.BShiftL; BShiftR ]
    |> List.concat_map (fun op -> [ op_128_of_op "i" op; op_128_of_op "u" op ])
    |> List.map (fun (x : K.expr) -> Krml.Helpers.assert_elid x.K.node)
    |> List.mem lident
  in
  let modify_rest : K.expr list -> K.expr list = function
    | [ e2 ] -> begin
        match e2.node with
        | EConstant (_, s) ->
            let i = int_of_string s in
            assert (i >= 0);
            [ Krml.Helpers.mk_uint32 i ]
        | _ -> [ K.(with_type (TInt UInt32) (ECast (e2, TInt UInt32))) ]
      end
    | _ ->
        failwith
          "Invalid call to binary operator `shiftl` or `shiftr` -- the number of operands is not 2"
  in
  (* Modify here *)
  let rest =
    match op.node with
    | EOp (BShiftL, _) | EOp (BShiftR, _) -> modify_rest rest
    | EQualified lident when is_128_bit_shift_lident lident -> modify_rest rest
    | _ -> rest
  in
  K.(with_type ret_t (EApp (op, first :: rest)))

let addrof ~const (e : K.expr) = K.(with_type (TBuf (e.typ, const)) (EAddrOf e))

(** Handling trait clauses as dictionaries *)

(* There are two ways that we skip synthesis of trait methods in function calls. The first one is if
   a trait declaration is blocklisted. This happens if the trait has built-in support (e.g.
   FnMut), or if the trait relies on unsupported features (e.g. provided methods,
   used by Iterator's chunk_next, for instance; or associated types; or parent
   clauses). The second way we skip trait methods (further down) is if the
   function is a known builtin implementation. *)
let blocklisted_trait_decls =
  [
    (* These don't have methods *)
    "core::marker::Sized";
    "core::marker::MetaSized";
    "core::marker::PointeeSized";
    "core::marker::Send";
    "core::marker::Sync";
    "core::marker::Tuple";
    "core::marker::Copy";
    (* The traits below *should* be handled properly ASAP. But for now, we have specific *instances*
       of those trait methods in the builtin lookup table, which we then implement by hand with
       macros. *)
    "core::iter::traits::iterator::Iterator";
    "core::iter::range::Step";
    (* TODO: figure out what to do with those *)
    "core::clone::Clone";
    (* TODO: these ones carry the drop_in_place code, but sometimes there's no
       explicit impl (because it's trivial e.g. for usize) which is tricky. *)
    "core::marker::Destruct";
    "core::fmt::Debug";
    "core::ptr::metadata::Thin";
  ]

(* Interpret a Rust function type, with trait bounds, into the krml Ast, providing:
   - the type scheme (fields may be zero)
   - the cg types, which only contains the original Rust const generic variables
   - the argument types, prefixed by the dictionary-style passing of trait clause methods
   - the return type
   - whether the function is builtin, or not. *)
type lookup_result = {
  ts : K.type_scheme; (* just for a sanity check *)
  cg_types : K.typ list;
  arg_types : K.typ list;
  ret_type : K.typ;
  is_known_builtin : bool;
}

let maybe_ts ts t =
  if ts.K.n <> 0 || ts.n_cgs <> 0 then
    K.TPoly (ts, t)
  else
    t

(* For a given function, a (flat) list of all the trait methods that are
   transitively, possibly called by this function, based on the trait bounds in
   its signature.

   Using tests/where_clauses_simple as an example.

   fn double<T: Ops + Copy, U: Ops+Copy> (...)

   this gets desugared to fn double<T,U> where
     T: Ops,      <-- ClauseId 0 (required_methods: add, of_u32)
     T: Copy,     <-- ClauseId 1 (builtin, so neither required nor provided methods)
     U: Ops,      <-- ClauseId 2 (required_methods: add, of_u32)
     U: Copy,     <-- ClauseId 3 (builtin, so neither required nor provided methods)

   the types we obtain by looking up the trait declaration have Self as 0
   (DeBruijn).

   When building a function declaration, this synthesizes all the extra binders
   required for trait methods (passed as function pointers). Assumes type
   variables have been suitably bound in the environment.
*)
let rec mk_clause_binders_and_args env ?depth ?clause_ref (trait_clauses : C.trait_param list) :
    (var_id * K.typ) list =
  let depth = Option.value ~default:"" depth in
  List.concat_map
    (fun tc ->
      let {
        C.clause_id;
        trait = { binder_value = { id = trait_decl_id; generics = trait_generics }; _ };
        _;
      } =
        tc
      in
      let trait_decl = env.get_nth_trait_decl trait_decl_id in
      (* Every item inside the `trait_decl` may refer to generic params of the
         trait. To get items that are valid to return outside of the scope of
         the trait, we must substitute them with the given generics. We should
         in principle substitute everything but we currently don't. This will
         likely be a source of bugs. *)
      let subst =
        Charon.Substitute.make_subst_from_generics trait_decl.generics trait_generics Self
      in
      let substitute_visitor = Charon.Substitute.st_substitute_visitor in

      let name = string_of_name env trait_decl.item_meta.name in
      let clause_ref : C.trait_ref =
        Option.value
          ~default:C.{ kind = C.Clause (Free clause_id); trait_decl_ref = tc.trait }
          clause_ref
      in

      if List.mem name blocklisted_trait_decls then
        []
      else begin
        (* FYI, some clauses like Copy have neither required nor provided methods. *)
        L.log "TraitClauses"
          "%sclause decl %s\n\
          \  id %d:\n\
          \  decl_generics.types are %s\n\
          \  decl_generics.const_generics are %s\n\
          \  methods: %d\n"
          depth name
          (C.TraitClauseId.to_int clause_id)
          (String.concat " ++ " (List.map C.show_ty trait_generics.C.types))
          (String.concat " ++ " (List.map C.show_constant_expr trait_generics.C.const_generics))
          (C.TraitMethodId.Map.cardinal trait_decl.C.methods);

        (* 1. Associated constants *)
        List.map
          (fun (const : C.trait_assoc_const) ->
            let trait_name = trait_decl.C.item_meta.name in
            let pretty_name = string_of_name env trait_name ^ "_" ^ const.C.name in
            let t = substitute_visitor#visit_ty subst const.C.ty in
            let t = typ_of_ty env t in
            ( TraitClauseConstant
                { item_name = const.C.name; pretty_name; clause_id = clause_ref.kind },
              t ))
          trait_decl.C.consts
        (* 2. Trait methods *)
        @ List.map
            (fun ((method_id, mthd) : _ * C.trait_method C.binder) ->
              let item_name = mthd.C.binder_value.C.name in
              let trait_name = trait_decl.C.item_meta.name in
              let pretty_name = string_of_name env trait_name ^ "_" ^ item_name in

              (* Ask charon for the properly bound method signature. *)
              let bound_method_sig : C.fun_sig C.binder C.item_binder =
                Option.get (Charon.Substitute.lookup_method_sig env.crate trait_decl_id method_id)
              in
              (* First we substitute the trait generics. *)
              let bound_method_sig : C.fun_sig C.binder =
                Charon.Substitute.apply_args_to_item_binder clause_ref.kind trait_generics
                  (substitute_visitor#visit_binder substitute_visitor#visit_fun_sig)
                  bound_method_sig
              in

              (* We then construct a polymorphic signature for this method.
                 Its generics are the method generics (the ones in the binder).
                 *)
              let method_sig =
                Charon.Substitute.(
                  (* Variables bound in the inner binder are `Bound`, which
                     eurydice doesn't handle. We therefore make them all `Free`
                     variables, shifting indices to avoid overlap with existing
                     in-scope variables. *)
                  let ambient_ts =
                    { K.n = List.length env.type_binders; K.n_cgs = List.length env.cg_binders }
                  in
                  let shift_ty_var varid =
                    C.TypeVarId.of_int (C.TypeVarId.to_int varid + ambient_ts.K.n)
                  in
                  let shift_cg_var varid =
                    C.ConstGenericVarId.of_int
                      (C.ConstGenericVarId.to_int varid + ambient_ts.K.n_cgs)
                  in
                  (* Replace bound variables with free variables that don't
                     overlap with existing ones. *)
                  let subst =
                    subst_remove_binder_zero
                      {
                        empty_free_sb_subst with
                        ty_sb_subst =
                          (fun varid -> empty_free_sb_subst.ty_sb_subst (shift_ty_var varid));
                        cg_sb_subst =
                          (fun varid -> empty_free_sb_subst.cg_sb_subst (shift_cg_var varid));
                      }
                  in

                  let signature =
                    st_substitute_visitor#visit_fun_sig subst bound_method_sig.binder_value
                  in
                  (* Gotta shift the params too, as trait clause may refer to bound types. *)
                  let method_params =
                    st_substitute_visitor#visit_generic_params subst bound_method_sig.binder_params
                  in
                  (* Finally, update the parameters so they use the new, shifted indices. *)
                  let method_params =
                    {
                      method_params with
                      types =
                        List.map
                          (fun (var : C.type_param) ->
                            { var with C.index = shift_ty_var var.C.index })
                          method_params.types;
                      const_generics =
                        List.map
                          (fun (var : C.const_generic_param) ->
                            { var with C.index = shift_cg_var var.C.index })
                          method_params.const_generics;
                    }
                  in
                  { C.item_binder_params = method_params; item_binder_value = signature })
              in
              L.log "TraitClauses" "%s computed method signature %s::%s:\n%s" depth name item_name
                (Charon.Print.fun_sig_to_string env.format_env "" " " method_sig);
              let ts, t = typ_of_signature env method_sig in
              let t = maybe_ts ts t in
              ( TraitClauseMethod
                  { method_id; item_name; pretty_name; clause_id = clause_ref.kind; ts },
                t ))
            (C.TraitMethodId.Map.to_list trait_decl.C.methods)
        (* 1 + 2, recursively, for parent traits *)
        @ List.concat_map
            (fun (parent_clause : C.trait_param) ->
              (* Make the clause valid outside the scope of the trait decl. *)
              let parent_clause = substitute_visitor#visit_trait_param subst parent_clause in
              (* Mapping of the methods of the parent clause *)
              let clause_ref : C.trait_ref =
                {
                  kind = ParentClause (clause_ref, parent_clause.clause_id);
                  trait_decl_ref = parent_clause.trait;
                }
              in
              mk_clause_binders_and_args env ~depth:(depth ^ "--") ~clause_ref [ parent_clause ])
            trait_decl.C.implied_clauses
      end)
    trait_clauses

and lookup_signature env depth (signature : C.bound_fun_sig) : lookup_result =
  let {
    C.item_binder_params = { types = type_params; const_generics; trait_clauses; _ };
    item_binder_value = { C.inputs; output; _ };
  } =
    signature
  in
  L.log "Calls" "%s# Lookup Signature\n%s--> args: %s, ret: %s\n" depth depth
    (String.concat " ++ " (List.map (Charon.Print.ty_to_string env.format_env) inputs))
    (Charon.Print.ty_to_string env.format_env output);
  L.log "Calls" "%sType parameters for this signature: %s\n" depth
    (String.concat " ++ " (List.map Charon.Print.type_param_to_string type_params));
  let env = push_cg_binders env const_generics in
  let env = push_type_binders env type_params in

  let clause_binders = mk_clause_binders_and_args env trait_clauses in
  debug_trait_clause_mapping env clause_binders;
  let clause_ts = List.map snd clause_binders in

  {
    ts = { n = List.length type_params; n_cgs = List.length const_generics };
    cg_types = List.map (fun (v : C.const_generic_param) -> typ_of_ty env v.ty) const_generics;
    arg_types =
      (clause_ts
      @ List.map (typ_of_ty env) inputs
      @
      if inputs = [] then
        [ K.TUnit ]
      else
        []);
    ret_type = typ_of_ty env output;
    is_known_builtin = false;
  }

(* Transforms a lookup result into a usable type, taking into account the fact that the internal Ast
   is ML-style and does not have zero-argument functions. *)
and typ_of_signature env signature =
  let { cg_types = const_generics_ts; arg_types = inputs; ret_type = output; ts; _ } =
    lookup_signature env "" signature
  in

  let adjusted_inputs = const_generics_ts @ inputs in

  let t = Krml.Helpers.fold_arrow adjusted_inputs output in
  ts, t

and debug_trait_clause_mapping env (mapping : (var_id * K.typ) list) =
  if mapping = [] then
    L.log "TraitClauses" "# Debug Mapping\nIn this function, trait clause mapping is empty"
  else
    L.log "TraitClauses"
      "# Debug Mapping\nIn this function, calls to trait bound methods are as follows:";
  List.iter
    (fun (clause_entry, t) ->
      match clause_entry with
      | TraitClauseMethod { clause_id; item_name; ts; _ } ->
          L.log "TraitClauses" "@@@ method name: %s" item_name;
          L.log "TraitClauses" "%s::%s: %a has trait-level %d const generics, %d type vars\n"
            (Charon.Print.trait_ref_kind_to_string env.format_env None clause_id)
            item_name ptyp t ts.K.n_cgs ts.n
      | TraitClauseConstant { clause_id; item_name; _ } ->
          L.log "TraitClauses" "@@@ method name: %s" item_name;
          L.log "TraitClauses" "%s::%s: associated constant %a\n"
            (Charon.Print.trait_ref_kind_to_string env.format_env None clause_id)
            item_name ptyp t
      | _ -> ())
    mapping

(** Compiling function instantiations into krml application nodes. *)

(* First step: produce an expression for the un-instantiated function reference, along with all the
   type information required to build a proper instantiation. The function reference is an expression
   that is either a reference to a variable in scope (trait methods), or to a top-level qualified
   name, which encompasses both externally-defined function (builtins), or regular functions. *)
let lookup_fun (env : env) depth (fn_ptr : C.fn_ptr) : K.expr' * lookup_result =
  let open RustNames in
  let matches p = Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config p fn_ptr in
  let builtin b =
    let { Builtin.name; typ; n_type_args; cg_args; _ } = b in
    let ret_type, arg_types = Krml.Helpers.flatten_arrow typ in
    let ts = { K.n = n_type_args; K.n_cgs = List.length cg_args } in
    K.EQualified name, { ts; arg_types; ret_type; cg_types = cg_args; is_known_builtin = true }
  in
  match List.find_opt (fun (p, _) -> matches p) (known_builtins !Options.no_const) with
  | Some (_, b) -> builtin b
  | None -> (
      let lookup_result_of_fun_id fun_id =
        let decl = env.get_nth_function fun_id in
        let lid = lid_of_name env decl.C.item_meta.name in
        L.log "Calls" "%s--> name: %a" depth plid lid;
        K.EQualified lid, lookup_signature env depth (C.bound_fun_sig_of_decl decl)
      in

      match fn_ptr.kind with
      | FunId (FRegular f) -> lookup_result_of_fun_id f
      | FunId (FBuiltin f) -> fail "unknown builtin function: %s" (C.show_builtin_fun_id f)
      | TraitMethod (trait_ref, method_id, _trait_opaque_signature) -> (
          match trait_ref.kind with
          | TraitImpl { id; _ } ->
              let trait_impl = env.get_nth_trait_impl id in
              let f =
                try C.TraitMethodId.Map.find method_id trait_impl.methods
                with Not_found ->
                  fail "Error looking trait impl: %s%!"
                    (Charon.Print.fn_ptr_to_string env.format_env fn_ptr)
              in
              lookup_result_of_fun_id f.C.binder_value.id
          | (Clause _ | ParentClause _) as tcid ->
              let f, t, sig_info = lookup_clause_method env tcid method_id in
              (* the sig_info is kind of redundant here *)
              let t =
                match t with
                | TPoly (_, t) -> t
                | _ -> t
              in
              let ret_type, arg_types = Krml.Helpers.flatten_arrow t in
              let cg_types, arg_types = Krml.KList.split sig_info.n_cgs arg_types in
              EBound f, { ts = sig_info; cg_types; arg_types; ret_type; is_known_builtin = false }
          | _ ->
              fail "Error looking trait ref: %s%!"
                (Charon.Print.fn_ptr_to_string env.format_env fn_ptr)))

let fn_ptr_is_opaque env (fn_ptr : C.fn_ptr) =
  match fn_ptr.kind with
  | FunId (FRegular id) -> (
      try
        match (env.get_nth_function id).body with
        | StructuredBody _ -> false
        | _ -> true
      with Not_found -> false)
  | _ -> false

(* This is a very core piece of logic that transforms a Rust fn_ptr into a krml AST node that
   contains type application, const generic applications, and application of trait methods to
   implement the dictionary-passing style. *)
let rec expression_of_fn_ptr env depth (fn_ptr : C.fn_ptr) =
  let {
    C.generics = { types = type_args; const_generics = const_generic_args; trait_refs; _ };
    kind;
    _;
  } : C.fn_ptr =
    fn_ptr
  in

  (* We handle any kind of fn_ptr, whether it's a concrete function call, a
     concrete trait implementation method call, or an abstract trait method call
     (e.g. a call to T::f when T is a trait bound in scope). *)
  L.log "Calls" "%sVisiting call: %s" depth (Charon.Print.fn_ptr_to_string env.format_env fn_ptr);
  L.log "Calls" "%s--> %d type_args, %d const_generics, %d trait_refs" depth (List.length type_args)
    (List.length const_generic_args) (List.length trait_refs);

  (* In case this is a call to a trait implementation method, there are two
     levels of applications: the trait-generic arguments (i.e. impl <T: ...> for ...)
     and the method-generic arguments (i.e. fn f<U: ...>). The method appears as
     a top-level function that receives all the arguments for T and U (types,
     const generics, trait references), and when we synthesize a call node, we
     do behave accordingly and provide arguments for both T and U. *)
  let type_args, const_generic_args, trait_refs =
    let generics =
      match kind with
      | TraitMethod ({ kind = TraitImpl { generics; _ }; _ }, _, _) ->
          L.log "Calls" "%s--> this is a trait method" depth;
          generics
      | _ -> C.empty_generic_args
    in
    ( generics.types @ type_args,
      generics.const_generics @ const_generic_args,
      generics.trait_refs @ trait_refs )
  in

  L.log "Calls" "%s--> %d type_args, %d const_generics, %d trait_refs" depth (List.length type_args)
    (List.length const_generic_args) (List.length trait_refs);
  L.log "Calls" "%s--> trait_refs: %s\n" depth
    (String.concat " ++ " (List.map (Charon.Print.trait_ref_to_string env.format_env) trait_refs));
  L.log "Calls" "%s--> pattern: %s" depth (string_of_fn_ptr env fn_ptr);
  L.log "Calls" "%s--> type_args: %s" depth
    (String.concat ", " (List.map (Charon.Print.ty_to_string env.format_env) type_args));

  (* The function itself, along with information about its *signature*. *)
  let f, { ts; arg_types = inputs; ret_type = output; cg_types = cg_inputs; is_known_builtin } =
    lookup_fun env depth fn_ptr
  in
  L.log "Calls" "%s--> %d inputs: %a" depth (List.length inputs) ptyps inputs;
  L.log "Calls" "%s--> is_known_builtin?: %b" depth is_known_builtin;

  (* Translate effective type and cg arguments. *)
  let const_generic_args =
    match f, type_args with
    | EQualified lid, [ _; TRef (_, TArray (_, cg), _); _ ]
      when lid = Builtin.slice_to_ref_array.name ->
        (* Special case, we *do* need to retain the length, which would disappear if we simply did
           typ_of_ty (owing to array decay rules). *)
        [ expression_of_const_generic env cg ]
    | _ -> List.map (expression_of_const_generic env) const_generic_args
  in
  let type_args = List.map (typ_of_ty env) type_args in

  (* Handling trait implementations for generic trait bounds in the callee. We
     synthesize krml expressions that correspond to each one of the trait methods
     that the callee expects. Order matters here. *)
  let fn_ptrs : K.expr list =
    if is_known_builtin then
      (* If this is a known builtin implementation, we do not materialize trait methods, on the
         basis that this is likely something from the standard library that exercises more features
         that we can support, and that since we hand-write it, we don't need this level of precision
         anyhow. *)
      []
    else
      (* MUST have the same structure as mk_clause_binders_and_args *)
      let rec build_trait_ref_mapping depth (trait_refs : C.trait_ref list) =
        List.concat_map
          (fun (trait_ref : C.trait_ref) ->
            let name =
              string_of_name env
                (env.get_nth_trait_decl trait_ref.trait_decl_ref.binder_value.id).item_meta.name
            in
            L.log "Calls" "%s--> trait_ref %s: %s\n" depth name (C.show_trait_ref trait_ref);

            match trait_ref.kind with
            | _ when List.mem name blocklisted_trait_decls ->
                (* Trait not supported -- don't synthesize arguments *)
                []
            | TraitImpl { id = impl_id; generics = _generics } ->
                (* Call-site has resolved trait clauses into a concrete trait implementation. *)
                let trait_impl : C.trait_impl = env.get_nth_trait_impl impl_id in

                (* This must be in agreement, and in the same order as mk_clause_binders_and_args *)
                List.map
                  (fun ((_item_name, { C.id; generics }) : _ * C.global_decl_ref) ->
                    if
                      not
                        (generics.types = [] && generics.const_generics = []
                       && generics.trait_refs = [])
                    then
                      failwith "TODO: polymorphic globals";
                    let global = env.get_nth_global id in
                    K.with_type (typ_of_ty env global.ty)
                      (K.EQualified (lid_of_name env global.item_meta.name)))
                  trait_impl.consts
                @ List.map
                    (fun ((method_id, bound_fn) : _ * C.fun_decl_ref C.binder) ->
                      let fun_decl_id = bound_fn.C.binder_value.C.id in
                      let fn_ptr : C.fn_ptr =
                        {
                          kind = TraitMethod (trait_ref, method_id, fun_decl_id);
                          generics = Charon.TypesUtils.empty_generic_args;
                        }
                      in
                      let fn_ptr = fst3 (expression_of_fn_ptr env (depth ^ "  ") fn_ptr) in
                      fn_ptr)
                    (C.TraitMethodId.Map.to_list trait_impl.methods)
                @ build_trait_ref_mapping ("  " ^ depth)
                    (let subst =
                       Charon.Substitute.make_subst_from_generics trait_impl.generics _generics Self
                     in
                     (*_generics.trait_refs*)
                     List.map
                       (Charon.Substitute.st_substitute_visitor#visit_trait_ref subst)
                       trait_impl.implied_trait_refs)
            | Clause _ as clause_id ->
                (* Caller it itself polymorphic and refers to one of its own clauses to synthesize
                   the clause arguments at call-site. We must pass whatever is relevant for this
                   clause, *transitively* (this means all the reachable parents). *)
                let rec relevant = function
                  | C.ParentClause (tref', _) -> relevant tref'.kind
                  | clause_id' -> clause_id = clause_id'
                in
                List.rev
                  (Krml.KList.filter_mapi
                     (fun i (var, t) ->
                       match var with
                       | TraitClauseMethod { clause_id = clause_id'; _ }
                       | TraitClauseConstant { clause_id = clause_id'; _ }
                         when relevant clause_id' -> Some K.(with_type t (EBound i))
                       | _ -> None)
                     env.binders)
            | ParentClause (tref, clause_id) ->
                let decl_id = tref.trait_decl_ref.binder_value.id in
                let trait_decl = env.get_nth_trait_decl decl_id in
                let name = string_of_name env trait_decl.item_meta.name in
                let clause_id = C.TraitClauseId.to_int clause_id in
                let parent_clause = List.nth trait_decl.implied_clauses clause_id in
                let parent_clause_decl =
                  env.get_nth_trait_decl parent_clause.trait.binder_value.id
                in
                let parent_name = string_of_name env parent_clause_decl.item_meta.name in
                Krml.KPrint.bprintf "looking up parent clause #%d of decl=%s = %s\n" clause_id name
                  parent_name;
                if List.mem parent_name blocklisted_trait_decls then
                  []
                else
                  failwith
                    ("Don't know how to resolve trait_ref above (2): "
                    ^ Charon.Print.trait_ref_to_string env.format_env trait_ref)
            | _ ->
                failwith
                  ("Don't know how to resolve trait_ref above (2): "
                  ^ Charon.Print.trait_ref_to_string env.format_env trait_ref))
          trait_refs
      in
      build_trait_ref_mapping depth trait_refs
  in
  L.log "Calls" "%s--> trait method impls: %d" depth (List.length fn_ptrs);

  (* This needs to match what is done in the FunGroup case (i.e. when we extract
     a definition). There are two behaviors depending on whether the function is
     builtin or not. *)
  let inputs =
    if inputs = [] then
      [ K.TUnit ]
    else
      inputs
  in

  (* From here on, this is only krml logic, which is about building
     properly-annotated internal nodes that take care of instantiating generic
     type schemes, dealing with type applications, const genericss, etc.
     followed by the application of trait methods (in the special TApp node). *)
  let t_unapplied = maybe_ts ts (Krml.Helpers.fold_arrow (cg_inputs @ inputs) output) in
  let offset = List.length env.binders - List.length env.cg_binders in
  L.log "Calls" "%s--> t_unapplied: %a" depth ptyp t_unapplied;
  L.log "Calls" "%s--> inputs: %a" depth ptyps inputs;
  L.log "Calls" "%s--> const_generic_args: %a (offset: %d)" depth pexprs const_generic_args offset;
  L.log "Calls" "%s--> %d fn_ptrs: %a (offset: %d)" depth (List.length fn_ptrs)
    (fun k e ->
      List.iter
        (fun e ->
          pexpr k e;
          Buffer.add_string k ": ";
          ptyp k e.typ)
        e)
    fn_ptrs offset;

  let t_applied =
    match t_unapplied with
    | TPoly ({ n; n_cgs }, t) ->
        let ts =
          { K.n = n - List.length type_args; n_cgs = n_cgs - List.length const_generic_args }
        in
        if ts.n > 0 || ts.n_cgs > 0 then
          K.TPoly (ts, t)
        else
          t
    | t -> t
  in
  L.log "Calls" "%s--> t_applied (1): %a" depth ptyp t_applied;
  let t_applied =
    Krml.DeBruijn.(subst_tn type_args (subst_ctn offset const_generic_args t_applied))
  in
  L.log "Calls" "%s--> t_applied (2): %a" depth ptyp t_applied;
  let t_applied =
    match t_applied with
    | TPoly (ts, t) ->
        assert (fn_ptrs = []);
        let ret, args = Krml.Helpers.flatten_arrow t in
        let _, args = Krml.KList.split (List.length const_generic_args) args in
        K.TPoly (ts, Krml.Helpers.fold_arrow args ret)
    | t ->
        let ret, args = Krml.Helpers.flatten_arrow t in
        if List.length const_generic_args + List.length fn_ptrs > List.length args then
          L.log "Calls" "ERROR in %s" (Charon.Print.fn_ptr_to_string env.format_env fn_ptr);
        let _, args =
          Krml.KList.split (List.length const_generic_args + List.length fn_ptrs) args
        in
        Krml.Helpers.fold_arrow args ret
  in
  L.log "Calls" "%s--> t_applied: %a" depth ptyp t_applied;
  let hd =
    let hd = K.with_type t_unapplied f in
    if type_args <> [] || const_generic_args <> [] || fn_ptrs <> [] then
      K.with_type t_applied (K.ETApp (hd, const_generic_args, fn_ptrs, type_args))
    else
      hd
  in
  L.log "Calls" "%s--> hd: %a" depth pexpr hd;
  ( hd,
    is_known_builtin,
    match t_applied with
    | TPoly (ts, t) -> K.TPoly (ts, fst (Krml.Helpers.flatten_arrow t))
    | t -> fst (Krml.Helpers.flatten_arrow t) )

let expression_of_fn_ptr env (fn_ptr : C.fn_ptr) = expression_of_fn_ptr env "" fn_ptr

let global_is_const env id =
  match (env.get_nth_global id).global_kind with
  | NamedConst | AnonConst -> true
  | Static -> false

let expression_of_operand (env : env) (op : C.operand) : K.expr =
  match op with
  | Copy ({ kind = PlaceGlobal { id; _ }; _ } as p) when global_is_const env id ->
      (* No need to copy a const since by definition it cannot be modified *)
      expression_of_place env p
  | Copy p -> expression_of_place env p
  | Move p -> expression_of_place env p
  | Constant { kind = CLiteral l; _ } -> expression_of_literal env l
  | Constant { kind = CVar var; _ } -> expression_of_cg_var_id env (C.expect_free_var var)
  | Constant { kind = CFnDef fn_ptr; _ } ->
      let e, _, _ = expression_of_fn_ptr env fn_ptr in
      e
  | Constant { kind = CTraitConst (({ C.kind; _ } as trait_ref), name); _ } -> begin
      (* Logic similar to lookup_fun *)
      match kind with
      | Clause _ | ParentClause _ ->
          let i, t = lookup_clause_constant env kind name in
          K.(with_type t (EBound i))
      | TraitImpl { id; _ } ->
          let trait = env.get_nth_trait_impl id in
          let global =
            try List.assoc name trait.consts
            with Not_found ->
              fail "Error looking trait impl: %s %s%!"
                (Charon.Print.trait_ref_to_string env.format_env trait_ref)
                name
          in
          let global = env.get_nth_global global.C.id in
          K.with_type (typ_of_ty env global.ty)
            (K.EQualified (lid_of_name env global.item_meta.name))
      | _ ->
          fail "expression_of_operand Constant: %s"
            (Charon.Print.operand_to_string env.format_env op)
    end
  | Constant { kind = CAdt _; ty } when Charon.TypesUtils.ty_is_unit ty -> K.with_type TUnit K.EUnit
  | Constant _ ->
      fail "expression_of_operand: %s" (Charon.Print.operand_to_string env.format_env op)

let is_str env var_id =
  match lookup_with_original_type env var_id with
  | _, _, TRef (_, TAdt { id = TBuiltin TStr; generics = { types = []; _ } }, _) -> true
  | _ -> false

let is_box_place (p : C.place) =
  match p.ty with
  | C.TAdt { id = TBuiltin TBox; _ } -> true
  | _ -> false

(* returns either a regular naked C pointer, or a fat pointer in the case of DSTs (i.e. with non-empty metadata) *)
let mk_reference ~const (e : K.expr) (metadata : K.expr) : K.expr =
  match metadata.typ with
  (* When it is unit, it means there is no metadata, simply take the address *)
  | K.TUnit -> addrof ~const e
  | _ -> (
      match e.typ with
      | TApp (lid, [ t ]) when lid = Builtin.derefed_slice ->
          (* The special "base case" of DSTs: slice<T>
          where we have to cast [derefed_slice<T>] into [T*] for the .ptr field in the fat pointer  *)
          let ptr = K.(with_type (TBuf (t, const)) (ECast (e, TBuf (t, const)))) in
          K.(
            with_type
              (Builtin.mk_dst_ref ~const t metadata.typ)
              (EFlat [ Some "ptr", ptr; Some "meta", metadata ]))
      | _ ->
          K.(
            with_type
              (Builtin.mk_dst_ref ~const e.typ metadata.typ)
              (EFlat [ Some "ptr", addrof ~const e; Some "meta", metadata ])))

(* To destruct a DST reference type into its base and metadata types
   I.e., from Eurydice_dst_ref<T, meta> to (T, meta) *)
let destruct_dst_ref_typ t =
  match t with
  | K.TApp (dst_ref_hd, [ t_base; t_meta ]) when is_dst_ref dst_ref_hd -> Some (t_base, t_meta)
  | _ -> None

(* Get the base pointer expression from a DST reference expression
   I.e., from `e : Eurydice_dst_ref<T, meta>` to `e.ptr : T*` *)
let get_dst_ref_base dst_ref =
  match destruct_dst_ref_typ dst_ref.K.typ with
  (* XXX fixme *)
  | Some (base, _) -> Some K.(with_type (TBuf (base, false)) (EField (dst_ref, "ptr")))
  | None -> None

(* Parse the fat pointer Eurydice_dst_ref<T<U>, _> into (T,T<U>),
   where the ignored field `_` must be `usize` as metadata,
   used to handle the unsized cast from &T<V> to &T<U> *)
let destruct_arr_dst_ref t =
  match t with
  | K.TApp (dst_ref_hd, [ (TApp (lid, _) as t_u); _ ]) when is_dst_ref dst_ref_hd -> Some (lid, t_u)
  | _ -> None

(* Reborrows allow going from a mutable slice to an immutable one. *)
let maybe_reborrow_slice t_dst e_src =
  let open K in
  match e_src.typ, t_dst with
  | TApp (hd1, [ t_ptr; t_meta ]), TApp (hd2, _) when is_dst_ref hd1 && is_dst_ref hd2 && hd1 <> hd2
    ->
      let mk e =
        with_type t_dst
          (EFlat
             [
               Some "ptr", with_type (TBuf (t_ptr, true)) (EField (e, "ptr"));
               Some "meta", with_type t_meta (EField (e, "meta"));
             ])
      in
      if Krml.Helpers.is_readonly_c_expression e_src then
        mk e_src
      else
        with_type t_dst
          (ELet
             ( Krml.Helpers.fresh_binder "reborrowed_slice" e_src.typ,
               e_src,
               mk (with_type e_src.typ (EBound 0)) ))
  | _ -> e_src

let expression_of_rvalue (env : env) (p : C.rvalue) expected_ty : K.expr =
  match p with
  | Use op -> expression_of_operand env op
  (* Generally, MIR / current LLBC is guaranteed to apply [Deref] only to places that are
     references or raw pointers, in these cases [&*p] == [p].
     The [Deref] traits types are desugared to function calls to [deref].
     The ONLY exception is when the place is a [Box]. That is, MIR/LLBC might generate [*b]
     where [b] is a [Box]. This refers to taking the value out of the [Box].
     Recall that [Box] is a wrapper of [Unique], which is in turn a wrapper of a [NonNull],
     which is a wrapper of a raw pointer. Hence, [*b] when [b] is a [Box] is equivalent to
     [*(b.0.pointer.pointer)]. This is a compiler magic.

     However, in Eurydice *now*, [Box] types are instantly unboxed to raw pointers, which
     coincides exactly with our current implementation, hence no extra handling is needed.
     In the future however, we might want to handle [Box] types differently, so this is a note
     to ourselves to be careful with this.
     *)
  | RvRef ({ kind = PlaceProjection (p, Deref); _ }, _, _)
  | RawPtr ({ kind = PlaceProjection (p, Deref); _ }, _, _) ->
      (* Notably, this is NOT simply an optimisation, as this represents re-borrowing, and [p] might
         be a reference to DST (fat pointer). *)
      (* This also works for when the case has metadata, simply ignore it *)
      maybe_reborrow_slice (typ_of_ty env expected_ty) (expression_of_place env p)
  | RvRef (p, bk, metadata) ->
      let metadata = expression_of_operand env metadata in
      let e = expression_of_place env p in
      mk_reference ~const:(const_of_borrow_kind bk) e metadata
  | RawPtr (p, rk, metadata) ->
      let metadata = expression_of_operand env metadata in
      let e = expression_of_place env p in
      mk_reference ~const:(const_of_ref_kind rk) e metadata
  | NullaryOp (SizeOf, ty) ->
      let t = typ_of_ty env ty in
      K.(with_type TBool (EApp (Builtin.(expr_of_builtin_t sizeof [ t ]), [])))
  | NullaryOp (AlignOf, ty) ->
      let t = typ_of_ty env ty in
      K.(with_type TBool (EApp (Builtin.(expr_of_builtin_t alignof [ t ]), [])))
  | UnaryOp (Cast (CastScalar (_, dst)), e) ->
      let dst = typ_of_literal_ty env dst in
      K.with_type dst (K.ECast (expression_of_operand env e, dst))
  | UnaryOp (Cast (CastRawPtr (_from, to_)), e) ->
      let dst = typ_of_ty env to_ in
      K.with_type dst (K.ECast (expression_of_operand env e, dst))
  | UnaryOp (Cast (CastTransmute ((TRawPtr _ as _from), (TLiteral (TUInt Usize) as to_))), e) ->
      let dst = typ_of_ty env to_ in
      K.with_type dst (K.ECast (expression_of_operand env e, dst))
  | UnaryOp (Cast (CastFnPtr (TFnDef _from, TFnPtr _to)), e) ->
      (* From FnDef to FnPtr *)
      if Charon.Substitute.lookup_fndef_sig env.crate _from = Some _to then
        expression_of_operand env e
      else
        let dst = typ_of_ty env (TFnPtr _to) in
        K.with_type dst (K.ECast (expression_of_operand env e, dst))
  | UnaryOp (Cast (CastFnPtr (TFnPtr _, TFnPtr _)), e) ->
      (* possible safe fn to unsafe fn, same in C *)
      expression_of_operand env e
  | UnaryOp (Cast (CastUnsize (ty_from, ty_to, meta) as ck), e) ->
      (* DSTs: we support going from &T<S1> to &T<S2> where S1 is sized,  S2 is
         unsized and &T<S2> becomes a fat pointer. The base case is from &T<[U;N]>
         to T<[U]>. See test/more_dst.rs for user-defined DST case. We build this
         coercion by hand, and slightly violate C's strict aliasing rules. *)
      let t_from = typ_of_ty env ty_from and t_to = typ_of_ty env ty_to in
      let e = expression_of_operand env e in
      begin
        match meta, t_from, destruct_arr_dst_ref t_to with
        | MetaLength cg, TBuf (TApp (lid1, _), const), Some (lid2, t_u) when lid1 = lid2 ->
            (* Cast from a struct whose last field is `t data[n]` to a struct whose last field is
             `Eurydice_derefed_slice data` (a.k.a. `char data[]`) *)
            let len = expression_of_const_generic env cg in
            let ptr = K.with_type (TBuf (t_u, const)) (K.ECast (e, TBuf (t_u, const))) in
            Builtin.dst_new ~const ~len ~ptr t_u
        | MetaLength cg, TBuf (K.TCgApp (K.TApp (lid_arr, [ t ]), _), _), _
          when lid_arr = Builtin.arr ->
            (* Cast from Box<[T;N]> (represented as a mut reference to an array) to Box<[T]> (which we
               represent as a slice). See the translation of types. *)
            let len = expression_of_const_generic env cg in
            let const =
              match t_to with
              | K.TApp (dst_ref_hd, _) when dst_ref_hd = Builtin.dst_ref_shared -> true
              | K.TApp (dst_ref_hd, _) when dst_ref_hd = Builtin.dst_ref_mut -> false
              | _ -> assert false
            in
            let array_to_slice =
              RustNames.builtin_of_function
                (if const then
                   Builtin.array_to_slice_func_shared
                 else
                   Builtin.array_to_slice_func_mut)
            in
            let t_without_cg = array_to_slice.typ in
            (* array_to_slice: size_t -> arr -> Eurydice_slice 0 *)
            let array_to_slice = Builtin.(expr_of_builtin array_to_slice) in
            let diff = List.length env.binders - List.length env.cg_binders in
            let array_to_slice =
              K.with_type
                Krml.DeBruijn.(subst_t t 0 (subst_ct diff len 0 t_without_cg))
                (K.ETApp (array_to_slice, [ len ], [], [ t ]))
            in
            K.(with_type (Builtin.mk_slice ~const t) (EApp (array_to_slice, [ e ])))
        | _, _, _ ->
            Krml.KPrint.bprintf "t_to = %a\n" ptyp t_to;
            Krml.KPrint.bprintf "destruct_arr_dst_ref t_to = None? %b\n"
              (destruct_arr_dst_ref t_to = None);
            Krml.Warn.fatal_error "unknown unsize cast: `%s`\nt_to=%a\nt_from=%a"
              (Charon.Print.cast_kind_to_string env.format_env ck)
              ptyp t_to ptyp t_from
      end
  | UnaryOp (Cast (CastConcretize (_from_ty, to_ty)), e) -> (
      (* Concretization cast is a no-op at runtime *)
      let op_e = expression_of_operand env e in
      let typ = typ_of_ty env to_ty in
      match get_dst_ref_base op_e with
      | Some base_ptr -> K.(with_type typ (ECast (base_ptr, typ)))
      | None ->
          failwith
            ("unknown concretize cast: `"
            ^ Charon.Print.cast_kind_to_string env.format_env (CastConcretize (_from_ty, to_ty))
            ^ "`"))
  | UnaryOp (Cast ck, e) ->
      (* Add a simpler case: identity cast is allowed *)
      let is_ident =
        match ck with
        (* Here are `literal_type`s *)
        | C.CastScalar (f, t) -> f = t
        (* The following are `type`s *)
        | C.CastFnPtr (f, t) | C.CastRawPtr (f, t) | C.CastUnsize (f, t, _) | C.CastTransmute (f, t)
          -> f = t
        | C.CastConcretize _ -> false
      in
      if is_ident then
        expression_of_operand env e
      else
        failwith ("unknown cast: `" ^ Charon.Print.cast_kind_to_string env.format_env ck ^ "`")
  (* | UnaryOp (PtrMetadata, e) ->
    let e = expression_of_operand env e in begin
    match e.typ with
    | TApp (lid, [ _; meta_ty ]) when lid = Builtin.dst_ref ->
      K.(with_type meta_ty (EField (e, "meta")))
    (* In cases like `PtrMetadata(T)` when `T` is a type variable or some types with unresolved type variable,
       We cannot tell the correct metadata type from it until fully monomorphized.
       But we can surely rely on monomorphized LLBC, and we ignore handling such cases in Eurydice. *)
    | ty when has_unresolved_generic ty ->
      failwith "Eurydice do not handle ptr-metadata for generic types. Consider using monomorphized LLBC."
    (* Otherwise, fetching ptr-metadata from a non-DST simply results in `()`
       When a type is fully resolved and it is not `Eurydice::DstRef`, we can be confident that it is not a DST. *)
    | _ -> K.with_type TUnit K.EUnit
    end *)
  | UnaryOp (op, o1) -> mk_op_app (op_of_unop op) (expression_of_operand env o1) []
  | BinaryOp (op, o1, o2) ->
      mk_op_app (op_of_binop op) (expression_of_operand env o1) [ expression_of_operand env o2 ]
  | Discriminant sub_p ->
      let e = expression_of_place env sub_p in
      let expected_t = typ_of_ty env expected_ty in
      K.(
        with_type expected_t
          (EApp (Builtin.(expr_of_builtin_t discriminant) [ e.typ; expected_t ], [ e ])))
  | Aggregate (AggregatedAdt ({ id = TTuple; _ }, _, None), ops) -> begin
      match ops with
      | [] -> K.with_type TUnit K.EUnit
      | [ op ] -> expression_of_operand env op
      | _ ->
          let ops = List.map (expression_of_operand env) ops in
          let ts = List.map (fun x -> x.K.typ) ops in
          K.with_type (TTuple ts) (K.ETuple ops)
    end
  | Aggregate
      ( AggregatedAdt
          ( { id = TAdtId typ_id; generics = { types = typ_args; const_generics; _ } },
            variant_id,
            None ),
        args ) ->
      let { C.item_meta; kind; _ } = env.get_nth_type typ_id in
      let name = item_meta.name in
      let typ_lid = lid_of_name env name in
      let typ_args = List.map (typ_of_ty env) typ_args in
      let cg_args = List.map (cg_of_const_generic env) const_generics in
      let t = K.fold_tapp (typ_lid, typ_args, cg_args) in
      let args = List.map (expression_of_operand env) args in
      begin
        match variant_id with
        | Some variant_id ->
            let variant_id = (find_nth_variant env typ_id variant_id).variant_name in
            if is_enum env typ_id then
              K.with_type t (K.EEnum (mk_enum_case typ_lid variant_id))
            else
              K.with_type t (K.ECons (variant_id, args))
        | None ->
            let fields =
              match kind with
              | Struct fields -> fields
              | Enum _ -> failwith "TODO: Enum"
              | Union _ -> failwith "TODO: Union"
              | Opaque -> failwith "TODO: Opaque"
              | Alias _ -> failwith "TODO: Alias"
              | TDeclError _ -> failwith "TODO: TDeclError"
            in
            K.with_type t
              (K.EFlat
                 (List.mapi
                    (fun i (f, a) -> Some (ensure_named i f.C.field_name), a)
                    (List.combine fields args)))
      end
  | Aggregate (AggregatedAdt ({ id = TBuiltin _; _ }, _, _), _) ->
      failwith "unsupported: AggregatedAdt / TAssume"
  | Aggregate (AggregatedArray (t, cg), ops) ->
      let ty = typ_of_ty env t in
      let typ_arr = typ_of_struct_arr env t cg in
      begin
        match ops with
        | [] ->
            let empty_array =
              K.with_type
                Krml.DeBruijn.(subst_t ty 0 Builtin.empty_array.typ)
                (K.ETApp (Builtin.(expr_of_builtin empty_array), [], [], [ ty ]))
            in
            K.with_type typ_arr (K.EApp (empty_array, [ K.with_type ty K.EAny ]))
            (* a dummy arg is needed to pass the checker *)
        | _ ->
            let array_expr =
              K.with_type
                (TArray (typ_of_ty env t, constant_of_scalar_value (assert_cg_scalar cg)))
                (K.EBufCreateL (Stack, List.map (expression_of_operand env) ops))
            in
            K.with_type typ_arr (mk_expr_arr_struct array_expr)
      end
  | rvalue ->
      failwith ("unsupported rvalue: `" ^ Charon.Print.rvalue_to_string env.format_env rvalue ^ "`")

let expression_of_assertion (env : env) ({ cond; expected; _ } : C.assertion) : K.expr =
  let cond =
    if not expected then
      expression_of_operand env cond
    else
      Krml.Helpers.mk_not (expression_of_operand env cond)
  in
  K.(
    with_type TAny
      (EIfThenElse (cond, with_type TAny (EAbort (None, Some "assert failure")), Krml.Helpers.eunit)))

let lesser t1 t2 =
  if t1 = K.TAny then
    t2
  else if t2 = K.TAny then
    t2
  else if t1 <> t2 then
    fail "lesser t1=%a t2=%a" ptyp t1 ptyp t2
  else
    t1

(* A `fn` pointer, which does not have trait bounds, and cannot be partially applied. This is a
   much simplified version of expression_of_fn_ptr. *)
let expression_of_fn_op_dynamic (env : env) ({ func; args; dest } : C.call) =
  let fHd =
    match func with
    | C.FnOpDynamic op -> expression_of_operand env op
    | _otw ->
        failwith @@ "Internal error: the given call is not to `FnOpMove`."
        ^ "The function `expression_of_fn_op_dynamic` handles only call to `FnOpMove`."
  in
  let lhs = expression_of_place env dest in
  let args = List.map (expression_of_operand env) args in
  let args =
    if args = [] then
      [ Krml.Helpers.eunit ]
    else
      args
  in
  (* Asserting that this is not a partial application *)
  let ret_t, args_t = Krml.Helpers.flatten_arrow fHd.typ in
  assert (List.length args_t = List.length args);
  let rhs = K.with_type ret_t @@ K.EApp (fHd, args) in
  Krml.Helpers.with_unit @@ K.EAssign (lhs, rhs)

(** Handles only the `SwitchInt` for 128-bit integers. Turn the switch expression into if-then-else
    expressions. This is to work around the Krml integer type limitations. *)
let rec expression_of_switch_128bits env ret_var scrutinee branches default : K.expr =
  let scrutinee = expression_of_operand env scrutinee in
  let else_branch = expression_of_block env ret_var default in
  let folder (svs, stmt) else_branch =
    (* [i1, i2, ..., in] ==> scrutinee == i1 || scrutinee == i2 || ... || scrutinee == in *)
    let guard =
      let make_eq sv = mk_op_app Eq scrutinee [ expression_of_scalar_value sv ] in
      List.map make_eq svs |> function
      | [] -> Krml.Helpers.etrue
      | x :: lst -> List.fold_left Krml.Helpers.mk_or x lst
    in
    (* the "then" body of the if-then-else expression *)
    let body = expression_of_block env ret_var stmt in
    (* combines the types: compare each branch and then generate the correct type *)
    let typ = lesser body.K.typ else_branch.K.typ in
    K.(with_type typ (EIfThenElse (guard, body, else_branch)))
  in
  List.fold_right folder branches else_branch

and expression_of_statement_kind (env : env) (ret_var : C.local_id) (s : C.statement_kind) : K.expr
    =
  match s with
  | Assign (p, rv) ->
      let expected_ty = p.ty in
      let p = expression_of_place env p in
      let rv = expression_of_rvalue env rv expected_ty in
      K.(with_type TUnit (EAssign (p, rv)))
  | SetDiscriminant (_, _) -> failwith "C.SetDiscriminant"
  | StorageLive _ -> Krml.Helpers.eunit
  | StorageDead _ -> Krml.Helpers.eunit
  | PlaceMention p ->
      let p = expression_of_place env p in
      K.(with_type TUnit (EIgnore p))
  | Drop (p, _, _) ->
      let _ = expression_of_place env p in
      begin
        match p.ty with
        (* doesn't do the right thing yet, need to understand why there are
           several drops per variable *)
        (* | C.Adt (Builtin Vec, _) when false -> *)
        (*     (1* p is a vec t *1) *)
        (*     let t = match p.typ with TApp ((["Eurydice"], "vec"), [ t ]) -> t | _ -> assert false in *)
        (*     Krml.Helpers.(with_unit K.(EApp ( *)
        (*       with_type (Krml.DeBruijn.subst_tn [ t ] Builtin.vec_drop.typ) (ETApp ( *)
        (*         with_type Builtin.vec_drop.typ (EQualified Builtin.vec_drop.name), *)
        (*         [ t ])), *)
        (*       [ p ]))) *)
        | _ -> Krml.Helpers.eunit
      end
  | Assert (a, _on_failure) -> expression_of_assertion env a
  | Call
      {
        func =
          FnOpRegular
            {
              kind = FunId (FBuiltin ArrayRepeat);
              generics = { types = [ ty ]; const_generics = [ c ]; _ };
              _;
            };
        args = [ e ];
        dest;
        _;
      } ->
      (* Special treatment *)
      let e = expression_of_operand env e in
      let t = typ_of_ty env ty in
      let t_array = maybe_cg_array env ty c in
      let len = expression_of_const_generic env c in
      let dest = expression_of_place env dest in
      let repeat =
        K.(
          with_type
            (Krml.Helpers.fold_arrow Builtin.array_repeat.cg_args Builtin.array_repeat.typ)
            (EQualified Builtin.array_repeat.name))
      in
      let diff = List.length env.binders - List.length env.cg_binders in
      let repeat =
        K.(
          with_type
            Krml.DeBruijn.(subst_t t 0 (subst_ct diff len 0 Builtin.array_repeat.typ))
            (ETApp (repeat, [ len ], [], [ t ])))
      in
      Krml.Helpers.with_unit
        K.(
          EAssign
            ( dest,
              with_type dest.typ (mk_expr_arr_struct (with_type t_array (EApp (repeat, [ e ])))) ))
  | Call
      {
        func =
          FnOpRegular
            {
              kind = FunId (FBuiltin (Index { is_array = true; mutability = _; is_range = false }));
              generics = { types = [ ty ]; const_generics = [ cg ]; _ };
              _;
            };
        args = [ e1; e2 ];
        dest;
        _;
      } ->
      (* Special treatment for e1[e2] of array which are translated into struct.
         e1[e2] is translated as fn ArrayIndexShared<T,N>(&[T;N], usize) -> &T

         Since [T;N] is translated into arr$T$N, we need to first dereference
         the e1 to get the struct, and then take its field "data" to get the
         array

         We construct dest := &( *e1).data[e2]
         *)
      let e1 = expression_of_operand env e1 in
      let e2 = expression_of_operand env e2 in
      let t = typ_of_ty env ty in
      let t_array = maybe_cg_array env ty cg in
      (* let const = const_of_tbuf e1.K.typ in *)
      let e1 = Krml.Helpers.(mk_deref ~const:true (Krml.Helpers.assert_tbuf e1.K.typ) e1.K.node) in
      let e1 = K.with_type t_array (K.EField (e1, "data")) in
      let dest = expression_of_place env dest in
      Krml.Helpers.with_unit
        K.(EAssign (dest, addrof ~const:false (with_type t (EBufRead (e1, e2)))))
  | Call { func = FnOpRegular fn_ptr; args; dest; _ }
    when Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_u16 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_u32 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_u64 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_i16 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_i32 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.from_i64 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_u16 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_u32 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_u64 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_i16 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_i32 fn_ptr
         || Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config RustNames.into_i64 fn_ptr
         || false ->
      (* TODO: this can now be properly represented in the AST, this should go
         away! there is *one* case in Kyber that is not caught by
         Cleanup2.remove_trivial_into, and we need to figure out why. *)
      let matches p = Charon.NameMatcher.match_fn_ptr env.name_ctx RustNames.config p fn_ptr in
      let w : Krml.Constant.width =
        if matches RustNames.from_u16 || matches RustNames.into_u16 then
          UInt16
        else if matches RustNames.from_u32 || matches RustNames.into_u32 then
          UInt32
        else if matches RustNames.from_u64 || matches RustNames.into_u64 then
          UInt64
        else if matches RustNames.from_i16 || matches RustNames.into_i16 then
          Int16
        else if matches RustNames.from_i32 || matches RustNames.into_i32 then
          Int32
        else if matches RustNames.from_i64 || matches RustNames.into_i64 then
          Int64
        else
          fail "Unknown from-cast: %s" (string_of_fn_ptr env fn_ptr)
      in
      let dest = expression_of_place env dest in
      let e = expression_of_operand env (Krml.KList.one args) in
      Krml.Helpers.with_unit K.(EAssign (dest, with_type (TInt w) (ECast (e, TInt w))))
  | Call { func = FnOpRegular fn_ptr; args; dest; _ } ->
      (* For now, we take trait type arguments to be part of the code-gen *)
      let hd, _is_known_builtin, output_t = expression_of_fn_ptr env fn_ptr in
      let dest = expression_of_place env dest in
      let args = List.map (expression_of_operand env) args in
      (* This needs to match what is done in the FunGroup case (i.e. when we extract
         a definition). There are two behaviors depending on whether the function is
         builtin or not. *)
      (* Krml.KPrint.bprintf "Call to %s is builtin %b\n" (string_of_fn_ptr env fn_ptr) is_builtin; *)
      let args =
        if args = [] then
          [ Krml.Helpers.eunit ]
        else
          args
      in
      let rhs =
        if args = [] then
          hd
        else
          K.with_type output_t (K.EApp (hd, args))
      in
      (* This does something similar to maybe_addrof *)
      let rhs =
        (* TODO: determine whether extra_types is necessary *)
        let extra_types =
          match fn_ptr.kind with
          | TraitMethod ({ kind = TraitImpl { id = _; generics }; _ }, _, _) -> generics.types
          | _ -> []
        in
        match fn_ptr.kind, fn_ptr.generics.types @ extra_types with
        | ( FunId (FBuiltin (Index { is_array = false; mutability = _; is_range = false })),
            [ TSlice _ ] ) ->
            (* Will decay. See comment above maybe_addrof *)
            rhs
        | ( FunId (FBuiltin (Index { is_array = false; mutability = _; is_range = false })),
            [ TAdt { id; generics } ] )
          when RustNames.is_vec env id generics ->
            (* Will decay. See comment above maybe_addrof *)
            rhs
        | FunId (FBuiltin (Index { is_array = false; mutability = _; is_range = false })), _ ->
            K.(with_type (TBuf (rhs.typ, false)) (EAddrOf rhs))
        | _ -> rhs
      in
      Krml.Helpers.with_unit K.(EAssign (dest, rhs))
  | Call ({ func = FnOpDynamic _; _ } as call) -> expression_of_fn_op_dynamic env call
  | Abort _ -> with_any (K.EAbort (None, Some "panic!"))
  | Return ->
      let e = expression_of_var_id env ret_var in
      K.(with_type TAny (EReturn e))
  | Break n ->
      assert (n = 0);
      K.(with_type TAny EBreak)
  | Continue n ->
      assert (n = 0);
      K.(with_type TAny EContinue)
  | Nop -> Krml.Helpers.eunit
  | Switch (If (op, s1, s2)) ->
      let e1 = expression_of_block env ret_var s1 in
      let e2 = expression_of_block env ret_var s2 in
      let t = lesser e1.typ e2.typ in
      K.(with_type t (EIfThenElse (expression_of_operand env op, e1, e2)))
  | Switch (SwitchInt (scrutinee, int_ty, branches, default)) ->
      let branches =
        List.map
          (fun (litl, block) -> List.map Charon.ValuesUtils.literal_as_scalar litl, block)
          branches
      in
      if int_ty = TInt I128 || int_ty = TUInt U128 then
        expression_of_switch_128bits env ret_var scrutinee branches default
      else
        let scrutinee = expression_of_operand env scrutinee in
        let branches =
          List.concat_map
            (fun (svs, stmt) ->
              List.map
                (fun sv ->
                  K.SConstant (constant_of_scalar_value sv), expression_of_block env ret_var stmt)
                svs)
            branches
          @ [ K.SWild, expression_of_block env ret_var default ]
        in
        let t = Krml.KList.reduce lesser (List.map (fun (_, e) -> e.K.typ) branches) in
        K.(with_type t (ESwitch (scrutinee, branches)))
  | Switch (Match (p, branches, default)) ->
      let scrutinee = expression_of_place env p in
      let typ_id, typ_lid, variant_name_of_variant_id =
        match p.ty with
        | TAdt { id = TAdtId typ_id; _ } ->
            let ty = env.get_nth_type typ_id in
            let variants =
              match ty.kind with
              | Enum variants -> variants
              | _ -> assert false
            in
            ( typ_id,
              lid_of_name env ty.item_meta.name,
              fun v ->
                let v = C.VariantId.nth variants v in
                v.variant_name, List.length v.fields )
        | _ -> failwith "TODO: match on not adt, not option"
      in

      let branches =
        List.concat_map
          (fun (variant_ids, branch) ->
            List.map
              (fun variant_id ->
                let variant_name, n_fields = variant_name_of_variant_id variant_id in
                let dummies = List.init n_fields (fun _ -> K.(with_type TAny PWild)) in
                let pat =
                  if is_enum env typ_id then
                    K.PEnum (mk_enum_case typ_lid variant_name)
                  else
                    K.PCons (variant_name, dummies)
                in
                let pat = K.with_type scrutinee.typ pat in
                [], pat, expression_of_block env ret_var branch)
              variant_ids)
          branches
      in
      let branches =
        branches
        @
        match default with
        | Some default ->
            [ [], K.with_type scrutinee.typ K.PWild, expression_of_block env ret_var default ]
        | None -> []
      in
      let t = Krml.KList.reduce lesser (List.map (fun (_, _, e) -> e.K.typ) branches) in
      K.(with_type t (EMatch (Unchecked, scrutinee, branches)))
  | Loop s -> K.(with_type TUnit (EWhile (Krml.Helpers.etrue, expression_of_block env ret_var s)))
  | _ ->
      failwith
        ("Unsupported statement: "
        ^ Charon.Print.Llbc.statement_kind_to_string env.format_env "" "" s)

and expression_of_statement (env : env) (ret_var : C.local_id) (s : C.statement) : K.expr =
  {
    (expression_of_statement_kind env ret_var s.kind) with
    meta =
      (if !Options.comments then
         List.map (fun x -> K.CommentBefore x) s.comments_before
       else
         []);
  }

and expression_of_block (env : env) (ret_var : C.local_id) (b : C.block) : K.expr =
  let statements = List.map (expression_of_statement env ret_var) b.statements in
  match List.rev statements with
  | [] -> Krml.Helpers.eunit
  | last :: _ -> K.(with_type last.typ (ESequence statements))

(** Top-level declarations: orchestration *)

let of_declaration_group (dg : 'id C.g_declaration_group) (f : 'id -> 'a) : 'a list =
  (* We do not care about recursion as in C, everything is mutually recursive
     thanks to header inclusion. *)
  match dg with
  | NonRecGroup id -> [ f id ]
  | RecGroup ids -> List.map f ids

let seen = ref 0
let total = ref 0

(** List all the ids in this declaration group. *)
let declaration_group_to_list (g : C.declaration_group) : C.item_id list =
  match g with
  | FunGroup g -> List.map (fun id -> C.IdFun id) (C.g_declaration_group_to_list g)
  | TypeGroup g -> List.map (fun id -> C.IdType id) (C.g_declaration_group_to_list g)
  | GlobalGroup g -> List.map (fun id -> C.IdGlobal id) (C.g_declaration_group_to_list g)
  | TraitDeclGroup g -> List.map (fun id -> C.IdTraitDecl id) (C.g_declaration_group_to_list g)
  | TraitImplGroup g -> List.map (fun id -> C.IdTraitImpl id) (C.g_declaration_group_to_list g)
  | MixedGroup g -> C.g_declaration_group_to_list g

let flags_of_meta (meta : C.item_meta) : K.flags =
  [
    Krml.Common.Comment
      (String.concat "\n"
         (List.filter_map
            (function
              | Charon.Meta.AttrDocComment s -> Some s
              | _ -> None)
            meta.attr_info.attributes));
  ]

let decl_of_id (env : env) (id : C.item_id) : K.decl option =
  match id with
  | IdType id -> begin
      let decl = env.get_nth_type id in
      let { C.item_meta; def_id; kind; generics = { types = type_params; const_generics; _ }; _ } =
        decl
      in
      let name = item_meta.name in
      L.log "AstOfLlbc" "Visiting type: %s\n%s" (string_of_name env name)
        (Charon.Print.type_decl_to_string env.format_env decl);

      assert (def_id = id);
      let name = lid_of_name env name in
      let env = push_cg_binders env const_generics in
      let env = push_type_binders env type_params in

      match kind with
      | Union _ | Opaque | TDeclError _ -> None
      | Struct fields ->
          let fields =
            List.mapi
              (fun i { C.field_name; field_ty; _ } ->
                Some (ensure_named i field_name), (typ_of_ty env field_ty, true))
              fields
          in
          Some
            (K.DType (name, [], List.length const_generics, List.length type_params, Flat fields))
      | Enum branches when List.for_all (fun v -> v.C.fields = []) branches ->
          let has_custom_constants =
            let rec has_custom_constants i = function
              | { C.discriminant; _ } :: bs ->
                  Charon.Scalars.get_val (Charon.ValuesUtils.literal_as_scalar discriminant)
                  <> Z.of_int i
                  || has_custom_constants (i + 1) bs
              | _ -> false
            in
            has_custom_constants 0 branches
          in

          let cases =
            List.map
              (fun ({ C.variant_name; discriminant; _ } : C.variant) ->
                let v =
                  if has_custom_constants then
                    Some
                      (Charon.Scalars.get_val (Charon.ValuesUtils.literal_as_scalar discriminant))
                  else
                    None
                in
                mk_enum_case name variant_name, v)
              branches
          in
          Some (K.DType (name, [], List.length const_generics, List.length type_params, Enum cases))
      | Enum branches ->
          let branches =
            List.map
              (fun ({ C.variant_name; fields; _ } : C.variant) ->
                ( variant_name,
                  List.mapi
                    (fun i { C.field_name; field_ty; _ } ->
                      mk_field_name field_name i, (typ_of_ty env field_ty, true))
                    fields ))
              branches
          in
          Some
            (K.DType
               (name, [], List.length const_generics, List.length type_params, Variant branches))
      | Alias ty ->
          Some
            (K.DType
               ( name,
                 [],
                 List.length const_generics,
                 List.length type_params,
                 Abbrev (typ_of_ty env ty) ))
    end
  | IdFun id -> (
      let decl = try Some (env.get_nth_function id) with Not_found -> None in
      match decl with
      | None -> None
      | Some decl -> (
          let { C.def_id; generics; signature; body; item_meta; src; _ } = decl in
          let env = { env with generic_params = generics } in
          L.log "AstOfLlbc" "Visiting %sfunction: %s\n%s"
            (match body with
            | StructuredBody _ -> ""
            | _ -> "opaque ")
            (string_of_name env item_meta.name)
            (Charon.Print.fun_decl_to_string env.format_env "  " "  " decl);

          assert (def_id = id);
          let name = lid_of_name env item_meta.name in
          match body, src with
          | _, TraitDeclItem (_, _, false) ->
              (* We skip those on the basis that they generate useless external prototypes, which we
                 do not really need. *)
              None
          | ( ( OpaqueBody
              | ExternBody _
              | IntrinsicBody _
              | TraitMethodWithoutDefaultBody
              | TargetDispatchBody _
              | MissingBody
              | ErrorBody _
              | UnstructuredBody _ ),
              _ ) ->
              (* Opaque function *)
              let { K.n_cgs; n }, t = typ_of_signature env (C.bound_fun_sig_of_decl decl) in
              Some (K.DExternal (None, [], n_cgs, n, name, t, []))
          | StructuredBody { locals; body; _ }, _ ->
              if Option.is_some decl.is_global_initializer then
                None
              else
                let env = push_cg_binders env generics.const_generics in
                let env = push_type_binders env generics.types in

                L.log "AstOfLlbc" "ty of locals: %s"
                  (String.concat " ++ "
                     (List.map
                        (fun (local : C.local) ->
                          Charon.Print.ty_to_string env.format_env local.local_ty)
                        locals.locals));
                L.log "AstOfLlbc" "ty of inputs: %s"
                  (String.concat " ++ "
                     (List.map
                        (fun t -> Charon.Print.ty_to_string env.format_env t)
                        signature.C.inputs));

                (* `locals` contains, in order: special return variable; function arguments;
                   local variables *)
                let args, locals = Krml.KList.split (locals.arg_count + 1) locals.locals in
                let return_var = List.hd args in
                let args = List.tl args in

                let return_type = typ_of_ty env return_var.local_ty in

                (* Note: Rust allows zero-argument functions but the krml internal
                   representation wants a unit there. This is aligned with typ_of_signature. *)
                let args =
                  let t_unit =
                    C.(
                      TAdt
                        {
                          id = TTuple;
                          generics =
                            { types = []; const_generics = []; regions = []; trait_refs = [] };
                        })
                  in
                  let v_unit =
                    {
                      C.index = Charon.Expressions.LocalId.of_int max_int;
                      name = None;
                      local_ty = t_unit;
                      span = decl.item_meta.span;
                    }
                  in
                  if args = [] then
                    [ v_unit ]
                  else
                    args
                in

                (* At this stage, env has:
                   cg_binders = <<all cg binders>>
                   type_binders = <<all type binders>>
                   binders = <<all cg binders>>
                *)
                let clause_binders = mk_clause_binders_and_args env generics.trait_clauses in
                debug_trait_clause_mapping env clause_binders;
                (* Now we turn it into:
                   binders = <<all cg binders>> ++ <<all clause binders>> ++ <<regular function args>>
                *)
                let env = push_clause_binders env clause_binders in
                let env = push_binders env args in

                let arg_binders =
                  List.map
                    (fun (arg : C.const_generic_param) ->
                      Krml.Helpers.fresh_binder ~mut:true arg.name (typ_of_ty env arg.ty))
                    generics.const_generics
                  @ List.map
                      (function
                        | TraitClauseMethod { pretty_name; _ }, t
                        | TraitClauseConstant { pretty_name; _ }, t ->
                            Krml.Helpers.fresh_binder pretty_name t
                        | _ -> assert false)
                      clause_binders
                  @ List.map
                      (fun (arg : C.local) ->
                        let name = Option.value ~default:"_" arg.name in
                        Krml.Helpers.fresh_binder ~mut:true name (typ_of_ty env arg.local_ty))
                      args
                in

                L.log "AstOfLlbc" "type of binders: %a" ptyps
                  (List.map (fun o -> o.K.typ) arg_binders);
                let body =
                  with_locals env return_type (return_var :: locals) (fun env ->
                      expression_of_block env return_var.index body)
                in
                let flags =
                  match item_meta.attr_info.inline with
                  | Some Hint -> [ Krml.Common.Inline ]
                  | Some Always -> [ Krml.Common.MustInline ]
                  | Some Never -> [ Krml.Common.NoInline ]
                  | _ -> []
                in
                (* This is kind of a hack here: we indicate that this function is intended to be
                   specialized, at monomorphization-time (which happens quite early on), on the cg
                   binders but also on the clause binders... This is ok because even though the
                   clause binders are not in env.cg_binders, well, types don't refer to clause
                   binders, so we won't have translation errors. *)
                let n_cg = List.length generics.const_generics in
                let n = List.length generics.types in
                Some
                  (K.DFunction
                     ( None,
                       flags @ flags_of_meta item_meta,
                       n_cg,
                       n,
                       return_type,
                       name,
                       arg_binders,
                       body ))))
  | IdGlobal id ->
      let global = env.get_nth_global id in
      let { C.item_meta; ty; def_id; _ } = global in
      let name = item_meta.name in
      let def = env.get_nth_global def_id in
      L.log "AstOfLlbc" "Visiting global: %s\n%s" (string_of_name env name)
        (Charon.Print.global_decl_to_string env.format_env "  " "  " def);
      let ty = typ_of_ty env ty in
      let flags =
        [ Krml.Common.Const "" ]
        @
        match global.global_kind with
        | NamedConst | AnonConst ->
            (* This is trickier: const can be evaluated at compile-time, so in theory, we could just
               emit a macro, except (!) in C, arrays need to be top-level declarations (not macros)
               because even with compound literals, you can't do `((int[1]){0})[0]` in expression
               position.

               We can't use the test "is_bufcreate" because the expression might only be a bufcreate
               *after* simplification, so we rely on the type here. *)
            if Krml.Helpers.is_array ty then
              []
            else
              [ Macro ]
        | Static ->
            (* This one needs to have an address, so definitely not emitting it as a macro. *)
            []
      in
      let body = env.get_nth_function def.init in
      L.log "AstOfLlbc" "Corresponding body:%s"
        (Charon.Print.fun_decl_to_string env.format_env "  " "  " body);
      begin
        match body.body with
        | StructuredBody body ->
            let ret_var = List.hd body.locals.locals in
            let body =
              with_locals env ty body.locals.locals (fun env ->
                  expression_of_block env ret_var.index body.body)
            in
            Some (K.DGlobal (flags, lid_of_name env name, 0, ty, body))
        | _ -> Some (K.DExternal (None, [], 0, 0, lid_of_name env name, ty, []))
      end
  | IdTraitDecl _ | IdTraitImpl _ -> None

let name_of_id env (id : C.item_id) =
  match id with
  | IdType id -> (env.get_nth_type id).item_meta.name
  | IdFun id -> (env.get_nth_function id).item_meta.name
  | IdGlobal id -> (env.get_nth_global id).item_meta.name
  | _ -> failwith "unsupported"

let known_failures =
  List.map Charon.NameMatcher.parse_pattern
    [
      (* Failure("TODO: TraitTypes Self::Output") *)
      "core::array::{core::ops::index::Index<[@T; @N], @I, @C>}::index";
      (* Failure("TODO: TraitTypes parent(Self)::TraitClause@0::Output") *)
      "core::array::{core::ops::index::IndexMut<[@T; @N], @I, @C>}::index_mut";
      (* Failure("TODO: TraitTypes core::marker::DiscriminantKind<T@0>::Discriminant") *)
      "core::intrinsics::discriminant_value";
      (* Failure("TODO: TraitTypes Self::Output") *)
      "core::slice::index::{core::ops::index::Index<[@T], @I, @C>}::index";
      (* Failure("TODO: TraitTypes Self::Output") *)
      "core::slice::index::{core::ops::index::IndexMut<[@T], @I, @C>}::index_mut";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::Range<usize>, [@T], \
       [@T]>}::get_unchecked";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::Range<usize>, [@T], \
       [@T]>}::get_unchecked_mut";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::RangeFrom<usize>, \
       [@T], [@T]>}::get_unchecked";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::RangeFrom<usize>, \
       [@T], [@T]>}::get_unchecked_mut";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::RangeTo<usize>, [@T], \
       [@T]>}::get_unchecked";
      (* File "lib/AstOfLlbc.ml", line 389, characters 6-12: Assertion failed *)
      "core::slice::index::{core::slice::index::SliceIndex<core::ops::range::RangeTo<usize>, [@T], \
       [@T]>}::get_unchecked_mut";
      (* Failure("TODO: TraitTypes core::marker::DiscriminantKind<T@0>::Discriminant") *)
      "issue_123::{core::cmp::PartialEq<issue_123::E2, issue_123::E2>}::eq";
      (* Failure("Can't handle arbitrary closures") *)
      "mismatch::{mismatch::MlKemKeyPairUnpacked<@Vector, @K>}::default";
    ]

let replacements =
  List.map
    (fun (p, d) -> Charon.NameMatcher.parse_pattern p, d)
    [
      "core::result::{core::result::Result<@T, @E>}::unwrap", Builtin.unwrap;
      "core::slice::{[@T]}::swap", Builtin.slice_swap;
      "alloc::vec::{alloc::vec::Vec<@T>}::try_with_capacity", Builtin.try_with_capacity;
      "core::ptr::null_mut", Builtin.null_mut;
    ]

(* Catch-all error handler (last resort) *)
let decl_of_id env decl =
  match
    List.find_map
      (fun (p, d) ->
        match
          Charon.NameMatcher.match_name env.name_ctx RustNames.config p (name_of_id env decl)
        with
        | true -> Some d
        | false -> None
        | exception _ -> None)
      replacements
  with
  | Some d ->
      let lid = lid_of_name env (name_of_id env decl) in
      L.log "AstOfLlbc" "Found replacement for %a" plid lid;
      Some (d lid)
  | None -> (
      try decl_of_id env decl
      with e ->
        let matches p =
          Charon.NameMatcher.match_name env.name_ctx RustNames.config p (name_of_id env decl)
        in
        if not (List.exists matches known_failures) then begin
          Printf.eprintf "ERROR translating %s: %s\n%s"
            (string_of_pattern (pattern_of_name env (name_of_id env decl)))
            (Printexc.to_string e) (Printexc.get_backtrace ());
          if not !Options.keep_going then
            exit 255
          else
            None
        end
        else
          None)

let flatten_declarations (d : C.declaration_group list) : C.item_id list =
  List.flatten (List.map declaration_group_to_list d)

let decls_of_declarations (env : env) (d : C.item_id list) : K.decl list =
  incr seen;
  L.log "Progress" "%s: %d/%d" env.crate_name !seen !total;
  Krml.KList.filter_some @@ List.map (decl_of_id env) d

(*
let impl_obligation (ob: decl_obligation) : K.decl =
    match ob with ObliArray (lid, t_array) ->
      L.log "AstOfLlbc" "append new decl of struct: %a" plid lid;
      K.DType (lid, [], 1, 1, Flat [(Some "data",(t_array,true))])

let impl_obligations (obpairs : (decl_obligation * unit) list) : K.decl list =
  List.map impl_obligation (List.map fst obpairs)
  *)

let file_of_crate (crate : Charon.LlbcAst.crate) : Krml.Ast.file =
  let {
    C.name;
    declarations;
    type_decls;
    fun_decls;
    global_decls;
    trait_decls;
    trait_impls;
    options;
    _;
  } =
    crate
  in
  if options.preset <> Some Eurydice then begin
    Printf.eprintf "ERROR: Eurydice expects Charon to be invoked with `--preset=eurydice`\n";
    exit 255
  end;
  let declarations = flatten_declarations declarations in
  seen := 0;
  total := List.length declarations;
  let format_env = Charon.Print.crate_to_fmt_env crate in
  let get_nth_function id =
    match C.FunDeclId.Map.find_opt id fun_decls with
    | Some f -> f
    | None -> fail "Function id not found: %s" (Charon.Print.fun_decl_id_to_string format_env id)
  in
  let get_nth_type id =
    match C.TypeDeclId.Map.find_opt id type_decls with
    | Some ty -> ty
    | None -> fail "Type id not found: %s" (Charon.Print.type_decl_id_to_string format_env id)
  in
  let get_nth_global id =
    match C.GlobalDeclId.Map.find_opt id global_decls with
    | Some g -> g
    | None -> fail "Global id not found: %s" (Charon.Print.global_decl_id_to_string format_env id)
  in
  let get_nth_trait_impl id =
    match C.TraitImplId.Map.find_opt id trait_impls with
    | Some impl -> impl
    | None ->
        fail "Trait impl id not found: %s" (Charon.Print.trait_impl_id_to_string format_env id)
  in
  let get_nth_trait_decl id =
    match C.TraitDeclId.Map.find_opt id trait_decls with
    | Some decl -> decl
    | None ->
        fail "Trait decl id not found: %s" (Charon.Print.trait_decl_id_to_string format_env id)
  in
  let name_ctx = Charon.NameMatcher.ctx_from_crate crate in
  let env =
    {
      get_nth_function;
      get_nth_type;
      get_nth_global;
      get_nth_trait_impl;
      get_nth_trait_decl;
      crate;
      cg_binders = [];
      binders = [];
      type_binders = [];
      format_env;
      crate_name = name;
      name_ctx;
      generic_params = Charon.TypesUtils.empty_generic_params;
    }
  in
  let trans_decls = decls_of_declarations env declarations in
  let extra_decls = Builtin.[ dst_ref_shared_decl; dst_ref_mut_decl; decl_of_arr ] in
  name, trans_decls @ extra_decls


================================================
FILE: lib/Builtin.ml
================================================
module K = struct
  include Krml.Ast
end

(** 1. Things that could otherwise be emitted as an extern prototype, but for some reason ought to
    be skipped. This is used by main.ml *)
let skip = Krml.Idents.LidSet.of_list [ [ "Eurydice" ], "assert"; [], "UNIT_METADATA" ]

(** 2. Internal types; this is the equivalent of an abstract type *)

let char_t = K.(TInt UInt32)
let c_void_t = K.TQualified ([ "Eurydice" ], "c_void_t")
let c_char_t = K.TQualified ([ "Eurydice" ], "c_char_t")
let int128_t = K.TQualified ([ "Eurydice"; "Int128" ], "int128_t")
let uint128_t = K.TQualified ([ "Eurydice"; "Int128" ], "uint128_t")

(** 3. Types that we *define* in abstract syntax, and associated helpers. *)

(** Dynamically-sized types. *)
let dst_ref_shared = [ "Eurydice" ], "dst_ref_shared"

let dst_ref_shared_decl =
  K.DType
    ( dst_ref_shared,
      [],
      0,
      2,
      Flat [ Some "ptr", (TBuf (TBound 1, true), false); Some "meta", (TBound 0, false) ] )

let dst_ref_mut = [ "Eurydice" ], "dst_ref_mut"

let dst_ref_mut_decl =
  K.DType
    ( dst_ref_mut,
      [],
      0,
      2,
      Flat [ Some "ptr", (TBuf (TBound 1, false), false); Some "meta", (TBound 0, false) ] )

let mk_dst_ref ~const (t : K.typ) (meta : K.typ) : K.typ =
  let const =
    if !Options.no_const then
      false
    else
      const
  in
  K.TApp
    ( (if const then
         dst_ref_shared
       else
         dst_ref_mut),
      [ t; meta ] )

let mk_slice ~const (t : K.typ) : K.typ = mk_dst_ref ~const t (TInt SizeT)

(* Take the type of the ptr field *)
let dst_new ~const ~ptr ~len t =
  let open K in
  with_type (mk_slice ~const t) (EFlat [ Some "ptr", ptr; Some "meta", len ])

(* Arrays, as values.

    Special treatment for the array type: translating [T;C] as rust generic type
    struct <const C:usize, T> { data : [T;C]; } *)
let arr : K.lident = [ "Eurydice" ], "arr"
let mk_arr (t : K.typ) (cg : K.cg) : K.typ = K.TCgApp (K.TApp (arr, [ t ]), cg)

(* []  : no flags
     1  : we have one const generic C
     1  : we have one type argument T *)
let decl_of_arr = K.DType (arr, [], 1, 1, Flat [ Some "data", (K.TCgArray (TBound 0, 0), true) ])

(* a->data where a: Arr<t,n>*, to be used before eurydice monomorphization *)
let data_of_arrref ?const (arrref : K.expr) t n_cgid =
  let arr =
    Krml.Helpers.(mk_deref ?const (Krml.Helpers.assert_tbuf_or_tarray arrref.typ) arrref.node)
  in
  K.(with_type (TCgArray (t, n_cgid)) (EField (arr, "data")))

let c_string_def =
  K.DType (([ "Prims" ], "string"), [ Private ], 0, 0, Abbrev (TBuf (c_char_t, false)))

let nonzero = [ "core"; "num"; "nonzero" ], "NonZero"
let nonzero_def = K.DType (nonzero, [], 0, 1, Abbrev (TBound 0))
let mk_nonzero t = K.TApp (nonzero, [ t ])

(* 4. Helpers to build types that are either eliminated, implemented as macros, or are generated by
   the translation. *)

let derefed_slice = [ "Eurydice" ], "derefed_slice"

(** The C counterpart of `&str` *)
let str_t ~const = mk_dst_ref ~const c_char_t (TInt SizeT)

(** The C counterpart of `str` and serves twofold functionalities: (1) when in expressions, it
    serves as a placeholder to get referenced again; (2) when in customised DST definition, it is
    defined as [char []] to have 0-length. *)
let deref_str_t = K.TApp (derefed_slice, [ c_char_t ])

let vec : K.lident = [ "Eurydice" ], "vec"
let mk_vec (t : K.typ) : K.typ = K.TApp (vec, [ t ])
let range : K.lident = [ "core"; "ops"; "range" ], "Range"
let mk_range (t : K.typ) : K.typ = K.TApp (range, [ t ])
let range_to : K.lident = [ "core"; "ops"; "range" ], "RangeTo"
let mk_range_to (t : K.typ) : K.typ = K.TApp (range_to, [ t ])
let range_from : K.lident = [ "core"; "ops"; "range" ], "RangeFrom"
let mk_range_from (t : K.typ) : K.typ = K.TApp (range_from, [ t ])
let option : K.lident = [ "core"; "option" ], "Option"
let mk_option (t : K.typ) : K.typ = K.TApp (option, [ t ])
let result = [ "core"; "result" ], "Result"
let mk_result t1 t2 = K.TApp (result, [ t1; t2 ])
let mk_sizeT = K.with_type (TInt SizeT)
let iterator : K.lident = [ "core"; "iter"; "traits"; "iterator" ], "Iterator"
let mk_iterator t = K.TApp (iterator, [ t ])
let step_by : K.lident = [ "core"; "iter"; "adapters"; "step_by" ], "StepBy"
let mk_step_by t = K.TApp (step_by, [ t ])
let mk_range_step_by_iterator t = mk_iterator (mk_step_by t)
let layout_t = K.TQualified ([ "core"; "alloc"; "layout" ], "Layout")

(** 5. A list of known builtins, i.e. functions that we intend to implement as macros, or eliminate
    later on. Some of these are markers inserted by AstOfLlbc, and destined to be eliminated later
    through targeted phases. *)

type builtin = {
  name : K.lident;
  typ : K.typ;
  n_type_args : int;
  cg_args : K.typ list;
  arg_names : string list;
}
(** A record to hold a builtin *function* with all relevant information for both krml and the
    transpilation phase in AstOfLlbc *)

let expr_of_builtin { name; typ; cg_args; _ } =
  (* let open Krml in *)
  (* let open PrintAst.Ops in *)
  (* KPrint.bprintf "%a:\n  typ = %a\n  cg_args=%a\n\n" plid name ptyp typ ptyps cg_args; *)
  let typ = List.fold_right (fun t acc -> K.TArrow (t, acc)) cg_args typ in
  K.(with_type typ (EQualified name))

let chop_cg_args n t =
  let t, ts = Krml.Helpers.flatten_arrow t in
  let _, ts = Krml.KList.split n ts in
  let t = Krml.Helpers.fold_arrow ts t in
  t

let expr_of_builtin_t builtin ?(cgs = 0, []) ts =
  let open Krml.DeBruijn in
  let builtin = expr_of_builtin builtin in
  let diff, cg_exprs = cgs in
  let cgs = List.map (cg_of_expr diff) cg_exprs in
  let t = chop_cg_args (List.length cgs) (subst_tn ts (subst_ctn' cgs builtin.typ)) in
  K.(with_type t (ETApp (builtin, cg_exprs, [], ts)))

module Op128Map = Map.Make (struct
  type t = string * string

  let compare = Stdlib.compare
end)

(* Builtins for i128 and u128 are defined here but implemented in C. *)
let mk_128_builtin_op kind op lhs_typ rhs_typ ret_typ =
  let name = [ "Eurydice"; "Int128" ], kind ^ "128_" ^ op in
  let args, arg_names =
    match rhs_typ with
    | K.TUnit -> [ lhs_typ ], [ "lhs" ]
    | rhs -> [ lhs_typ; rhs ], [ "lhs"; "rhs" ]
  in
  { name; typ = Krml.Helpers.fold_arrow args ret_typ; n_type_args = 0; cg_args = []; arg_names }

let op_128_cfgs =
  [
    ("i", "from_bits"), (Krml.Helpers.uint64, Krml.Helpers.uint64, int128_t);
    ("i", "add"), (int128_t, int128_t, int128_t);
    ("i", "sub"), (int128_t, int128_t, int128_t);
    ("i", "mul"), (int128_t, int128_t, int128_t);
    ("i", "div"), (int128_t, int128_t, int128_t);
    ("i", "mod"), (int128_t, int128_t, int128_t);
    ("i", "bor"), (int128_t, int128_t, int128_t);
    ("i", "band"), (int128_t, int128_t, int128_t);
    ("i", "bxor"), (int128_t, int128_t, int128_t);
    ("i", "shl"), (int128_t, TInt UInt32, int128_t);
    ("i", "shr"), (int128_t, TInt UInt32, int128_t);
    ("i", "bnot"), (int128_t, K.TUnit, int128_t);
    ("i", "neg"), (int128_t, K.TUnit, int128_t);
    ("u", "neg"), (uint128_t, K.TUnit, uint128_t);
    ("i", "eq"), (int128_t, int128_t, TBool);
    ("i", "lt"), (int128_t, int128_t, TBool);
    ("i", "gt"), (int128_t, int128_t, TBool);
    ("i", "lte"), (int128_t, int128_t, TBool);
    ("i", "gte"), (int128_t, int128_t, TBool);
    ("i", "neq"), (int128_t, int128_t, TBool);
    ("i", "addW"), (int128_t, int128_t, int128_t);
    ("i", "subW"), (int128_t, int128_t, int128_t);
    ("i", "divW"), (int128_t, int128_t, int128_t);
    ("i", "multW"), (int128_t, int128_t, int128_t);
    ("u", "from_bits"), (Krml.Helpers.uint64, Krml.Helpers.uint64, uint128_t);
    ("u", "add"), (uint128_t, uint128_t, uint128_t);
    ("u", "sub"), (uint128_t, uint128_t, uint128_t);
    ("u", "mul"), (uint128_t, uint128_t, uint128_t);
    ("u", "div"), (uint128_t, uint128_t, uint128_t);
    ("u", "mod"), (uint128_t, uint128_t, uint128_t);
    ("u", "bor"), (uint128_t, uint128_t, uint128_t);
    ("u", "band"), (uint128_t, uint128_t, uint128_t);
    ("u", "bxor"), (uint128_t, uint128_t, uint128_t);
    ("u", "shl"), (uint128_t, TInt UInt32, uint128_t);
    ("u", "shr"), (uint128_t, TInt UInt32, uint128_t);
    ("u", "bnot"), (uint128_t, K.TUnit, uint128_t);
    ("u", "eq"), (uint128_t, uint128_t, TBool);
    ("u", "lt"), (uint128_t, uint128_t, TBool);
    ("u", "gt"), (uint128_t, uint128_t, TBool);
    ("u", "lte"), (uint128_t, uint128_t, TBool);
    ("u", "gte"), (uint128_t, uint128_t, TBool);
    ("u", "neq"), (uint128_t, uint128_t, TBool);
    ("u", "addW"), (uint128_t, uint128_t, uint128_t);
    ("u", "subW"), (uint128_t, uint128_t, uint128_t);
    ("u", "divW"), (uint128_t, uint128_t, uint128_t);
    ("u", "multW"), (uint128_t, uint128_t, uint128_t);
  ]
  |> List.fold_left
       (fun acc ((kind, op), (lhs_typ, rhs_typ, ret_typ)) ->
         Op128Map.add (kind, op) (mk_128_builtin_op kind op lhs_typ rhs_typ ret_typ) acc)
       Op128Map.empty

let get_128_op (kind, op) : K.expr = expr_of_builtin @@ Op128Map.find (kind, op) op_128_cfgs

(** Get the size of the given type, corresponding to `sizeof` in C. This corresponds to
    `NullOp::SizeOf` in Charon, which is itself used in metadata field `size` in vtable. *)
let sizeof =
  {
    name = [ "Eurydice" ], "sizeof";
    typ = Krml.Helpers.fold_arrow [] (TInt SizeT);
    n_type_args = 1;
    cg_args = [];
    arg_names = [];
  }

(** Get the alignment of the given type, corresponding to `alignof` in C. This corresponds to
    `NullOp::AlignOf` in Charon, which is itself used in metadata field `align` in vtable. *)
let alignof =
  {
    name = [ "Eurydice" ], "alignof";
    typ = Krml.Helpers.fold_arrow [] (TInt SizeT);
    n_type_args = 1;
    cg_args = [];
    arg_names = [];
  }

let suffix_of_const const =
  if const then
    "_shared"
  else
    "_mut"

(* These two are placeholders that are inserted by AstOfLlbc with the intent that they should be
   desugared later on, once monomorphization and data type compilation, respectively, have happened. *)
let array_repeat =
  {
    name = [ "Eurydice" ], "array_repeat";
    typ = Krml.Helpers.fold_arrow [ TBound 0 ] (TCgArray (TBound 0, 0));
    n_type_args = 1;
    cg_args = [ TInt SizeT ];
    arg_names = [ "init" ];
  }

(* Eurydice_discriminant<T,U>(x: T) -> U
   T = type of the argument (an ADT)
   U = expected type of the discriminant (usize, u8, etc.)
   There is an unverified invariant that the algorithm in CStarToC11 to automatically pick suitable
   sizes for the `tag` field is compatible with the expected type U here. *)
let discriminant =
  {
    name = [ "Eurydice" ], "discriminant";
    typ = Krml.Helpers.fold_arrow [ TBound 1 ] (TBound 0);
    n_type_args = 2;
    cg_args = [];
    arg_names = [ "adt" ];
  }

let array_eq =
  {
    name = [ "Eurydice" ], "array_eq";
    typ =
      Krml.Helpers.fold_arrow
        [ TBuf (mk_arr (TBound 0) (CgVar 0), true); TBuf (mk_arr (TBound 0) (CgVar 0), true) ]
        TBool;
    n_type_args = 1;
    cg_args = [ TInt SizeT ];
    arg_names = [ "arr"; "arr2" ];
  }

let array_eq_slice const =
  {
    name = [ "Eurydice" ], "array_eq_slice" ^ suffix_of_const const;
    typ =
      Krml.Helpers.fold_arrow
        [ TBuf (mk_arr (TBound 0) (CgVar 0), true); TBuf (mk_slice ~const (TBound 0), true) ]
        TBool;
    n_type_args = 1;
    cg_args = [ TInt SizeT ];
    arg_names = [ "arr"; "slice" ];
  }

(* Unlike other builtins in this file, comparing an array for 
   equality with a slice has a single implementation in Rust. 
   It should, by default, take a const pointer to the slice, 
   on the basis that the callee does not modify its argument. 
   However, when `--no-const` is passed as an option, we pick a 
   variant that takes a mutable slice so as to avoid generating 
   const slice types. *)
let array_eq_slice_shared = array_eq_slice true
let array_eq_slice_mut = array_eq_slice false

let slice_eq const =
  {
    name = [ "Eurydice" ], "slice_eq" ^ suffix_of_const const;
    typ =
      Krml.Helpers.fold_arrow
        [ TBuf (mk_slice ~const (TBound 0), true); TBuf (mk_slice ~const (TBound 0), true) ]
        TBool;
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "s1"; "s2" ];
  }

let slice_eq_shared = slice_eq true
let slice_eq_mut = slice_eq false

(* XXX investigate whether this can be extracted now...?

   This is incorrect: the function receives e.g.
   - Range<usize> as its type argument,
   - &StepBy<Range<usize>> for the type of its argument,
   then returns Option<usize> for its return value. Which we can't really type. *)
let range_iterator_step_by =
  {
    name = [ "Eurydice" ], "range_iterator_step_by";
    typ =
      Krml.Helpers.fold_arrow [ mk_range (TBound 0); TInt SizeT ] (mk_step_by (mk_range (TBound 0)));
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "iter" ];
  }

let range_step_by_iterator_next =
  {
    name = [ "Eurydice" ], "range_step_by_iterator_next";
    typ =
      Krml.Helpers.fold_arrow
        [ TBuf (mk_step_by (mk_range (TBound 0)), false) ]
        (mk_option (TBound 0));
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "iter" ];
  }

let slice_index const =
  {
    name = [ "Eurydice" ], "slice_index" ^ suffix_of_const const;
    typ = Krml.Helpers.fold_arrow [ mk_slice ~const (TBound 0); TInt SizeT ] (TBound 0);
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "s"; "i" ];
  }

let slice_index_shared = slice_index true
let slice_index_mut = slice_index false

(* The three entries below do not need a shared/mut variant because of the way the &mut[T] vs &[T]
   is passed as an argument to the type application *)

(* This is replaced in PreCleanup because we need to allocate a Arr<T,C> *)
let slice_to_array =
  {
    name = [ "Eurydice" ], "slice_to_array";
    typ = Krml.Helpers.fold_arrow [ TBound 2 ] (mk_result (TBound 1) (TBound 0));
    n_type_args = 3;
    cg_args = [];
    arg_names = [ "s" ];
  }

(* This is replaced by slice_to_ref_array2 by allocate a  Arr<T,C> and pass the ref as arg*)
let slice_to_ref_array =
  {
    name = [ "Eurydice" ], "slice_to_ref_array";
    typ = Krml.Helpers.fold_arrow [ TBound 2 ] (mk_result (TBound 1) (TBound 0));
    n_type_args = 3;
    cg_args = [ TInt SizeT ];
    arg_names = [ "s" ];
  }

let slice_to_ref_array2 =
  {
    name = [ "Eurydice" ], "slice_to_ref_array2";
    typ = Krml.Helpers.fold_arrow [ TBound 2; TBound 1 ] (mk_result (TBound 1) (TBound 0));
    n_type_args = 3;
    cg_args = [ TInt SizeT ];
    arg_names = [ "s" ];
  }

let box_new =
  {
    name = [ "Eurydice" ], "box_new";
    typ = Krml.Helpers.fold_arrow [ TBound 0 ] (TBuf (TBound 0, false));
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "v" ];
  }

let empty_array =
  {
    name = [ "Eurydice" ], "empty_array";
    typ = Krml.Helpers.fold_arrow [ TBound 0 ] (mk_arr (TBound 0) (CgConst (SizeT, "0")));
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "x" ];
  }

let replace =
  {
    name = [ "Eurydice" ], "replace";
    typ = Krml.Helpers.fold_arrow [ TBuf (TBound 0, false); TBound 0 ] (TBound 0);
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "v"; "x" ];
  }

(* pointer, value *)
let bitand_pv_u8 =
  {
    name = [ "Eurydice" ], "bitand_pv_u8";
    typ = Krml.Helpers.fold_arrow [ TBuf (TInt UInt8, false); TInt UInt8 ] (TInt UInt8);
    n_type_args = 0;
    cg_args = [];
    arg_names = [ "x"; "y" ];
  }

let shr_pv_u8 =
  {
    name = [ "Eurydice" ], "shr_pv_u8";
    typ = Krml.Helpers.fold_arrow [ TBuf (TInt UInt8, false); TInt Int32 ] (TInt UInt8);
    n_type_args = 0;
    cg_args = [];
    arg_names = [ "x"; "y" ];
  }

let min_u32 =
  {
    name = [ "Eurydice" ], "min_u32";
    typ = Krml.Helpers.fold_arrow [ TInt UInt32; TInt UInt32 ] (TInt UInt32);
    n_type_args = 0;
    cg_args = [];
    arg_names = [ "x"; "y" ];
  }

(* A non error-checking function that returns a vector whose ptr component is potentially NULL *)
let vec_alloc =
  {
    name = [ "Eurydice" ], "vec_alloc";
    typ = Krml.Helpers.fold_arrow [ TInt SizeT ] (mk_vec (TBound 0));
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "len" ];
  }

(* Will allocating len elements of type T overflow SIZE_MAX? *)
let vec_overflows =
  {
    name = [ "Eurydice" ], "vec_overflows";
    typ = Krml.Helpers.fold_arrow [ TInt SizeT ] TBool;
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "len" ];
  }

(* Since Eurydice_vec is opaque from the point of view of krml, we expose a helper (implemented with
   a macro) that can determine whether this a failed allocation *)
let vec_failed =
  {
    name = [ "Eurydice" ], "vec_failed";
    typ = Krml.Helpers.fold_arrow [ mk_vec (TBound 0) ] TBool;
    n_type_args = 1;
    cg_args = [];
    arg_names = [ "v" ];
  }

(* Compute a layout from a type *)
let layout =
  {
    name = [ "Eurydice" ], "layout";
    typ = Krml.Helpers.fold_arrow [ TUnit ] layout_t;
    n_type_args = 1;
    cg_args = [];
    arg_names = [];
  }

(* 6. Implementations, defined as DFunction using abstract syntax.

 We still provide a corresponding `builtin` to facilitate interop between AstOfLlbc and later phases
 -- we still need to convey type information for AstOfLlbc to generate well-typed nodes. *)

(* Helpers for common use *)

(* let array_to_slice<T;N> (a : &Arr<T,N>) = dst_ref { ptr = a->data; meta = N }  *)
let array_to_slice_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 0 in
  let arrref_t = TBuf (mk_arr (TBound 0) (CgVar 0), const) in
  let ret_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "array_to_slice" ^ suffix_of_const const in
  let binders = [ Helpers.fresh_binder "N" (TInt SizeT); Helpers.fresh_binder "a" arrref_t ] in
  let expr =
    (* args *)
    let n = mk_sizeT (EBound 1) in
    let arrref = with_type arrref_t (EBound 0) in
    let data = data_of_arrref ~const:true arrref element_t 0 in
    with_type ret_t (EFlat [ Some "ptr", data; Some "meta", n ])
  in
  DFunction (None, [ Private ], 1, 1, ret_t, lid, binders, expr)

let array_to_slice_func_shared = array_to_slice_func true
let array_to_slice_func_mut = array_to_slice_func false

(* let array_to_subslice<T, _, _;N> (r: Range<SizeT>, x : &Arr<T,N>)
   = dst_ref { ptr = a->data + r.start ; meta = r.end - r.start }  *)
let array_to_subslice_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let arrref_t = TBuf (mk_arr (TBound 2) (CgVar 0), const) in
  let ret_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "array_to_subslice" ^ suffix_of_const const in
  let binders =
    [
      Helpers.fresh_binder "N" (TInt SizeT);
      Helpers.fresh_binder "a" arrref_t;
      Helpers.fresh_binder "r" (mk_range (TInt SizeT));
    ]
  in
  let expr =
    (* args *)
    let arrref = with_type arrref_t (EBound 1) in
    let range = with_type (mk_range (TInt SizeT)) (EBound 0) in
    let data = data_of_arrref ~const:true arrref element_t 0 in
    let r_start = mk_sizeT (EField (range, "start")) in
    let r_end = mk_sizeT (EField (range, "end")) in
    let meta = mk_sizeT (EApp (Helpers.mk_op Sub (TInt SizeT), [ r_end; r_start ])) in
    let ptr = with_type (TBuf (element_t, const)) (EBufSub (data, r_start)) in
    with_type ret_t (EFlat [ Some "ptr", ptr; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 1, 3, ret_t, lid, binders, expr)

let array_to_subslice_func_shared = array_to_subslice_func true
let array_to_subslice_func_mut = array_to_subslice_func false

(* let array_to_subslice_to<T;N> (r: RangeTo<SizeT>, x : &Arr<T,N>)
   = dst_ref { ptr = a->data; meta = r.end } *)
let array_to_subslice_to_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let arrref_t = TBuf (mk_arr (TBound 2) (CgVar 0), const) in
  let ret_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "array_to_subslice_to" ^ suffix_of_const const in
  let binders =
    [
      Helpers.fresh_binder "N" (TInt SizeT);
      Helpers.fresh_binder "a" arrref_t;
      Helpers.fresh_binder "r" (mk_range_to (TInt SizeT));
    ]
  in
  let expr =
    (* args *)
    let arrref = with_type arrref_t (EBound 1) in
    let range = with_type (mk_range_to (TInt SizeT)) (EBound 0) in
    (* { .ptr = a->data + r.start, .meta = r.end - r.start }*)
    let data = data_of_arrref ~const:true arrref element_t 0 in
    let meta = with_type (TInt SizeT) (EField (range, "end")) in
    with_type ret_t (EFlat [ Some "ptr", data; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 1, 3, ret_t, lid, binders, expr)

let array_to_subslice_to_func_shared = array_to_subslice_to_func true
let array_to_subslice_to_func_mut = array_to_subslice_to_func false

(* let array_to_subslice_from<T, _, _;N> (r: RangeFrom<SizeT>, x : &Arr<T,N>)
   = dst_ref { ptr = a->data + r.start; meta = N - r.start } *)
let array_to_subslice_from_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let arrref_t = TBuf (mk_arr (TBound 2) (CgVar 0), const) in
  let ret_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "array_to_subslice_from" ^ suffix_of_const const in
  let binders =
    [
      Helpers.fresh_binder "N" (TInt SizeT);
      Helpers.fresh_binder "a" arrref_t;
      Helpers.fresh_binder "r" (mk_range_from (TInt SizeT));
    ]
  in
  let expr =
    (* args *)
    let n = mk_sizeT (EBound 2) in
    let arrref = with_type arrref_t (EBound 1) in
    let range = with_type (mk_range_from (TInt SizeT)) (EBound 0) in
    let data = data_of_arrref ~const:true arrref element_t 0 in
    let start = mk_sizeT (EField (range, "start")) in
    let meta = mk_sizeT (EApp (Helpers.mk_op Sub (TInt SizeT), [ n; start ])) in
    let ptr = with_type (TBuf (element_t, const)) (EBufSub (data, start)) in
    with_type ret_t (EFlat [ Some "ptr", ptr; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 1, 3, ret_t, lid, binders, expr)

let array_to_subslice_from_func_shared = array_to_subslice_from_func true
let array_to_subslice_from_func_mut = array_to_subslice_from_func false

(* let slice_subslice<T, _, _> (r: Range<SizeT>, s : DstRef<T,N>)
   = dst_ref { ptr = s.ptr + r.start; meta = r.end - r.start } *)
let slice_subslice_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let slice_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "slice_subslice" ^ suffix_of_const const in
  let binders =
    [ Helpers.fresh_binder "s" slice_t; Helpers.fresh_binder "r" (mk_range (TInt SizeT)) ]
  in
  let expr =
    (* args *)
    let slice = with_type slice_t (EBound 1) in
    let range = with_type (mk_range (TInt SizeT)) (EBound 0) in
    let ptr = with_type (TBuf (element_t, const)) (EField (slice, "ptr")) in
    let r_start = mk_sizeT (EField (range, "start")) in
    let r_end = mk_sizeT (EField (range, "end")) in
    let meta = mk_sizeT (EApp (Helpers.mk_op Sub (TInt SizeT), [ r_end; r_start ])) in
    let ptr = with_type (TBuf (element_t, const)) (EBufSub (ptr, r_start)) in
    with_type slice_t (EFlat [ Some "ptr", ptr; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 0, 3, slice_t, lid, binders, expr)

let slice_subslice_func_shared = slice_subslice_func true
let slice_subslice_func_mut = slice_subslice_func false

(* let slice_subslice_to<T, _, _> (r: RangeTo<SizeT>, s : DstRef<T,N>)
   = dst_ref { ptr = s.ptr ; meta = r.end } *)
let slice_subslice_to_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let slice_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "slice_subslice_to" ^ suffix_of_const const in
  let binders =
    [ Helpers.fresh_binder "s" slice_t; Helpers.fresh_binder "r" (mk_range_to (TInt SizeT)) ]
  in
  let expr =
    (* args *)
    let slice = with_type slice_t (EBound 1) in
    let range = with_type (mk_range_to (TInt SizeT)) (EBound 0) in
    let ptr = with_type (TBuf (element_t, const)) (EField (slice, "ptr")) in
    let meta = with_type (TInt SizeT) (EField (range, "end")) in
    with_type slice_t (EFlat [ Some "ptr", ptr; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 0, 3, slice_t, lid, binders, expr)

let slice_subslice_to_func_shared = slice_subslice_to_func true
let slice_subslice_to_func_mut = slice_subslice_to_func false

(* let slice_subslice_from<T, _, _> (r: RangeFrom<SizeT>, s : DstRef<T,N>)
   = dst_ref { ptr = s.ptr + r.start ; meta = s.meta - r.start } *)
let slice_subslice_from_func const =
  let open Krml in
  let open Ast in
  let element_t = TBound 2 in
  let slice_t = mk_slice ~const element_t in
  let lid = [ "Eurydice" ], "slice_subslice_from" ^ suffix_of_const const in
  let binders =
    [ Helpers.fresh_binder "s" slice_t; Helpers.fresh_binder "r" (mk_range_from (TInt SizeT)) ]
  in
  let expr =
    (* args *)
    let slice = with_type slice_t (EBound 1) in
    let range = with_type (mk_range_from (TInt SizeT)) (EBound 0) in
    let ptr = with_type (TBuf (element_t, const)) (EField (slice, "ptr")) in
    let meta = mk_sizeT (EField (slice, "meta")) in
    let start = mk_sizeT (EField (range, "start")) in
    let ptr = with_type (TBuf (element_t, const)) (EBufSub (ptr, start)) in
    let meta = mk_sizeT (EApp (Helpers.mk_op Sub (TInt SizeT), [ meta; start ])) in
    with_type slice_t (EFlat [ Some "ptr", ptr; Some "meta", meta ])
  in
  DFunction (None, [ Private ], 0, 3, slice_t, lid, binders, expr)

let slice_subslice_from_func_shared = slice_subslice_from_func true
let slice_subslice_from_func_mut = slice_subslice_from_func false

(* Not fully general *)
let static_assert, static_assert_ref =
  let name = [ "Eurydice" ], "assert" in
  let typ = Krml.Helpers.fold_arrow [ TBool; Krml.Checker.c_string ] TUnit in
  ( K.DExternal (None, [ Krml.Common.Private; Macro ], 0, 0, name, typ, [ "test"; "msg" ]),
    K.(with_type typ (EQualified name)) )

(* Replacements, now applied on-the-fly in AstOfLlbc.

 IMPORTANT: such replacements are written in abstract syntax that *already* has cleanups applied,
 meaning that some passes like Cleanup1.remove_assignments and un-necessary and will actually error
 out. We maintain a list of such functions in Cleanup1, to be kept in sync with this. *)

let unwrap =
  let open Krml in
  let open Ast in
  let t_T = TBound 1 in
  let t_E = TBound 0 in
  let b = Krml.Helpers.fresh_binder "f0" t_T in
  let t_result = mk_result t_T t_E in
  let binders = [ Helpers.fresh_binder "self" t_result ] in
  (* Ensures this returns always the same term (structurally equal) *)
  fun lid ->
    DFunction
      ( None,
        [ Private ],
        0,
        2,
        t_T,
        lid,
        binders,
        with_type t_T
          (EMatch
             ( Unchecked,
               with_type t_result (EBound 0),
               [
                 ( [ b ],
                   with_type t_result (PCons ("Ok", [ with_type t_T (PBound 0) ])),
                   with_type t_T (EBound 0) );
                 ( [],
                   with_type t_result PWild,
                   with_type t_T (EAbort (Some t_T, Some "unwrap not Ok")) );
               ] )) )

(* Easier this way rather than implement a macro with an expression-statement.

   external core_slice_{@Slice<T>}_swap <1>:<cg: 0>
    Eurydice_slice
    0 ->
    size_t ->
      size_t ->
        ()
*)
let slice_swap =
  let open Krml in
  let open Ast in
  let t = TBound 0 in
  (* Slice must be mut for elements to be swapped *)
  let mk_slice = mk_slice ~const:false in
  let binders =
    [
      Helpers.fresh_binder ~mut:true "s" (mk_slice t);
      Helpers.fresh_binder "i" (TInt SizeT);
      Helpers.fresh_binder "j" (TInt SizeT);
    ]
  in
  (* with slice type *)
  let mk_slice = with_type (mk_slice t) in
  (* with usize type *)
  let index s i =
    let slice_index = expr_of_builtin_t slice_index_mut [ t ] in
    with_type t (EApp (slice_index, [ s; i ]))
  in
  let lhs s i =
    with_type t (EBufRead (with_type (TBuf (t, false)) (EAddrOf (index s i)), Helpers.zero_usize))
  in
  fun lid ->
    DFunction
      ( None,
        [ Private ],
        0,
        1,
        TUnit,
        lid,
        binders,
        (* let tmp = s[i]; *)
        with_type TUnit
          (ELet
             ( Helpers.fresh_binder "tmp" t,
               index (mk_slice (EBound 2)) (mk_sizeT (EBound 1)),
               with_type TUnit
                 (ESequence
                    [
                      (* s[i] = s[j] *)
                      with_type TUnit
                        (EAssign
                           ( lhs (mk_slice (EBound 3)) (mk_sizeT (EBound 2)),
                             index (mk_slice (EBound 3)) (mk_sizeT (EBound 1)) ));
                      (* s[j] = tmp *)
                      with_type TUnit
                        (EAssign
                           (lhs (mk_slice (EBound 3)) (mk_sizeT (EBound 1)), with_type t (EBound 0)));
                    ]) )) )

(* Formerly a macro, using GCC expression-statements:

#define alloc_vec__alloc__vec__Vec_T___try_with_capacity(len, t_elt, t_ret) \
  ({ \
    size_t element_sz = sizeof(t_elt); \
    Eurydice_vec v = Eurydice_vec_try_with_capacity(len, sizeof(t_elt)); \
    t_ret r; \
    if (!(len <= SIZE_MAX/element_sz)) \
      r = ((t_ret){ .tag = core_result_Err, .val = { .case_Err = { .tag = alloc_collections_CapacityOverflow } } }); \
    else if (v.ptr != NULL) { \
      r = ((t_ret){ .tag = core_result_Ok, .val = { .case_Ok = v }}); \
    } else { \
      r = ((t_ret){ .tag = core_result_Err, .val = { .case_Err = { \
         .tag = alloc_collections_AllocError, /* CHECK ??? */ \
         .layout = { .size = len * sizeof(t_elt), .align = 8 } \
       }}}); \
    } \
    r; \
  })

  Remember that this is all pre-monomorphization.

*)
let try_with_capacity =
  let open Krml in
  let open Ast in
  let t = TBound 0 in
  let t_try_reserve_error = TQualified ([ "alloc"; "collections" ], "TryReserveError") in
  (* Result<Vec<T>, TryReserveError> *)
  let t_ret = TApp (([ "core"; "result" ], "Result"), [ mk_vec t; t_try_reserve_error ]) in
  (* TryReserveError { kind = TryReserveErrorKind::Cons args } *)
  let mk_try_reserve_error cons args =
    with_type t_try_reserve_error
      (EFlat
         [
           ( Some "kind",
             with_type
               (TQualified ([ "alloc"; "collections" ], "TryReserveErrorKind"))
               (ECons (cons, args)) );
         ])
  in
  let mk_res_error err = with_type t_ret (ECons ("Err", [ err ])) in
  let mk_res_ok ok = with_type t_ret (ECons ("Ok", [ ok ])) in
  let binders = [ Helpers.fresh_binder "len" (TInt SizeT) ] in
  (* with size *)
  let ws = with_type (TInt SizeT) in
  fun lid ->
    DFunction
      ( None,
        [ Private ],
        0,
        1,
        t_ret,
        lid,
        binders,
        with_type t_ret
          (EIfThenElse
             ( (* if vec_overflows<t_elt>(len) then *)
               with_type TBool (EApp (expr_of_builtin_t vec_overflows [ t ], [ ws (EBound 0) ])),
               (* Result::Error(TryReserveError { kind = TryReserveErrorKind::CapacityOverflow }) *)
               mk_res_error (mk_try_reserve_error "CapacityOverflow" []),
               (* else let v: vec<t_elt> = vec_alloc len in *)
               with_type t_ret
                 (ELet
                    ( Helpers.fresh_binder "v" (mk_vec t),
                      with_type (mk_vec t)
                        (EApp (expr_of_builtin_t vec_alloc [ t ], [ ws (EBound 0) ])),
                      (* if vec_failed v then *)
                      with_type t_ret
                        (EIfThenElse
                           ( with_type TBool
                               (EApp
                                  ( expr_of_builtin_t vec_failed [ t ],
                                    [ with_type (mk_vec t) (EBound 0) ] )),
                             (* Result::Error(
                  TryReserveError { kind = TryReserveErrorKind::AllocError { layout: layout<T>(), non_exhaustive: () }}
                 )
              *)
                             mk_res_error
                               (mk_try_reserve_error "AllocError"
                                  [
                                    (* "layout", *)
                                    with_type layout_t
                                      (EApp (expr_of_builtin_t layout [ t ], [ Helpers.eunit ]));
                                    (* "non_exhaustive", *)
                                    Helpers.eunit;
                                  ]),
                             (* Result::Ok(v) *)
                             mk_res_ok (with_type (mk_vec t) (EBound 0)) )) )) )) )

let null_mut =
  let open Krml.Ast in
  let t = TBound 0 in
  fun lid ->
    DFunction
      ( None,
        [ Private ],
        0,
        1,
        TBuf (t, false),
        lid,
        [ Krml.Helpers.fresh_binder "_" TUnit ],
        with_type (TBuf (t, false)) EBufNull )

(* -------------------------------------------------------------------------- *)

let builtin_funcs =
  [
    sizeof;
    alignof;
    array_repeat;
    array_eq;
    array_eq_slice_mut;
    array_eq_slice_shared;
    slice_eq_shared;
    slice_eq_mut;
    slice_index_shared;
    slice_index_mut;
    slice_to_array;
    slice_to_ref_array;
    slice_to_ref_array2;
    discriminant;
    range_iterator_step_by;
    range_step_by_iterator_next;
    box_new;
    empty_array;
    replace;
    bitand_pv_u8;
    shr_pv_u8;
    min_u32;
    vec_alloc;
    vec_overflows;
    vec_failed;
    layout;
  ]
  (* Declares the 128-bit operations *)
  @ begin
      Op128Map.to_seq op_128_cfgs |> List.of_seq |> List.map snd
    end

let builtin_defined_funcs =
  [
    array_to_slice_func_shared;
    array_to_slice_func_mut;
    array_to_subslice_func_shared;
    array_to_subslice_func_mut;
    array_to_subslice_to_func_shared;
    array_to_subslice_to_func_mut;
    array_to_subslice_from_func_shared;
    array_to_subslice_from_func_mut;
    slice_subslice_func_shared;
    slice_subslice_func_mut;
    slice_subslice_to_func_shared;
    slice_subslice_to_func_mut;
    slice_subslice_from_func_shared;
    slice_subslice_from_func_mut;
  ]

let files =
  [
    Krml.Builtin.lowstar_ignore;
    (let externals =
       List.map
         (fun { name; typ; cg_args; n_type_args; arg_names } ->
           let typ = Krml.Helpers.fold_arrow cg_args typ in
           let flags = [ Krml.Common.Private ] in
           K.DExternal (None, flags, List.length cg_args, n_type_args, name, typ, arg_names))
         builtin_funcs
       @ builtin_defined_funcs
       @ [ nonzero_def; static_assert; c_string_def ]
     in
     "Eurydice", externals);
  ]

let is_a_builtin_func_name (name : K.lident) =
  (* Potentially make the list of built-in funcs a Map to speed up if necessary. *)
  List.exists (fun { name = n; _ } -> n = name) builtin_funcs


================================================
FILE: lib/Bundles.ml
================================================
(* A more modern version of the krml facility that matches on lids (instead of file names), and
   relies on a YAML file for configuration (rather than the cryptic syntax). *)

module L = Logging
module K = Krml.Ast
open Krml.Ast

type pattern = Prefix of string list | Exact of string list | Lid of lident [@@deriving show]
type visibility = Api | Internal | Private [@@deriving show]

let string_of_pattern = function
  | Exact p -> "[ " ^ String.concat ", " p ^ " ]"
  | Prefix p -> "[ " ^ String.concat ", " p ^ ", '*' ]"
  | Lid name -> String.concat "_" (fst name @ [ snd name ])

type file = {
  name : string;
  target : string;
  inline_static : bool;
  library : bool;
  definitions : (pattern * visibility) list;
  monomorphizations_using : (pattern * visibility) list;
  monomorphizations_of : (pattern * visibility) list;
  monomorphizations_exact : (pattern * visibility) list;
}

type config = file list

(** Loading & parsing *)

let load_config (path : string) : Yaml.value =
  (* TODO: library not found: Yaml_unix *)
  let contents = Krml.Utils.file_get_contents path in
  match Yaml.of_string contents with
  | Error (`Msg s) -> Krml.Warn.fatal_error "Issue reading configuration file: %s" s
  | Ok v -> v

let parsing_error f = Krml.Warn.fatal_error ("Issue parsing configuration file: " ^^ f)

let parse_pattern (v : Yaml.value) : pattern =
  match v with
  | `A vs ->
      let rec parse acc = function
        | `String "*" :: [] -> Prefix (List.rev acc)
        | `String "*" :: _ -> parsing_error "wildcards only allowed at the end"
        | `String s :: tl -> parse (s :: acc) tl
        | _ :: _ -> parsing_error "only strings in patterns"
        | [] -> Exact (List.rev acc)
      in
      parse [] vs
  | _ -> parsing_error "pattern not a list"

let parse_exact v : pattern =
  match parse_pattern v with
  | Exact lid -> Lid (Krml.KList.split_at_last lid)
  | _ -> parsing_error "monomorphizations_exact does not take wildcards"

let parse_file (v : Yaml.value) : file =
  match v with
  | `O ls ->
      let count = ref 0 in
      let lookup k =
        try
          let r = List.assoc k ls in
          incr count;
          Some r
        with Not_found -> None
      in
      let lookup_ k ls =
        try
          let r = List.assoc k ls in
          incr count;
          Some r
        with Not_found -> None
      in
      let name =
        match lookup "name" with
        | Some (`String name) -> name
        | Some _ -> parsing_error "name not a string"
        | None -> parsing_error "missing name"
      in
      let target =
        match lookup "target" with
        | Some (`String target) -> target
        | Some _ -> parsing_error "target not a string"
        | None -> ""
      in
      let inline_static =
        match lookup "inline_static" with
        | Some (`Bool inline_static) -> inline_static
        | Some _ -> parsing_error "inline_static not a bool"
        | None -> false
      in
      let library =
        match lookup "library" with
        | Some (`Bool library) -> library
        | Some _ -> parsing_error "library not a bool"
        | None -> false
      in
      let map_or f o k =
        match lookup_ k o with
        | None -> []
        | Some (`A l) -> List.map f l
        | Some _ -> failwith (k ^ " is not a list")
      in
      (* TODO: fix copy-pasting *)
      let definitions, monomorphizations_of, monomorphizations_using, monomorphizations_exact =
        (* Preserve order *)
        let rec parse ls =
          match ls with
          | [] -> [], [], [], []
          | ((("api" | "internal" | "private") as k), o) :: ls ->
              incr count;
              let vis =
                match k with
                | "api" -> Api
                | "internal" -> Internal
                | "private" -> Private
                | _ -> assert false
              in
              let parse_pattern_vis p = parse_pattern p, vis in
              let parse_exact_vis p = parse_exact p, vis in
              let defs, m_of, m_using, m_exact = parse ls in
              begin
                match o with
                | `A pats -> List.map parse_pattern_vis pats @ defs, m_of, m_using, m_exact
                | `O o ->
                    ( map_or parse_pattern_vis o "patterns" @ map_or parse_exact_vis o "exact" @ defs,
                      map_or parse_pattern_vis o "monomorphizations_of" @ m_of,
                      map_or parse_pattern_vis o "monomorphizations_using" @ m_using,
                      map_or parse_exact_vis o "monomorphizations_exact" @ m_exact )
                | _ -> failwith (k ^ " neither a list nor object")
              end
          | _ :: ls -> parse ls
        in
        parse ls
      in
      let include_ =
        match lookup "include_in_h" with
        | None -> []
        | Some (`A include_) ->
            List.map
              (function
                | `String s -> Krml.Options.HeaderOnly name, s
                | _ -> parsing_error "include_in_h must be a string")
              include_
        | Some _ -> parsing_error "include_in_h must be a list"
      in
      let include_internal =
        match lookup "include_in_internal_h" with
        | None -> []
        | Some (`A include_) ->
            List.map
              (function
                | `String s -> Krml.Options.InternalOnly name, s
                | _ -> parsing_error "include_in_internal_h must be a string")
              include_
        | Some _ -> parsing_error "include_in_internal_h must be a list"
      in
      let c_include_ =
        match lookup "include_in_c" with
        | None -> []
        | Some (`A include_) ->
            List.map
              (function
                | `String s -> Krml.Options.COnly name, s
                | _ -> parsing_error "include_in_c must be a string")
              include_
        | Some _ -> parsing_error "include_in_c must be a list"
      in
      if !count < List.length ls then
        parsing_error "extraneous fields in file";
      Krml.Options.(
        add_early_include := include_ @ c_include_ @ include_internal @ !add_early_include);
      {
        name;
        definitions;
        inline_static;
        library;
        monomorphizations_using;
        monomorphizations_of;
        monomorphizations_exact;
        target;
      }
  | _ -> parsing_error "file must be an object"

let parse_config (v : Yaml.value) : config =
  match v with
  | `O entries ->
      (match List.assoc_opt "naming" entries with
      | None -> ()
      | Some naming ->
          let skip_prefix =
            match naming with
            | `O [ ("skip_prefix", `A prefixes) ] -> prefixes
            | `O [ ("skip_prefix", _) ] -> parsing_error "skip_prefix must be a list"
            | _ -> parsing_error "naming must be an object with the following keys: skip_prefix"
          in
          let skip_prefix =
            List.map
              (function
                | `A m ->
                    List.map
                      (function
                        | `String s -> s
                        | _ -> parsing_error "skip_prefix component not a list of strings")
                      m
                | _ -> parsing_error "entries under skip prefix must be a list of strings")
              skip_prefix
          in
          let skip_prefix = List.map (fun p -> Krml.Bundle.Module p) skip_prefix in
          Krml.Options.(no_prefix := !no_prefix @ skip_prefix));
      begin
        match List.assoc_opt "files" entries with
        | Some (`A files) -> List.map parse_file files
        | _ -> parsing_error "files is not a sequence"
      end
  | _ -> parsing_error "YAML file must be an object with key files"

(** Constructing bundles *)

let starts_with l prefix =
  List.length prefix <= List.length l && fst (Krml.KList.split (List.length prefix) l) = prefix

(* `lid` matches pattern `p` *)
let matches lid p =
  match p with
  | Exact m -> m = fst lid
  | Prefix prefix -> starts_with (fst lid) prefix
  | Lid lid' -> lid = lid'

let find_map desc f l =
  List.find_map
    (fun (arg, ret) ->
      if f arg then
        Some (arg, ret, desc)
      else
        None)
    l

let mark_internal =
  let add_if name flags =
    let is_internal = List.mem Krml.Common.Internal flags in
    if (not is_internal) && not (Krml.Inlining.always_live name) then
      Krml.Common.Internal :: List.filter (( <> ) Krml.Common.Private) flags
    else
      List.filter (( <> ) Krml.Common.Private) flags
  in
  function
  | DFunction (cc, flags, n_cgs, n, typ, name, binders, body) ->
      DFunction (cc, add_if name flags, n_cgs, n, typ, name, binders, body)
  | DGlobal (flags, name, n, typ, body) -> DGlobal (add_if name flags, name, n, typ, body)
  | DType (lid, flags, n_cgs, n, def) -> DType (lid, add_if lid flags, n_cgs, n, def)
  | DExternal (cc, flags, n_cg, n, lid, t, pp) ->
      DExternal (cc, add_if lid flags, n_cg, n, lid, t, pp)

let adjust vis decl =
  match vis with
  | Api -> decl
  | Private -> Krml.Bundles.mark_private decl
  | Internal -> mark_internal decl

let record_inline_static lid = Krml.Options.(static_header := Lid lid :: !static_header)

let bundle (files : Krml.Ast.file list) (c : config) : files =
  let bundled = Hashtbl.create 137 in
  let bundle name decl =
    if Hashtbl.mem bundled name then
      Hashtbl.replace bundled name (decl :: Hashtbl.find bundled name)
    else
      Hashtbl.add bundled name [ decl ]
  in
  let record_library lid = Krml.Options.(library := Lid lid :: !library) in
  let files =
    List.map
      (fun ((filename : string), (decls : Krml.Ast.decl list)) ->
        ( filename,
          List.filter_map
            (fun decl ->
              let lid = lid_of_decl decl in
              let rec find config =
                match config with
                | [] ->
                    Krml.(KPrint.bprintf "%a doesn't go anywhere\n" PrintAst.Ops.plid lid);
                    false
                | { name; definitions; inline_static; library; _ } :: config -> (
                    (* Krml.KPrint.bprintf "for %s, definitions are :\n" name; *)
                    (* List.iter (fun (p, vis) -> *)
                    (*   Krml.KPrint.bprintf "%s: %s\n" (show_visibility vis) (show_pattern p) *)
                    (* ) definitions; *)
                    match
                      List.find_map
                        (fun (pat, vis) ->
                          if matches lid pat then
                            Some vis
                          else
                            None)
                        definitions
                    with
                    | None -> find config
                    | Some vis ->
                        (* Krml.(KPrint.bprintf "%a goes into %s at vis %s\n" PrintAst.Ops.plid lid name (show_visibility vis)); *)
                        (* if List.length vis_ > 1 then *)
                        (*   Krml.(KPrint.bprintf "vis_ was: %s\n" (String.concat ", " (List.map show_visibility vis_))); *)
                        let decl = adjust vis decl in
                        bundle name decl;
                        if inline_static then
                          record_inline_static lid;
                        if library then
                          record_library lid;
                        true)
              in
              if find c then
                None
              else
                Some decl)
            decls ))
      files
  in
  let files =
    List.filter
      (fun (filename, decls) ->
        (* Collision between the original crate name (e.g. libcrux_kyber) and the destination bundle
           (e.g. libcrux_kyber). *)
        if Hashtbl.mem bundled filename then begin
          List.iter (bundle filename) decls;
          false
        end
        else
          true)
      files
  in
  Hashtbl.fold
    (fun filename decls acc -> (filename, List.rev decls) :: acc)
    bundled
    (List.filter (fun (_, decls) -> decls <> []) files)

let libraries (files : Krml.Ast.file list) : files =
  List.map
    (fun (f, decls) ->
      ( f,
        List.filter_map
          (fun d ->
            let lid = Krml.Ast.lid_of_decl d in
            if List.exists (fun p -> Krml.(Bundle.pattern_matches_lid p lid)) !Krml.Options.library
            then begin
              Logging.log "Libraries" "%a becomes abstract\n" Krml.PrintAst.Ops.plid lid;
              match d with
              | DType (_, _, _, _, Abbrev _) as t -> Some t
              | DType _ -> None
              | d -> Krml.Builtin.make_abstract_function_or_global d
            end
            else
              Some d)
          decls ))
    files

let topological_sort decls =
  let module T = struct
    type color = White | Gray | Black
  end in
  let open T in
  let graph = Hashtbl.create 41 in
  let is_forward = function
    | DType (_, _, _, _, Forward _) -> `Forward
    | _ -> `Regular
  in
  List.iter
    (fun decl ->
      let deps =
        begin
          object (self)
            inherit [_] reduce as super
            method zero = []
            method plus = ( @ )
            method! visit_EQualified (under_ref, _) lid = [ lid, under_ref ]
            method! visit_TQualified under_ref lid = [ lid, under_ref ]

            method! visit_TApp under_ref lid ts =
              [ lid, under_ref ] @ List.concat_map (self#visit_typ under_ref) ts

            method! visit_TBuf _ t const = super#visit_TBuf true t const
          end
        end
          #visit_decl
          false decl
      in
      Hashtbl.add graph (lid_of_decl decl, is_forward decl) (ref White, deps, decl))
    decls;

  if L.has_logging "dfs" then
    Hashtbl.iter
      (fun (lid, forward) (_, deps, _) ->
        let open Krml in
        let open PrintAst.Ops in
        KPrint.bprintf "%a(%s) depends on: %s\n" plid lid
          (match forward with
          | `Forward -> "forward"
          | `Regular -> "regular")
          (String.concat " ++ "
             (List.map (fun (lid, b) -> KPrint.bsprintf "%a(%b)" plid lid b) deps)))
      graph;

  let stack = ref [] in
  let rec dfs (lid, under_ref) =
    let has_forward_decl = Hashtbl.mem graph (lid, `Forward) in
    if Hashtbl.mem graph (lid, `Regular) || has_forward_decl then
      let key =
        if has_forward_decl && under_ref then
          lid, `Forward
        else
          lid, `Regular
      in
      let r, deps, decl = Hashtbl.find graph key in
      match !r with
      | Black -> ()
      | Gray -> ()
      | White ->
          r := Gray;
          List.iter dfs deps;
          r := Black;
          (* Krml.(PrintAst.Ops.(KPrint.bprintf "%a %b\n" plid lid under_ref)); *)
          stack := decl :: !stack
  in
  List.iter (fun decl -> dfs (lid_of_decl decl, false)) decls;
  List.rev !stack

module LidMap = Krml.Idents.LidMap

(* Because the krml monomorphization procedure is not optimal, it is sometimes
   the case the our topological sort places a forward declaration *after* the
   corresponding struct. Filter those out! *)
let filter_forward files =
  let seen = Hashtbl.create 41 in
  List.map
    (fun (file, decls) ->
      ( file,
        List.filter_map
          (fun decl ->
            match decl with
            | DType (lid, _, _, _, Forward _) when Hashtbl.mem seen lid -> None
            | _ ->
                Hashtbl.add seen (lid_of_decl decl) ();
                Some decl)
          decls ))
    files

(* Second phase of bundling, post-monomorphization. This is Eurydice-specific,
   as we oftentimes need to move definitions that have been /specialized/ using
   e.g. a platform-specific trait into their own file.

   Note that there may be multiple definitions per `lid`, because of forward structs. *)
let reassign_monomorphizations (files : Krml.Ast.file list) (config : config) =
  let open Krml.Ast in
  let open Krml.PrintAst.Ops in
  (* Pure sanity check *)
  let count_decls files =
    List.fold_left
      (fun acc (_, decls) ->
        let add_incr lid map =
          if LidMap.mem lid map then
            LidMap.add lid (LidMap.find lid map + 1) map
          else
            LidMap.add lid 1 map
        in
        List.fold_left (fun acc decl -> add_incr (lid_of_decl decl) acc) acc decls)
      LidMap.empty files
  in
  let c0 = count_decls files in
  let target_of_lid = Hashtbl.create 41 in
  let ( ||| ) o1 o2 =
    match o1 with
    | Some _ -> o1
    | None -> o2
  in
  let reverse_type_map =
    (* Maps t____u (an lid) to t<u> (a type application) *)
    let map = Hashtbl.create 41 in
    Hashtbl.iter
      (fun node (_, monomorphized_lid) ->
        assert (snd3 node <> [] || thd3 node <> []);
        Hashtbl.add map monomorphized_lid (fold_tapp node))
      Krml.MonomorphizationState.state;
    map
  in
  let uses monomorphizations_using t =
    begin
      object (self)
        inherit [_] reduce as super

        method private visit_through_map lid =
          Option.bind (Hashtbl.find_opt reverse_type_map lid) (self#visit_typ ())

        method zero = None

        method plus o1 o2 =
          if o1 = None then
            o2
          else
            o1

        method! visit_TQualified _ lid' =
          find_map "monomorphizations_using" (matches lid') monomorphizations_using
          ||| self#visit_through_map lid'

        method! visit_TApp _ lid' ts =
          find_map "monomorphizations_using" (matches lid') monomorphizations_using
          ||| self#visit_through_map lid' ||| super#visit_TApp () lid' ts
      end
    end
      #visit_typ
      () t
  in
  (* Review the function monomorphization state.

     THOUGHTS: maybe this should just all be grouped as a single field? Do we really care about
     catching `t<u>` but not `u<t>`? (i.e., distinguish monomorphizations *of* from
     monomorphizations using?

     Semantics of `monomorphizations_using`:
       if `lid`, below, is the result of a (function) monomorphization that
       *uses* (in its arguments, `cgs`, below) an `lid'` that matches a
       `monomorphizations_using` clause of file `name`, then `lid` moves to
       `name`.
     Semantics of `monomorphizations_of`: unlike above, this matches a
       generic lid (e.g., we want all the monomorphized instances of `Result` to
       go into a single file)
     Semantics of `monomorphizations_exact`: self-explanatory
  *)
  Hashtbl.iter
    (fun (generic_lid, cgs, ts) monomorphized_lid ->
      match
        List.find_map
          (fun {
                 name;
                 inline_static;
                 monomorphizations_using;
                 monomorphizations_of;
                 monomorphizations_exact;
                 _;
               } ->
            (* Monomorphization resulting in exactly this name *)
            find_map "monomorphizations_exact" (matches monomorphized_lid) monomorphizations_exact
            |||
            (* Monomorphization using given trait name, amongst the arguments *)
            List.find_map
              (fun e ->
                match e.node with
                | EQualified lid' ->
                    find_map "monomorphizations_using" (matches lid') monomorphizations_using
                | _ -> None)
              cgs
            |||
            (* Monomorphization using given type name *)
            List.find_map (uses monomorphizations_using) ts
            |||
            (* Monomorphization of a given polymorphic name *)
            find_map "monomorphizations_of" (matches generic_lid) monomorphizations_of
            |> Option.map (fun vis -> name, inline_static, vis))
          config
      with
      | Some name -> Hashtbl.add target_of_lid monomorphized_lid name
      | None -> ())
    Krml.MonomorphizationState.generated_lids;
  (* Review the type monomorphization state. *)
  Hashtbl.iter
    (fun (generic_lid, ts, _) (_, monomorphized_lid) ->
      (* Krml.KPrint.bprintf "generic=%a, monomorphized=%a\n" plid generic_lid plid monomorphized_lid; *)
      match
        List.find_map
          (fun {
                 name;
                 inline_static;
                 monomorphizations_of;
                 monomorphizations_using;
                 monomorphizations_exact;
                 _;
               } ->
            find_map "monomorphizations_exact" (matches monomorphized_lid) monomorphizations_exact
            ||| List.find_map (uses monomorphizations_using) ts
            ||| find_map "monomorphizations_of" (matches generic_lid) monomorphizations_of
            |> Option.map (fun vis -> name, inline_static, vis))
          config
      with
      | Some name -> Hashtbl.add target_of_lid monomorphized_lid name
      | None -> ())
    Krml.MonomorphizationState.state;
  (* Debug *)
  Hashtbl.iter
    (fun lid (target, _inline_static, (pat, vis, desc)) ->
      L.log "Reassign"
        "declaration %a goes into file %s (at visibility: %s) because it matched %s in a %s section"
        plid lid target (show_visibility vis) (string_of_pattern pat) desc)
    target_of_lid;
  (* Filter the files, plucking out those that move and registering them under
     the right file name in `reassigned`. We maintain the invariant of one entry
     per key in the table. *)
  let reassigned = Hashtbl.create 41 in
  let files =
    List.map
      (fun (f, decls) ->
        ( f,
          List.filter
            (fun decl ->
              let lid = lid_of_decl decl in
              match Hashtbl.find_all target_of_lid lid with
              | exception Not_found -> true
              | [] -> true
              | entries ->
                  List.iter
                    (fun (target, inline_static, (_, vis, _)) ->
                      let decl = adjust vis decl in
                      if inline_static then
                        record_inline_static lid;
                      if Hashtbl.mem reassigned target then
                        Hashtbl.replace reassigned target (decl :: Hashtbl.find reassigned target)
                      else
                        Hashtbl.add reassigned target [ decl ])
                    (List.rev entries);
                  false)
            decls ))
      files
  in
  (* Extend each file with the definitions that are moving into it. *)
  let files =
    List.map
      (fun (f, decls) ->
        let reassigned =
          if Hashtbl.mem reassigned f then (
            let r = Hashtbl.find reassigned f in
            Hashtbl.remove reassigned f;
            r)
          else
            []
        in
        f, decls @ reassigned)
      files
  in

  (* Deal with files that did not exist previously. *)
  let files = files @ Hashtbl.fold (fun f reassigned acc -> (f, reassigned) :: acc) reassigned [] in

  (* A quick topological sort to make sure type declarations come *before*
     functions that use them. Note that this is incompatible with forward structs. *)
  let files = List.map (fun (f, decls) -> f, topological_sort decls) files in
  let c1 = count_decls files in
  ignore
    (LidMap.merge
       (fun lid v1 v2 ->
         match v1, v2 with
         | None, None -> failwith "impossible"
         | Some v1, None -> Krml.Warn.fatal_error "lost %d declaration for %a\n" v1 plid lid
         | None, Some v2 -> Krml.Warn.fatal_error "gained %d declaration for %a\n" v2 plid lid
         | Some v1, Some v2 ->
             if v1 != v2 then
               Krml.Warn.fatal_error "mismatch on %a: %d != %d\n" plid lid v1 v2
             else
               None)
       c0 c1);
  let files = filter_forward files in
  files


================================================
FILE: lib/Cleanup1.ml
================================================
open Krml.Ast
open Krml.DeBruijn
module H = Krml.Helpers
module AtomMap = Map.Make (Krml.Atom)
module AtomSet = Set.Make (Krml.Atom)

let set_of_map_keys m = AtomSet.of_list (List.map fst (AtomMap.bindings m))

let count_atoms =
  object
    inherit [_] reduce
    method private zero = AtomSet.empty
    method private plus = AtomSet.union
    method! visit_EOpen _ _ a = AtomSet.singleton a
  end

type remove_env = (string * typ * node_meta list * meta list) AtomMap.t

let pmeta buf ({ meta; _ } : 'a with_type) =
  List.iter
    (function
      | CommentBefore s | CommentAfter s ->
          Buffer.add_string buf s;
          Buffer.add_char buf '\n')
    meta

let mk typ meta node = { node; typ; meta }
let is_sequence = Krml.Simplify.is_sequence

let already_clean = function
  | [ "core"; "slice"; _ ], "swap" -> true
  | [ "alloc"; "vec"; _ ], "try_with_capacity" -> true
  | _ -> false

let remove_assignments =
  object (self)
    inherit [_] map

    method private peel_lets (to_close : remove_env) e =
      match e.node with
      | ELet (b, e1, e2) ->
          (if not (e1.node = EAny || e1.node = EUnit) then
             Krml.(Warn.fatal_error "Initializer of let-binding is %a" PrintAst.Ops.pexpr e1));
          (* Krml.(KPrint.bprintf "peeling %s\n" b.node.name); *)
          let b, e2 = open_binder b e2 in
          (* Krml.KPrint.bprintf "peel: let-binding meta %a\n" pmeta b; *)
          let to_close =
            AtomMap.add b.node.atom (b.node.name, b.typ, b.meta, b.node.meta) to_close
          in
          self#peel_lets to_close e2
      | _ ->
          let e = Krml.Simplify.sequence_to_let#visit_expr_w () e in
          (* Krml.(KPrint.bprintf "after peeling:\n%a\n\n" PrintAst.Ops.ppexpr e); *)
          self#visit_expr_w to_close e

    method! visit_DFunction (to_close : remove_env) cc flags n_cgs n t name bs e =
      (* Krml.(KPrint.bprintf "visiting %a\n" PrintAst.Ops.plid name); *)
      assert (AtomMap.is_empty to_close);
      DFunction
        ( cc,
          flags,
          n_cgs,
          n,
          t,
          name,
          bs,
          if already_clean name then
            e
          else
            self#peel_lets to_close e )

    method! visit_DGlobal (to_close : remove_env) flags n t name e =
      assert (AtomMap.is_empty to_close);
      DGlobal (flags, n, t, name, self#peel_lets to_close e)

    method! visit_ELet ((not_yet_closed : remove_env), t) b e1 e2 =
      (* If [not_yet_closed] represents the set of bindings that have yet to be
         closed (i.e. for which we have yet to insert a let-binding, as close as
         possible to the first use-site), and [candidates] represents the atoms
         that we know for sure must be closed right now, then [close_now_over]
         inserts suitable let-bindings for the candidates that have not yet been
         closed, then calls the continuation with the remaining subset of
         not_yet_closed. *)
      let close_now_over (not_yet_closed : remove_env) candidates mk_node =
        let to_close_now = AtomSet.inter candidates (set_of_map_keys not_yet_closed) in
        let bs = List.of_seq (AtomSet.to_seq to_close_now) in
        let bs =
          List.map
            (fun atom ->
              let name, typ, meta, binder_meta = AtomMap.find atom not_yet_closed in
              ( {
                  node = { atom; name; mut = true; mark = ref Krml.Mark.default; meta = binder_meta };
                  typ;
                  meta;
                },
                if typ = TUnit then
                  Krml.Helpers.eunit
                else
                  Krml.Helpers.any ))
            bs
        in
        (* For the subexpressions, we now need to insert declarations for those variables that we're
           not handling now. *)
        let not_yet_closed =
          AtomMap.filter (fun a _ -> not (AtomSet.mem a to_close_now)) not_yet_closed
        in
        let node = mk_node not_yet_closed in
        (* XXX why is the with_type necessary here?? *)
        (Krml.Helpers.nest bs t (with_type t node)).node
      in

      let count e = count_atoms#visit_expr_w () e in

      let ( ++ ) = AtomSet.union in

      (* Called when hitting a node in terminal position: either fall back into
         the general case if it's a let-node; special treatment if it's
         control-flow (match, if, while); otherwise, just close everything now and
         move on (wildcard case). *)
      let rec recurse_or_close (not_yet_closed : remove_env) e0 =
        let t = e0.typ in
        match e0.node with
        | ELet _ ->
            (* let node: restart logic and jump back to match below *)
            self#visit_expr_w not_yet_closed e0
        | EIfThenElse (e, e', e'') ->
            mk t e0.meta
            @@ close_now_over not_yet_closed
                 ((* We must now bind: *)
                  count e
                ++
                (* whichever variables were in the condition *)
                AtomSet.empty)
                 (* unlike below, we are in terminal position, so we do not need to
                    close immediately variables that appear in both branches -- we can simply declare them
                    twice in each branch! is this a better code-gen choice? yes, absolutely -- owing to
                    the structure of MIR, NOT doing this generates awful code *)
                 (fun not_yet_closed ->
                   EIfThenElse
                     ( self#visit_expr_w not_yet_closed e,
                       recurse_or_close not_yet_closed e',
                       recurse_or_close not_yet_closed e'' ))
        | EWhile (e, e') ->
            mk t e0.meta
            @@ close_now_over not_yet_closed (count e) (fun not_yet_closed ->
                   EWhile (self#visit_expr_w not_yet_closed e, recurse_or_close not_yet_closed e'))
        | ESwitch (e, branches) ->
            mk t e0.meta
            @@ close_now_over not_yet_closed
                 ((* We must now bind: *)
                  count e
                ++
                (* i.e., whichever variables were in the condition *)
                AtomSet.empty)
                 (* see above *)
                 (fun not_yet_closed ->
                   ESwitch
                     ( self#visit_expr_w not_yet_closed e,
                       List.map (fun (p, e) -> p, recurse_or_close not_yet_closed e) branches ))
        | EMatch (c, e, branches) ->
            mk t e0.meta
            @@ close_now_over not_yet_closed
                 ((* We must now bind: *)
                  count e
                ++
                (* i.e., whichever variables were in the condition *)
                AtomSet.empty)
                 (* see above *)
                 (fun not_yet_closed ->
                   EMatch
                     ( c,
                       self#visit_expr_w not_yet_closed e,
                       List.map
                         (fun (bs, p, e) -> bs, p, recurse_or_close not_yet_closed e)
                         branches ))
        | _ ->
            (* There are opportunities for finesse here, for instance, if we reach
               an assignment in terminal position, *and* the variable has yet to
               be closed, it means that the assignment is useless since no one
               else will be using the variable after that. *)
            mk t e0.meta
            @@ close_now_over not_yet_closed (count e0) (fun not_yet_closed ->
                   (* not_yet_closed should be empty at this stage *)
                   (self#visit_expr_w not_yet_closed e0).node)
      in

      match e1.node with
      | EAssign ({ node = EOpen (_, atom); _ }, e_rhs) when AtomMap.mem atom not_yet_closed ->
          close_now_over not_yet_closed (count e_rhs) (fun not_yet_closed ->
              (* Combined "close now" (above) + let-binding insertion in lieu of the assignment *)
              assert (is_sequence b.node.meta);
              let e2 = snd (open_binder b e2) in
              let name, typ, meta, binder_meta = AtomMap.find atom not_yet_closed in
              let b =
                {
                  node =
                    { atom; name; mut = true; mark = ref Krml.Mark.default; meta = binder_meta };
                  typ;
                  meta = meta @ e1.meta;
                }
              in
              let not_yet_closed = AtomMap.remove atom not_yet_closed in
              (* Krml.(KPrint.bprintf "rebuilt: %a\n" PrintAst.Ops.pexpr (with_type TUnit (ELet (b, e_rhs, e2)))); *)
              let e2 = recurse_or_close not_yet_closed (close_binder b e2) in
              ELet (b, e_rhs, e2))
      | EIfThenElse (e, e', e'') ->
          assert (is_sequence b.node.meta);
          close_now_over not_yet_closed
            ((* We must now bind: *)
             count e
            ++
            (* whichever variables were in the condition *)
            AtomSet.inter (count e') (count e'')
            ++
            (* variables that appear in both branches *)
            AtomSet.inter (count e' ++ count e'') (count e2))
            (* variables in either branch *and* used later *)
            (fun not_yet_closed ->
              ELet
                ( b,
                  mk e1.typ e1.meta
                    (EIfThenElse
                       ( self#visit_expr_w not_yet_closed e,
                         recurse_or_close not_yet_closed e',
                         recurse_or_close not_yet_closed e'' )),
                  recurse_or_close not_yet_closed e2 ))
      | EWhile (e, e') ->
          assert (is_sequence b.node.meta);
          close_now_over not_yet_closed
            (* We must be here variables that are declared in the condition, and variables that
               appear both in the loop body and its continuation. *)
            (count e ++ AtomSet.inter (count e') (count e2))
            (fun not_yet_closed ->
              ELet
                ( b,
                  mk e1.typ e1.meta
                    (EWhile (self#visit_expr_w not_yet_closed e, recurse_or_close not_yet_closed e')),
                  recurse_or_close not_yet_closed e2 ))
      | ESwitch (e, branches) ->
          assert (is_sequence b.node.meta);
          close_now_over not_yet_closed
            ((* We must now bind: *)
             count e
            ++
            (* i.e., whichever variables were in the condition *)
            Krml.KList.reduce AtomSet.inter (List.map (fun (_p, e) -> count e) branches)
            ++
            (* i.e., variables that appear in all branches -- note that
                  switches don't bind variables in their branches so it's simpler
                  than the match below*)
            AtomSet.inter
              (Krml.KList.reduce ( ++ ) (List.map (fun (_, e) -> count e) branches))
              (count e2))
            (* i.e., variables in either one of the branches *and* used later *)
            (fun not_yet_closed ->
              ELet
                ( b,
                  mk e1.typ e1.meta
                    (ESwitch
                       ( self#visit_expr_w not_yet_closed e,
                         List.map (fun (p, e) -> p, recurse_or_close not_yet_closed e) branches )),
                  recurse_or_close not_yet_closed e2 ))
      | EMatch (c, e, branches) ->
          assert (is_sequence b.node.meta);
          close_now_over not_yet_closed
            ((* We must now bind: *)
             count e
            ++
            (* i.e., whichever variables were in the condition *)
            Krml.KList.reduce AtomSet.inter (List.map (fun (_bs, _p, e) -> count e) branches)
            ++
            (* i.e., variables that appear in all branches -- note that we
                  don't open _bs meaning that we don't collect bound variables in this branch *)
            AtomSet.inter
              (Krml.KList.reduce ( ++ ) (List.map (fun (_, _, e) -> count e) branches))
              (count e2))
            (* i.e., variables in either one of the branches *and* used later *)
            (fun not_yet_closed ->
              ELet
                ( b,
                  mk e1.typ e1.meta
                    (EMatch
                       ( c,
                         self#visit_expr_w not_yet_closed e,
                         List.map
                           (fun (bs, p, e) -> bs, p, recurse_or_close not_yet_closed e)
                           branches )),
                  recurse_or_close not_yet_closed e2 ))
      | _ ->
          (* The open variables in e1 for which we have not yet inserted a declaration need to be closed now *)
          close_now_over not_yet_closed (count e1) (fun not_yet_closed ->
              ELet (b, self#visit_expr_w not_yet_closed e1, recurse_or_close not_yet_closed e2))
  end

let remove_terminal_returns =
  object (self)
    inherit [_] map

    method! visit_DFunction env cc flags n_cgs n t name bs e =
      DFunction
        ( cc,
          flags,
          n_cgs,
          n,
          t,
          name,
          bs,
          if already_clean name then
            e
          else
            self#visit_expr_w env e )

    method! visit_ELet (terminal, _) b e1 e2 =
      (* let _ = x := e in
         return x                 ~~~>      return e
      *)
      match e1.node, e2.node with
      | EAssign ({ node = EBound i; _ }, e1), EReturn { node = EBound j; _ } when j = i + 1 ->
          (* This early optimization is important to avoid superfluous variable
             declarations for the return value of the function -- these
             interfere with pattern-matches such as resugar_loops. See
             test/for.rs *)
          self#visit_EReturn (terminal, e2.typ) e1
      | _ -> ELet (b, self#visit_expr_w false e1, self#visit_expr_w terminal e2)

    method! visit_EWhile _ e1 e2 = EWhile (self#visit_expr_w false e1, self#visit_expr_w false e2)

    method! visit_EFor _ b e1 e2 e3 e4 =
      EFor
        ( b,
          self#visit_expr_w false e1,
          self#visit_expr_w false e2,
          self#visit_expr_w false e3,
          self#visit_expr_w false e4 )

    method! visit_EReturn (terminal, _) e =
      if terminal then
        (self#visit_expr_w terminal e).node
      else
        EReturn (self#visit_expr_w terminal e)

    method! visit_ESequence (terminal, _) es =
      let es, e = Krml.KList.split_at_last es in
      ESequence (List.map (self#visit_expr_w false) es @ [ self#visit_expr_w terminal e ])

    method! visit_EIfThenElse (terminal, _) e1 e2 e3 =
      EIfThenElse
        (self#visit_expr_w false e1, self#visit_expr_w terminal e2, self#visit_expr_w terminal e3)

    method! visit_EMatch (terminal, _) f e branches =
      EMatch
        ( f,
          self#visit_expr_w false e,
          List.map (fun (b, p, e) -> b, p, self#visit_expr_w terminal e) branches )
  end

let remove_terminal_continues =
  object (self)
    inherit [_] map

    method! visit_DFunction env cc flags n_cgs n t name bs e =
      DFunction
        ( cc,
          flags,
          n_cgs,
          n,
          t,
          name,
          bs,
          if already_clean name then
            e
          else
            self#visit_expr_w env e )

    method! visit_ELet (terminal, _) b e1 e2 =
      ELet (b, self#visit_expr_w false e1, self#visit_expr_w terminal e2)

    method! visit_EWhile _ e1 e2 = EWhile (self#visit_expr_w false e1, self#visit_expr_w true e2)

    method! visit_EFor _ b e1 e2 e3 e4 =
      EFor
        ( b,
          self#visit_expr_w false e1,
          self#visit_expr_w false e2,
          self#visit_expr_w false e3,
          self#visit_expr_w true e4 )

    method! visit_EContinue (terminal, t) =
      if terminal then begin
        assert (t = TUnit);
        EUnit
      end
      else
        EContinue

    method! visit_ESequence (terminal, _) es =
      let es, e = Krml.KList.split_at_last es in
      ESequence (List.map (self#visit_expr_w false) es @ [ self#visit_expr_w terminal e ])

    method! visit_EIfThenElse (terminal, _) e1 e2 e3 =
      EIfThenElse
        (self#visit_expr_w false e1, self#visit_expr_w terminal e2, self#visit_expr_w terminal e3)

    method! visit_EMatch (terminal, _) f e branches =
      EMatch
        ( f,
          self#visit_expr_w false e,
          List.map (fun (b, p, e) -> b, p, self#visit_expr_w terminal e) branches )
  end

let unsigned_overflow_is_ok_in_c =
  object
    inherit [_] map as super

    method! visit_EApp env e es =
      let is_u = function
        | "u8" | "u16" | "u32" | "u64" | "usize" -> true
        | _ -> false
      in
      let as_w = function
        | "u8" -> K.UInt8
        | "u16" -> UInt16
        | "u32" -> UInt32
        | "u64" -> UInt64
        | "usize" -> SizeT
        | _ -> failwith "not an unsigned crate name"
      in
      let as_t t = TInt (as_w t) in
      match e.node with
      | EQualified ([ "core"; "num"; t; _ ], "wrapping_add") when is_u t ->
          EApp (Krml.Helpers.mk_op Add (as_t t), es)
      | EQualified ([ "core"; "num"; t; _ ], "wrapping_sub") when is_u t ->
          EApp (Krml.Helpers.mk_op Sub (as_t t), es)
      | EQualified ([ "core"; "num"; t; _ ], "wrapping_mul") when is_u t ->
          EApp (Krml.Helpers.mk_op Mult (as_t t), es)
      | _ -> super#visit_EApp env e es
  end

(* PPrint.(Krml.Print.(print (Krml.PrintAst.print_files files ^^ hardline))); *)

let remove_slice_eq =
  object (self)
    inherit [_] map as super

    method private do_it ~const eq t u s1 s2 =
      assert (t = u);
      let slice_eq =
        if const then
          Builtin.slice_eq_shared
        else
          Builtin.slice_eq_mut
      in
      match flatten_tapp t with
      | lid, [ t ], [] when lid = Builtin.derefed_slice ->
          let rec is_flat = function
            | TArray (t, _) -> is_flat t
            | TInt _ | TBool | TUnit -> true
            | _ -> false
          in
          if not (is_flat t) then
            failwith "TODO: slice eq at non-flat types";
          with_type TBool (EApp (Builtin.expr_of_builtin_t slice_eq [ t ], [ s1; s2 ]))
      | _ ->
          let deref e = with_type (H.assert_tbuf e.typ) (EBufRead (e, H.zero_usize)) in
          with_type TBool (EApp (List.hd eq, [ deref s1; deref s2 ]))

    method! visit_expr _ e =
      match e with
      | [%cremepat {| core::cmp::impls::?impl::eq(#?eq..)<?t,?u>(?s1, ?s2) |}] -> begin
          match impl with
          | "{core::cmp::PartialEq<&0 mut (B)> for &1 mut (A)}" ->
              self#do_it ~const:false eq t u s1 s2
          | "{core::cmp::PartialEq<&0 (B)> for &1 (A)}" -> self#do_it ~const:true eq t u s1 s2
          | _ -> failwith "unknown eq impl in core::cmp::impls"
        end
      | _ -> super#visit_expr ((), e.typ) e
  end

let remove_units =
  object (self)
    inherit [_] map as super

    (* Every local variable at type unit is suitably initialized *)
    method! visit_ELet env b e1 e2 =
      if b.typ = TUnit && e1.node = EAny then
        ELet (b, Krml.Helpers.eunit, self#visit_expr_w () e2)
      else
        super#visit_ELet env b e1 e2

    (* Assigning into a local variable of type unit is meaningless and the rhs can be used instead
       -- no uninitialized variables issues, because of ELet above. *)
    method! visit_EAssign env e1 e2 =
      match e1.node with
      | EBound _ when e1.typ = TUnit -> (self#visit_expr_w () e2).node
      | _ -> super#visit_EAssign env e1 e2

    (* Returning a local variable of type unit is equivalent to returning a unit *)
    method! visit_EReturn env e =
      match e.node with
      | EBound _ when e.typ = TUnit -> EReturn Krml.Helpers.eunit
      | _ -> super#visit_EReturn env e

    method! visit_ESequence _env es =
      let es = List.filter (fun x -> x.node <> EUnit) (List.map (self#visit_expr_w ()) es) in
      match es with
      | [] -> EUnit
      | [ e ] -> e.node
      | _ -> ESequence es
  end

let cleanup files =
  let files = remove_units#visit_files () files in
  let files = remove_assignments#visit_files AtomMap.empty files in
  let files = unsigned_overflow_is_ok_in_c#visit_files () files in
  let files = remove_terminal_returns#visit_files true files in
  let files = Krml.Simplify.optimize_lets files in
  (* Krml.(PPrint.(Print.(print (PrintAst.print_files files ^^ hardline)))); *)
  let files = remove_terminal_continues#visit_files false files in
  let files = Krml.Simplify.let_to_sequence#visit_files () files in
  let files = remove_slice_eq#visit_files () files in
  files


================================================
FILE: lib/Cleanup2.ml
================================================
open Krml.Ast
open Krml.DeBruijn
module H = Krml.Helpers
module L = Logging
open Krml.PrintAst.Ops

(* Target cleanups invoked from bin/main.ml *)

(* A note on the various cleanup phases for arrays to preserve the semantics of Rust. Assume
   `struct S { y: [u32; 4] }`.
   ... pass by ref
   1. remove_array_repeats: [e; N] becomes bufcreate e N, or bufcreateL, depending on some
      heuristics -- see comments in this phase 
   2. remove_literals: let x = S { y: foo } --> let x; x.y := foo; x
      where the assignment has an array type -- this is either because foo would decay in C and as
      such cannot appear in the initializer; or because of foo if of a syntactic form that does not
      suit itself to becoming an initializer (e.g. is an if-then-else).
   3. remove_implicit_array_copies: handles x := e1 at array types, including nested array cases
   ... hoist

   Phase 2. performs a limited form of hoisting, There is an invariant that hoist cannot be more
   aggressive than 2., otherwise, there will be array copy-assignments that won't be compiled.
*)

(* In the initial value of a variable, is this a suitable expression to initialize something that
   has an array type (or a struct that may contain arrays)? *)
let rec is_suitable_array_initializer =
  let rec subarrays_only_literals e =
    (* Underneath an initializer list *)
    match e.node, e.typ with
    | _, TArray _ ->
        (* In the case of nested arrays *)
        begin
          match e.node with
          | EBufCreateL (_, es) ->
              (* We only allow sub-initializer lists *)
              List.for_all subarrays_only_literals es
          | _ ->
              (* Anything else (e.g. variable) is not copy-assignment in C *)
              false
        end
    | EFlat es, _ -> List.for_all subarrays_only_literals (List.map snd es)
    | _ ->
        (* If this is not a nested array, then anything goes *)
        true
  in
  function
  | EAny | EBufCreate _ -> true
  | EBufCreateL (_, es) -> List.for_all subarrays_only_literals es
  | EFlat es -> List.for_all subarrays_only_literals (List.map snd es)
  | _ -> false

(* A general phase that removes assignments at array types. Note that all array repeat expressions
   are desugared before this. We try to reduce all cases to the assignment case (e1 := e2). *)
let remove_implicit_array_copies =
  object (self)
    inherit [_] map as super

    (* Desugar `lhs := rhs in e2`, because `rhs` has an array type and `not (is_suitable_initializer rhs)`. *)
    method private remove_assign n lhs rhs e2 =
      (* Krml.KPrint.bprintf "remove_assign %a := %a\n" pexpr lhs pexpr rhs; *)
      let is_array = function
        | TArray _ -> true
        | _ -> false
      in

      (* What are we trying to assign? *)
      match rhs.node with
      | EBufCreateL (Stack, es) ->
          if List.for_all (( = ) (List.hd es)) es && not (is_array (List.hd es).typ) then
            (* We assign a list of elements that are all identical -- optimize *)
            let lift = Krml.DeBruijn.lift 1 in
            ELet
              ( H.sequence_binding (),
                H.with_unit (EBufFill (lhs, List.hd es, Krml.Helpers.mk_uint32 (List.length es))),
                lift e2 )
          else begin
            (* lhs := bufcreatel e1, e2, ... ~~> lhs[0] := e1, lhs[1] := e2, ...
               we possibly recurse if the type of elements is an array *)
            assert (List.length es = int_of_string (snd n));
            let lift = Krml.DeBruijn.lift in
            let rec nest lifting_index array_index es =
              match es with
              | [] -> lift lifting_index (self#visit_expr_w () e2)
              | e :: es -> (
                  let array_index_ =
                    with_type H.usize (EConstant (SizeT, string_of_int array_index))
                  in
                  let lhs_i =
                    with_type (H.assert_tbuf_or_tarray lhs.typ) (EBufRead (lhs, array_index_))
                  in
                  match e.typ with
                  | TArray (_, n) ->
                      with_type e2.typ
                        (self#remove_assign n (lift lifting_index lhs_i) (lift lifting_index e)
                           (nest lifting_index (array_index + 1) es))
                  | _ ->
                      with_type e2.typ
                        (ELet
                           ( H.sequence_binding (),
                             H.with_unit (EAssign (lift lifting_index lhs_i, lift lifting_index e)),
                             nest (lifting_index + 1) (array_index + 1) es )))
            in
            (nest 0 0 es).node
          end
      | _ ->
          (* Something else, e.g. a variable -- generate a memcpy *)
          let zero = Krml.(Helpers.zero Constant.SizeT) in
          let rhs = self#visit_expr_w () rhs in
          let lhs = self#visit_expr_w () lhs in
          ELet
            ( H.sequence_binding (),
              H.with_unit (EBufBlit (rhs, zero, lhs, zero, PreCleanup.expr_of_constant n)),
              lift 1 (self#visit_expr_w () e2) )

    method! visit_ELet (((), _) as env) b e1 e2 =
      match b.typ, e1.node with
      (* INVALID INITIALIZATION: let b = e1 in e2 -- explode into assignments, recursively *)
      | TArray (_, n), _ when not (is_suitable_array_initializer e1.node) ->
          (* let b = <uninitialized> in *)
          ELet
            ( b,
              H.any,
              (* b := *)
              with_type e2.typ
                (self#remove_assign n (with_type b.typ (EBound 0)) (Krml.DeBruijn.lift 1 e1)
                   (* e2 *)
                   (self#visit_expr env e2)) )
      (* COPY: let _ = lhs := rhs with lhs.typ == TArray _ ... *)
      | _, EAssign (lhs, rhs) when H.is_array lhs.typ ->
          let n =
            match lhs.typ with
            | TArray (_, n) -> n
            | _ -> failwith "impossible"
          in
          (* Fixpoint here for multi-dimensional arrays. *)
          self#remove_assign n lhs rhs (subst H.eunit 0 e2)
      | _ -> super#visit_ELet env b e1 e2

    method! visit_EAssign env lhs rhs =
      (* COPY: lhs := rhs with lhs.typ == TArray _ ... *)
      match lhs.typ with
      | TArray (_, n) -> self#remove_assign n lhs rhs H.eunit
      | _ -> super#visit_EAssign env lhs rhs
  end

let remove_array_temporaries =
  object (self)
    inherit [_] map as _super

    method! visit_ELet (((), _) as env) b e1 e2 =
      (* let x: TArray (t, n) = any;
         blit (src, 0, dst, 0, n); // same length
         x
         ~~>
         src
      *)
      match snd !(b.node.mark), b.typ, e1.node, e2.node with
      | ( AtMost 2,
          TArray (_, l),
          EAny,
          ESequence
            [
              {
                node =
                  EBufBlit
                    ( src,
                      { node = EConstant (_, "0"); _ },
                      { node = EBound 0; _ },
                      { node = EConstant (_, "0"); _ },
                      { node = EConstant l'; _ } );
                _;
              };
              { node = EBound 0; _ };
            ] )
        when l = l' -> (subst H.eunit 0 src).node
      | _ -> ELet (b, self#visit_expr env e1, self#visit_expr env e2)
  end

(* We remove array repeat expressions.

   Such expressions might occur in any position; we rewrite everything into a
   single form let x = [e; n] with a let-binding. (The later hoist phase is
   going to do this anyhow, so we might as well do it now for simplicity.)

   - If the array repeat is made up of zeroes, or array repeats made of zeroes,
     then we generate (complete) initializer lists that the subsequent code-gen
     in CStarToC will be able to emit as = { 0 } (note that this works because
     we ensure such expressions are let-bound.) We could expand and generate
     EBufCreateL nodes for *any* array repeat whose bounds are statically known,
     but that's generally a bad idea.
   - If the array repeat is of a /simple form/ (i.e., e is a scalar value), then
     we use the BufCreate node, to be emitted later on (also in CStarToC) as a
     zero-initializer, a memset, or a for-loop.
   - Barring that, we use a for-loop and recurse.

   This happens BEFORE remove_implicit_array_copies above. *)
let remove_array_repeats =
  object (self)
    inherit [_] map as super

    method! visit_EApp env e es =
      (* This is the case where the declaration is not in let-binding position. This happens with
         e.g. `fn init() -> ... { [0; 32] }`. *)
      match e.node, es with
      | ETApp ({ node = EQualified lid; _ }, [ _ ], _, [ _ ]), [ _ ]
        when lid = Builtin.array_repeat.name ->
          (* Same logic as below: if we can do something smart (like, only zeroes), then we expand,
             let the subsequent `hoist` phase lift this into a let-binding, and code-gen will optimize this into
             { 0 }. If we can't do something smart, we let-bind, and fall back onto the general case. *)
          begin
            try (self#expand_repeat (fst env) (with_type (snd env) (EApp (e, es)))).node
            with Not_found ->
              (self#visit_expr env
                 (with_type (snd env)
                    (ELet
                       ( H.fresh_binder "repeat_expression" (snd env),
                         with_type (snd env) (EApp (e, es)),
                         with_type (snd env) (EBound 0) ))))
                .node
          end
      | _ -> super#visit_EApp env e es

    method private assert_length len =
      match len.node with
      | EConstant (_, s) -> int_of_string s
      | _ -> failwith "impossible"

    method private is_arr_typ t =
      match t with
      | TQualified ([ s1 ], s2) -> s1 = "Eurydice" && String.sub s2 0 3 = "arr"
      | _ -> false

    (* This function recursively expands nested repeat expressions as initializer lists
       (EBufCreateL) as long as the innermost initial value is a zero, otherwise, it throws
       Not_found. For instance:
       - [[0; 2]; 2] --> { {0, 0}, {0, 0} }.
       - [[1; 2]; 2] --> error -- better code quality with a BufCreate expression which will give
         rise to a for-loop initializer

       We override this behavior when we're already underneath a visit_DGlobal -- here, we've already
       committed to an initializer list (and Charon will suitably "fold" repeat expressions
       automatically for us), so we might as well expand.
       
    *)
    method private expand_repeat under_global e =
      match e.node with
      | EApp
          ( { node = ETApp ({ node = EQualified lid; _ }, [ len ], _, [ _ ]); _ },
            [ ({ node = EConstant (_, "0"); _ } as init) ] )
        when lid = Builtin.array_repeat.name ->
          (* [0; n] -> ok *)
          with_type e.typ @@ EBufCreateL (Stack, List.init (self#assert_length len) (fun _ -> init))
      | EApp
          ( { node = ETApp ({ node = EQualified lid; _ }, [ len ], _, [ _ ]); _ },
            [ ({ node = EConstant _; _ } as init) ] )
        when lid = Builtin.array_repeat.name && under_global ->
          (* [c; n] -> get translated when we are under DGlobal *)
          with_type e.typ @@ EBufCreate (Stack, init, Krml.Helpers.mk_sizet (self#assert_length len))
      | EApp ({ node = ETApp ({ node = EQualified lid; _ }, [ len ], _, [ _ ]); _ }, [ init ])
        when lid = Builtin.array_repeat.name ->
          (* [e; n] -> ok if e ok -- n is a constant here Rust has no VLAs *)
          let init = self#expand_repeat under_global init in
          with_type e.typ @@ EBufCreateL (Stack, List.init (self#assert_length len) (fun _ -> init))
      | EFlat [ (lido, e1) ] when lido = Some "data" && self#is_arr_typ e.typ ->
          (* { .data = e } -> ok if e ok *)
          let e1 = self#expand_repeat under_global e1 in
          with_type e.typ (EFlat [ lido, e1 ])
      | EBufCreateL (l, es) when under_global ->
          (* { e1, e2, ... en } -> get recursively expanded when are under DGlobal *)
          with_type e.typ @@ EBufCreateL (l, List.map (self#expand_repeat true) es)
      | _ ->
          if under_global then
            e
          else
            raise Not_found

    method! visit_DGlobal _env flags name n t e1 = super#visit_DGlobal true flags name n t e1

    method! visit_ELet ((under_global, _) as env) b e1 e2 =
      match e1.node with
      (* Nothing special here for EBufCreateL otherwise it breaks the invariant expected by
         remove_implicit_array_copies *)
      | EApp ({ node = ETApp ({ node = EQualified lid; _ }, [ len ], _, [ _ ]); _ }, [ init ])
        when lid = Builtin.array_repeat.name -> begin
          try
            (* Case 1 (only zeroes). *)
            let r = ELet (b, (self#expand_repeat under_global) e1, self#visit_expr env e2) in
            r
          with Not_found -> (
            match init.node with
            | EConstant _ ->
                (* Case 2. *)
                let e1 =
                  with_type e1.typ
                    (EBufCreate (Stack, init, Krml.Helpers.mk_sizet (self#assert_length len)))
                in
                ELet (b, e1, self#visit_expr env e2)
            | _ ->
                (* Case 3. *)

                (* let b = [ init; len ] *)
                let module H = Krml.Helpers in
                let len = self#visit_expr env len in
                let init = self#visit_expr env init in
                (* let b; *)
                ELet
                  ( b,
                    H.any,
                    (* let _ = *)
                    with_type e2.typ
                      (ELet
                         ( H.sequence_binding (),
                           (* for *)
                           H.with_unit
                             (EFor
                                ( Krml.Helpers.fresh_binder ~mut:true "i" H.usize,
                                  H.zero_usize (* i = 0 *),
                                  H.mk_lt_usize (Krml.DeBruijn.lift 2 len) (* i < len *),
                                  H.mk_incr_usize (* i++ *),
                                  let i = with_type H.usize (EBound 0) in
                                  let b = with_type b.typ (EBound 1) in
                                  let b_i =
                                    with_type (H.assert_tbuf_or_tarray b.typ) (EBufRead (b, i))
                                  in
                                  (* b[i] := init *)
                                  H.with_unit (EAssign (b_i, Krml.DeBruijn.lift 2 init)) )),
                           (* e2 *)
                           Krml.DeBruijn.lift 1 (self#visit_expr env e2) )) ))
        end
      | _ -> super#visit_ELet env b e1 e2
  end

let remove_array_from_fn files =
  let defs =
    Krml.Helpers.build_map files (fun tbl d ->
        match d with
        | DFunction (_, _, _, _, _, name, _, body) -> Hashtbl.add tbl name body
        | _ -> ())
  in
  begin
    object
      inherit [_] map as super

      method! visit_DFunction _ cc flags n_cgs n t name bs e =
        assert (n_cgs = 0 && n = 0);
        Hashtbl.add defs name e;
        super#visit_DFunction () cc flags n_cgs n t name bs e

      method! visit_EApp env e es =
        match e.node with
        | ETApp
            ( { node = EQualified ([ "core"; "array" ], "from_fn"); _ },
              [ len ],
              [ call_mut; _call_once ],
              [ t_elements; _t_captured_state ] ) ->
            L.log "Cleanup2" "%a %a" ptyp t_elements ptyp t_elements;
            (* By translating array into struct, we return a struct of array for [from_fn] here *)
            let state = Krml.KList.one es in
            let t_struct, _ = Krml.Helpers.flatten_arrow e.typ in
            let t_element, _ = Krml.Helpers.flatten_arrow call_mut.typ in
            let t_array =
              match len.node with
              | EConstant c -> TArray (t_element, c)
              | _ -> assert false
            in
            let x, dst_struct = H.mk_binding ~mut:true "arr_struct" t_struct in
            let dst = with_type t_array (EField (dst_struct, "data")) in
            let bindx = x, with_type t_struct EAny in
            let t_dst = H.assert_tbuf_or_tarray t_array in
            let for_assign =
              let lift1 = Krml.DeBruijn.lift 1 in
              with_type TUnit
                (EFor
                   ( Krml.Helpers.fresh_binder ~mut:true "i" H.usize,
                     H.zero_usize (* i: size_t = 0 *),
                     H.mk_lt_usize (Krml.DeBruijn.lift 1 len) (* i < len *),
                     H.mk_incr_usize (* i++ *),
                     let i = with_type H.usize (EBound 0) in
                     Krml.Helpers.with_unit
                       (EBufWrite
                          ( lift1 dst,
                            i,
                            with_type t_dst
                              (EApp
                                 ( call_mut,
                                   [
                                     with_type (TBuf (state.typ, false)) (EAddrOf (lift1 state));
                                     with_type (TInt SizeT) (EBound 0);
                                   ] )) )) ))
            in
            (H.nest [ bindx ] t_struct (with_type t_struct (ESequence [ for_assign; dst_struct ])))
              .node
        | ETApp
            ( { node = EQualified ("core" :: "array" :: _, "map"); _ },
              [ len ],
              [ call_mut; _call_once ],
              ts ) ->
            let t_src, t_dst =
              match ts with
              | [ t_src; t_state; t_dst ] ->
                  assert (t_state = TUnit);
                  L.log "Cleanup2" "found array map from %a to %a" ptyp t_src ptyp t_dst;
                  t_src, t_dst
              | _ ->
                  failwith "TODO: unknown map closure shape; is it an array outparam? (see above)"
            in
            let e_src, e_state =
              match es with
              | [ e_src; e_state ] -> e_src, e_state
              | _ -> failwith "unknown shape of arguments to array map"
            in
            let len_c =
              match len.node with
              | EConstant c -> c
              | _ -> failwith "unable to get the const length for array map"
            in
            let lift1 = Krml.DeBruijn.lift 1 in
            let e_state = with_type (TBuf (e_state.typ, false)) (EAddrOf (lift1 e_state)) in
            let e_src = with_type (TArray (t_src, len_c)) (EField (e_src, "data")) in
            let t_dst_str, _ = Krml.Helpers.flatten_arrow e.typ in
            let t_dst_arr = TArray (t_dst, len_c) in
            let x, dst_struct = H.mk_binding ~mut:true "arr_mapped_str" t_dst_str in
            let e_dst = with_type t_dst_arr (EField (dst_struct, "data")) in
            let bindx = x, with_type t_dst_str EAny in
            let for_assign =
              with_type TUnit
                (EFor
                   ( Krml.Helpers.fresh_binder ~mut:true "i" H.usize,
                     H.zero_usize (* i = 0 *),
                     H.mk_lt_usize (Krml.DeBruijn.lift 1 len) (* i < len *),
                     H.mk_incr_usize (* i++ *),
                     let i = with_type H.usize (EBound 0) in
                     let e_src_i = with_type t_src (EBufRead (lift1 e_src, i)) in
                     Krml.Helpers.with_unit
                       (EBufWrite
                          ( lift1 e_dst,
                            i,
                            with_type t_dst (EApp (call_mut, [ lift1 e_state; e_src_i ])) )) ))
            in
            (H.nest [ bindx ] t_dst_str
               (with_type t_dst_str (ESequence [ for_assign; dst_struct ])))
              .node
        | _ -> super#visit_EApp env e es
    end
  end
    #visit_files
    () files

let remove_trivial_into =
  object (self)
    inherit [_] map as _super

    method! visit_EApp env e es =
      let e = self#visit_expr_w () e in
      let es = List.map (self#visit_expr env) es in
      match e.node, es with
      | ( ETApp ({ node = EQualified ([ "core"; "convert"; _ ], "into"); _ }, [], _, [ t1; t2 ]),
          [ e1 ] )
        when t1 = t2 -> e1.node
      | ( ETApp
            ( { node = EQualified ([ "core"; "convert"; _ ], "into"); _ },
              [],
              _,
              [ TInt _; (TInt _ as t2) ] ),
          [ e1 ] ) -> ECast (e1, t2)
      | _ -> EApp (e, es)
  end

let remove_trivial_ite =
  object (self)
    inherit [_] map as super

    method! visit_EIfThenElse (((), _) as env) e1 e2 e3 =
      match e1.node with
      | EApp
          ( { node = EOp (Eq, _); _ },
            [ { node = EConstant (w1, c1); _ }; { node = EConstant (w2, c2); _ } ] )
        when w1 = w2 ->
          if int_of_string c1 = int_of_string c2 then
            (self#visit_expr env e2).node
          else
            (self#visit_expr env e3).node
      | EBool true -> (self#visit_expr env e2).node
      | EBool false -> (self#visit_expr env e3).node
      | _ -> super#visit_EIfThenElse env e1 e2 e3

    method! visit_ESwitch env scrut branches =
      let const_eq (w1, s1) (w2, s2) = w1 = w2 && int_of_string s1 = int_of_string s2 in
      let fits s (w' : K.width) =
        let s = Z.of_string s in
        match w' with
        | UInt8 -> Z.leq s (Z.of_string "0xff")
        | UInt16 -> Z.leq s (Z.of_string "0xffff")
        | UInt32 -> Z.leq s (Z.of_string "0xffffffff")
        | UInt64 -> Z.leq s (Z.of_string "0xffffffffffffffff")
        | _ -> false (* conservative decision *)
      in
      let normalize = function
        | ECast ({ node = EConstant (_, s); _ }, TInt w') when fits s w' -> EConstant (w', s)
        | c -> c
      in
      match normalize scrut.node with
      | EConstant c -> begin
          match
            List.find_opt
              (function
                | SConstant c', _ -> const_eq c c'
                | _ -> false)
              branches
          with
          | Some (_, b) -> (self#visit_expr env b).node
          | None -> begin
              match List.find_opt (fun (sv, _) -> sv = SWild) branches with
              | Some (_, b) -> (self#visit_expr env b).node
              | None ->
                  assert (snd env = TUnit);
                  EUnit
            end
        end
      | _ -> super#visit_ESwitch env scrut branches
  end

let contains_array t =
  begin
    object (_self)
      inherit [_] reduce as _super
      method zero = false
      method plus = ( || )
      method! visit_TBuf _ _ _ = false
      method! visit_TArray _ _ _ = true
      method! visit_TCgArray _ _ _ = true
    end
  end
    #visit_expr_w
    () t

let must_explode e =
  (* Note that this visits the whole type (including the type of fields) *)
  contains_array e && not (is_suitable_array_initializer e.node)

let remove_literals tbl =
  object (_self)
    inherit [_] map as super_map
    inherit! Krml.Structs.remove_literals tbl as super_krml

    method! visit_ELet env b e1 e2 =
      if must_explode e1 then
        super_krml#visit_ELet env b e1 e2
      else
        super_map#visit_ELet env b e1 e2

    method! visit_EFlat (((), t) as env) fields =
      if must_explode (with_type t (EFlat fields)) then
        super_krml#visit_EFlat env fields
      else
        super_map#visit_EFlat env fields

    method! visit_DGlobal _env flags name n t body =
      (* No point: can't have let-bindings in globals *)
      DGlobal (flags, name, n, t, body)
  end

let remove_literals files =
  (remove_literals (Krml.Structs.build_remove_literals_map files))#visit_files () files

let build_macros (macros : Krml.Idents.LidSet.t ref) =
  object (_self)
    inherit [_] map as super

    method! visit_DGlobal env flags name n t body =
      (if List.mem Krml.Common.Macro flags then
         macros := Krml.Idents.LidSet.(union !macros (singleton name)));
      super#visit_DGlobal env flags name n t body
  end

let build_macros files =
  let map = ref Krml.Idents.LidSet.empty in
  let files = (build_macros map)#visit_files () files in
  files, !map

let rec ends_with pred e =
  match e.node with
  | EIfThenElse (_, e1, e2) -> ends_with pred e1 && ends_with pred e2
  | EMatch (_, _, es) -> List.for_all (fun (_, _, e) -> ends_with pred e) es
  | ELet (_, _, e) -> ends_with pred e
  | ESequence es -> ends_with pred (Krml.KList.last es)
  | _ -> pred e

let ends_with_continue =
  ends_with (fun n ->
      match n.node with
      | EContinue -> true
      | _ -> false)

let ends_with_return =
  ends_with (fun n ->
      match n.node with
      | EReturn _ -> true
      | _ -> false)

let resugar_loops =
  object(self)
  inherit [_] map as super

  method! visit_expr ((), _ as env) e =
    let open Krml.Helpers in
    let step_by = match e with
      (* Non-terminal position (step-by for-loop) *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          let x = core::iter::adapters::step_by::?::next<?, ?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          }
        };
        ?rest..
      |}] -> 
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = Krml.DeBruijn.subst e_some_i 0 e_body in
        Some (t1, e_start, e_end, e_increment, [e_body], rest)

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          let x = core::iter::adapters::step_by::?::next<?, ?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        };
        ?rest..
      |}] -> 
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = List.map (Krml.DeBruijn.subst e_some_i 0) (e_body :: loop_rest) in
        Some (t1, e_start, e_end, e_increment, e_body, rest)

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          match (core::iter::adapters::step_by::?::next<?, ?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          }
        };
        ?rest..
      |}] -> Some (t1, e_start, e_end, e_increment, [e_body], rest)

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          match (core::iter::adapters::step_by::?::next<?, ?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        };
        ?rest..
      |}] -> Some (t1, e_start, e_end, e_increment, e_body :: loop_rest, rest)

      (* Terminal position (step-by for-loop) *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          let x = core::iter::adapters::step_by::?::next<?, ?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          }
        }
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = Krml.DeBruijn.subst e_some_i 0 e_body in
        Some (t1, e_start, e_end, e_increment, [e_body], [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          let x = core::iter::adapters::step_by::?::next<?, ?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        }
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = List.map (Krml.DeBruijn.subst e_some_i 0) (e_body :: loop_rest) in
        Some (t1, e_start, e_end, e_increment, e_body, [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          match (core::iter::adapters::step_by::?::next<?, ?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          }
        }
      |}] -> Some (t1, e_start, e_end, e_increment, [e_body], [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter<
            core::iter::adapters::step_by::StepBy<core::ops::range::Range<?..>>,
            ?..
          >(core::iter::range::?::step_by<?..>(
            { start: ?e_start, end: ?e_end },
            ?e_increment
          ));
        while true {
          match (core::iter::adapters::step_by::?::next<?, ?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        }
      |}] -> Some (t1, e_start, e_end, e_increment, e_body :: loop_rest, [])

      | _ -> None
    in

    let range_iter = match e with
      (* Terminal position (regular range for-loop) *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?..>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          let x = core::iter::range::?::next<?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          }
        }
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = Krml.DeBruijn.subst e_some_i 0 e_body in
        Some (t1, e_start, e_end, [e_body], [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?..>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          let x = core::iter::range::?::next<?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        }
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = List.map (Krml.DeBruijn.subst e_some_i 0) (e_body :: loop_rest) in
        Some (t1, e_start, e_end, e_body, [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?..>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          match (core::iter::range::?::next<?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          }
        }
      |}] -> Some (t1, e_start, e_end, [e_body], [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?..>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          match (core::iter::range::?::next<?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        }
      |}] -> Some (t1, e_start, e_end, e_body :: loop_rest, [])

      (* Non-terminal position (regular range for-loop) *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          let x = core::iter::range::?::next<?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          }
        };
        ?rest..
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = Krml.DeBruijn.subst e_some_i 0 e_body in
        Some (t1, e_start, e_end, [e_body], rest)

      (* Non-terminal position (regular range for-loop) *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          let x = core::iter::range::?::next<?t1>(&iter);
          match x {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        };
        ?rest..
      |}] ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = List.map (Krml.DeBruijn.subst e_some_i 0) (e_body :: loop_rest) in
        Some (t1, e_start, e_end, e_body, rest)

      (* Special variant that appears in external crates -- TODO: do we need variants of all other
         patterns? *)
      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          let x = core::iter::range::?::next<?t1>(&iter);
          match x {
            None -> ?e2,
            Some ? -> ?e_body
          };
          abort
        }
      |}] when ends_with_return e2 && ends_with_continue e_body
      (* && x does not appear in e2 *) ->
        let e_some_i = with_type (Builtin.mk_option t1) (ECons ("Some", [with_type t1 (EBound 0)])) in
        let e_body = Krml.DeBruijn.subst e_some_i 0 e_body in
        Some (t1, e_start, e_end, [e_body], [])

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          match (core::iter::range::?::next<?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          }
        };
        ?rest..
      |}] -> Some (t1, e_start, e_end, [e_body], rest)

      | [%cremepat {|
        let iter =
          core::iter::traits::collect::?::into_iter
            <core::ops::range::Range<?>, ?..>
            ({ start: ?e_start, end: ?e_end });
        while true {
          match (core::iter::range::?::next<?t1>(&iter)) {
            None -> break,
            Some ? -> ?e_body
          };
          ?loop_rest..
        };
        ?rest..
      |}] -> Some (t1, e_start, e_end, e_body :: loop_rest, rest)

      | _ -> None
    in

    match step_by with
    | Some (t1, e_start, e_end, e_increment, e_body, rest) -> 
      let w = match t1 with TInt w -> w | _ -> assert false in
      with_type e.typ @@
        ESequence (
          with_type TUnit (EFor (
            fresh_binder ~mut:true "i" t1,
            e_start,
            mk_lt w (Krml.DeBruijn.lift 1 e_end),
            (* XXX seems like the increment is always size_t here ?! *)
            mk_incr_e w (with_type t1 (ECast (e_increment, t1))),
            with_type TUnit (ESequence (
              List.map (self#visit_expr env) e_body
            ))
          )) :: List.map (fun e -> self#visit_expr env (Krml.DeBruijn.subst eunit 0 e)) rest
      )
    | None -> begin match range_iter with
      | Some (t1, e_start, e_end, e_body, rest) -> 
        let w = match t1 with TInt w -> w | _ -> assert false in
        with_type e.typ @@ ESequence (
          with_type TUnit (EFor (
            fresh_binder ~mut:true "i" t1,
            e_start,
            mk_lt w (Krml.DeBruijn.lift 1 e_end),
            mk_incr w,
            with_type TUnit (ESequence (
              List.map (self#visit_expr env) e_body
            ))
          )) :: List.map (fun e -> self#visit_expr env (Krml.DeBruijn.subst eunit 0 e)) rest
        )
      | None -> super#visit_expr env e
    end

end
[@ocamlformat "disable"]

let improve_names files =
  let renamed = Hashtbl.create 41 in
  let allocated = Hashtbl.create 41 in
  (object (_self)
     inherit [_] iter

     method! visit_DFunction _ _ _ _ _ _ ((m, n) as lid) _ _ =
       let trait_impl, m = List.partition (fun s -> s.[0] = '{') m in
       match trait_impl with
       | [ trait_impl ] ->
           let hash = Hashtbl.hash trait_impl in
           let n = Printf.sprintf "%s_%02x" n (hash land 0xFF) in
           Krml.Monomorphization.maybe_debug_hash hash
             (lazy PPrint.(string "trait impl:" ^/^ string trait_impl));
           let n = Krml.Idents.mk_fresh n (fun n -> Hashtbl.mem allocated (m, n)) in
           Hashtbl.add renamed lid ((m, n), trait_impl);
           Hashtbl.add allocated (m, n) ()
       | _ -> ()
  end)
    #visit_files
    () files;
  (* Hashtbl.iter (fun k (v, _) -> *)
  (*   Krml.KPrint.bprintf "%a --> %a\n" plid k plid v *)
  (* ) renamed; *)
  (* TODO: are there other global maps like this whose lids need to be
     updated??? *)
  Krml.Options.static_header :=
    List.map
      (function
        | Krml.Bundle.Lid lid when Hashtbl.mem renamed lid ->
            Krml.Bundle.Lid (fst (Hashtbl.find renamed lid))
        | x -> x)
      !Krml.Options.static_header;
  (object (self)
     inherit [_] map

     method! visit_DFunction env cc flags n_cgs n t lid bs e =
       match Hashtbl.find_opt renamed lid with
       | Some (lid, trait_impl) ->
           let comment = Krml.KPrint.bsprintf "This function found in impl %s" trait_impl in
           DFunction (cc, flags @ [ Comment comment ], n_cgs, n, t, lid, bs, self#visit_expr_w env e)
       | None -> DFunction (cc, flags, n_cgs, n, t, lid, bs, self#visit_expr_w env e)

     method! visit_EQualified _ lid =
       EQualified
         (match Hashtbl.find_opt renamed lid with
         | Some (lid, _) -> lid
         | None -> lid)
  end)
    #visit_files
    () files

let recognize_asserts =
  object (_self)
    inherit [_] map as super

    method! visit_EIfThenElse (((), _) as env) e1 e2 e3 =
      match e1.typ, e2.node, e3.node with
      | TBool, EUnit, EAbort (_, msg) ->
          (* if e1 then () else abort msg -->  static_assert(e1, msg) *)
          EApp
            ( Builtin.static_assert_ref,
              [ e1; with_type Krml.Checker.c_string (EString (Option.value ~default:"" msg)) ] )
      | TBool, EAbort (_, msg), EUnit ->
          (* if not (e1) then abort msg else ()  -->  static_assert(e1, msg) *)
          EApp
            ( Builtin.static_assert_ref,
              [
                Krml.Helpers.mk_not e1;
                with_type Krml.Checker.c_string (EString (Option.value ~default:"" msg));
              ] )
      | _ -> super#visit_EIfThenElse env e1 e2 e3
  end

(* Reconstructing for-loops from while nodes introduced by c_for!. *)

class iter_counting =
  object
    (* The environment [i] has type [int]. *)
    inherit [_] iter

    (* The environment [i] keeps track of how many binders have been
       entered. It is incremented at each binder. *)
    method! extend i (_ : binder) = i + 1
  end

(* De Bruijn index i is found in expression e *)
let found i e =
  let exception Found in
  let find =
    object
      inherit iter_counting

      method! visit_EBound (i, _) j =
        if i = j then
          raise Found
    end
  in
  try
    find#visit_expr_w i e;
    false
  with Found -> true

let smallest =
  object
    inherit [_] reduce
    method zero = max_int
    method plus x y = min x y
    method visit_EBound _ i = i
  end

let rec find_terminal_incr i e =
  if e.typ <> TUnit && e.typ <> TAny then
    Krml.Warn.failwith "e_then has type: %a\n" ptyp e.typ;
  let ( let* ) = Option.bind in
  let hoist e = Krml.DeBruijn.subst_n e (List.init i (fun _ -> Krml.Helpers.eunit)) in
  match e.node with
  | ELet (b, e1, e2) ->
      let* e2, e_incr = find_terminal_incr (i + 1) e2 in
      Some ({ e with node = ELet (b, e1, e2) }, e_incr)
  | ESequence es ->
      let es, e_incr = Krml.KList.split_at_last es in
      let nearest = smallest#visit_expr_w () e_incr in
      if nearest < i then
        None
      else
        Some ({ e with node = ESequence es }, hoist e_incr)
  | _ ->
      let nearest = smallest#visit_expr_w () e in
      if nearest < i then
        None
      else
        Some (Krml.Helpers.eunit, hoist e)

let reconstruct_for_loops =
  let no_control_flow (e : expr) =
    match e.node with
    | EWhile _ | EFor _ | ELet _ | EFun _ | EIfThenElse _ | ESequence _ | EMatch _ | ESwitch _ ->
        false
    | _ -> true
  in

  object (self)
    inherit [_] map as super

    method! visit_ELet (((), _) as env) b e1 e2 =
      match e1.node, e1.typ, e2.node with
      (* t x = e1; while (true) { if (e_cond) { ...;  e_incr } else { break; } *)
      | ( _,
          _,
          EWhile
            ( { node = EBool true; _ },
              { node = EIfThenElse (e_cond, e_then, { node = EBreak; _ }); _ } ) ) -> begin
          match find_terminal_incr 0 e_then with
          | Some (e_then, e_incr) when no_control_flow e_incr ->
              let e_then = self#visit_expr env e_then in
              EFor (b, e1, e_cond, e_incr, e_then)
          | _ -> super#visit_ELet env b e1 e2
        end
      (* let t x = e1 in
         let _ = while (true) { if (e_cond) { e_then; e_incr } else { break; } in
         e2
         ~~~>
         let _ = for (t x = e1; e_cond; e_incr) { e_then } in
         e2 *)
      | ( _,
          _,
          ELet
            ( _,
              {
                node =
                  EWhile
                    ( { node = EBool true; _ },
                      { node = EIfThenElse (e_cond, e_then, { node = EBreak; _ }); _ } );
                _;
              },
              e2' ) )
        when not (found 1 e2') -> begin
          match find_terminal_incr 0 e_then with
          | Some (e_then, e_incr) when no_control_flow e_incr ->
              let e_then = self#visit_expr env e_then in
              let e2 = self#visit_expr env e2' in
              let shift1 = Krml.(DeBruijn.subst Helpers.eunit 0) in
              ELet
                ( Krml.Helpers.sequence_binding (),
                  with_type TUnit (EFor (b, e1, e_cond, e_incr, e_then)),
                  shift1 e2 )
          | _ -> super#visit_ELet env b e1 e2
        end
      | _ -> super#visit_ELet env b e1 e2

    method! visit_EWhile env e1 e2 =
      (* while (true) { if (e_cond) { e_then } else { break } } ~~>
         while (e_cond) { e_then } *)
      match e1.node, e2.node with
      | EBool true, EIfThenElse (e_cond, e_then, { node = EBreak; _ }) ->
          EWhile (e_cond, self#visit_expr env e_then)
      | _ -> super#visit_EWhile env e1 e2

    (*     method! visit_DFunction _ cc flags n_cgs n t name bs e = *)
    (*       Krml.KPrint.bprintf "for-loop reconstruction: visiting %a\n" plid name; *)
    (*       super#visit_DFunction () cc flags n_cgs n t name bs e *)
  end

let remove_assign_return =
  object (self)
    inherit [_] map as super

    method! visit_ESequence (((), _) as env) es =
      match List.rev es with
      | { node = EReturn { node = EBound i; _ }; typ = t; _ }
        :: { node = EAssign ({ node = EBound i'; _ }, e); _ }
        :: es
        when i = i' ->
          ESequence (List.rev (with_type t (EReturn e) :: List.map (self#visit_expr env) es))
      | { node = EBound i; _ } :: { node = EAssign ({ node = EBound i'; _ }, e); _ } :: es
        when i = i' -> ESequence (List.rev (e :: List.map (self#visit_expr env) es))
      | _ -> super#visit_ESequence env es
  end

let bonus_cleanups =
  let open Krml in
  object (self)
    inherit [_] map as super
    method! extend env b = b.node.name :: env

    method! visit_lident _ lid =
      match lid with
      | [ "core"; "slice"; "{[T]}" ], "len" -> [ "Eurydice" ], "slice_len"
      | [ "core"; "slice"; "{[T]}" ], "copy_from_slice" -> [ "Eurydice" ], "slice_copy"
      | [ "core"; "slice"; "{[T]}" ], "split_at" -> [ "Eurydice" ], "slice_split_at"
      | [ "core"; "slice"; "{[T]}" ], "split_at_mut" -> [ "Eurydice" ], "slice_split_at_mut"
      | _ -> lid

    (* { f = e; ... }.f ~~> e

     scheduled late because we need all the let-inlining *)
    method! visit_EField env e f =
      match e.node with
      | EFlat fields -> (List.assoc (Some f) fields).node
      | _ -> EField (self#visit_expr env e, f)

    method! visit_ELet ((bs, _) as env) b e1 e2 =
      match e1.node, e1.typ, e2.node with
      (* let x; x := e; return x  -->  x*)
      | ( EAny,
          _,
          ESequence [ { node = EAssign ({ node = EBound 0; _ }, e3); _ }; { node = EBound 0; _ } ] )
        -> (DeBruijn.subst Helpers.eunit 0 e3).node
      (* let uu; memcpy(uu, ..., src, ...); e2  -->  let copy_of_src; ... *)
      | ( EAny,
          TArray (_, (_, n)),
          ESequence
            [
              {
                node =
                  EBufBlit
                    ( { node = EBound src; _ },
                      { node = EConstant (_, "0"); _ },
                      { node = EBound 0; _ },
                      { node = EConstant (_, "0"); _ },
                      { node = EConstant (_, n'); _ } );
                _;
              };
              _;
            ] )
        when n = n' && Krml.Helpers.is_uu b.node.name ->
          super#visit_ELet env
            {
              b with
              node = { b.node with name = "copy_of_" ^ List.nth bs (src - 1) };
              meta = [ CommentBefore "Passing arrays by value in Rust generates a copy in C" ];
            }
            e1 e2
      (* let uu = f(e); y = uu; e2  -->  let y = f(e); e2 *)
      | ( EApp ({ node = EQualified _; _ }, es),
          _,
          ESequence [ { node = EAssign (e2, { node = EBound 0; _ }); _ }; e3 ] )
        when Helpers.is_uu b.node.name && List.for_all Helpers.is_readonly_c_expression es ->
          ESequence
            [
              with_type TUnit (EAssign (DeBruijn.subst Helpers.eunit 0 e2, e1));
              self#visit_expr env (DeBruijn.subst Helpers.eunit 0 e3);
            ]
      | _ -> super#visit_ELet env b e1 e2
  end

let cosmetic =
  object (_self)
    inherit [_] map as super

    method! visit_expr _ e =
      match e with
      | [%cremepat {| core::slice::?impl::len<?>(Eurydice::array_to_slice_shared[#?n]<?>(?)) |}]
        when impl = "{[T]}" -> n
      | [%cremepat {| core::slice::?impl::len<?>(Eurydice::array_to_slice_mut[#?n]<?>(?)) |}]
        when impl = "{[T]}" -> n
      | [%cremepat {| core::slice::?impl::len<?>(?e) |}] when impl = "{[T]}" ->
          with_type (TInt SizeT) (EField (e, "meta"))
      | [%cremepat {| Eurydice::slice_index_mut<?t>(?s, ?i) |}] ->
          with_type e.typ
            (EBufRead (with_type (TBuf (t, false)) (EField (super#visit_expr_w () s, "ptr")), i))
      | [%cremepat {| Eurydice::slice_index_shared<?t>(?s, ?i) |}] ->
          with_type e.typ
            (EBufRead (with_type (TBuf (t, true)) (EField (super#visit_expr_w () s, "ptr")), i))
      | _ -> super#visit_expr ((), e.typ) e
  end

(* This is a potentially tricky phase because if it's too aggressive, it'll
   generate a copy -- for instance, f(&x[3]) is not the same as let tmp = x[3];
   f(&tmp). Such cases might be hidden behind macros! (Like
   Eurydice_slice_index.) *)
let check_addrof =
  object (self)
    inherit [_] map

    method! visit_EAddrOf ((), t) e =
      (* see https://en.cppreference.com/w/c/language/operator_member_access *)
      match e.node with
      | EQualified _ (* case 1 *) | EBufRead _ (* case 4 *) -> EAddrOf (self#visit_expr_w () e)
      | EApp ({ node = EQualified lid; _ }, _)
      | EApp ({ node = ETApp ({ node = EQualified lid; _ }, _, _, _); _ }, _)
        when lid = Builtin.slice_index_shared.name
             || lid = Builtin.slice_index_mut.name
             || Krml.KString.starts_with (snd lid) "op_Bang_Star__" (* case 4, case 3 *) ->
          EAddrOf e
      | _ ->
          (* Recursively do for the internal expression first *)
          let e = self#visit_expr_w () e in
          if Krml.Structs.will_be_lvalue e then
            EAddrOf e
          else
            let b = Krml.Helpers.fresh_binder ~mut:true "lvalue" e.typ in
            let b =
              {
                b with
                Krml.Ast.meta = [ CommentBefore "original Rust expression is not an lvalue in C" ];
              }
            in
            ELet (b, e, with_type t (EAddrOf (with_type e.typ (EBound 0))))
  end

(* Aeneas requires hoisting loop bodies into separate functions. *)
let is_inline_loop lid = Krml.KString.exists (snd lid) "inner_loop"

let return_becomes_break =
  object
    inherit [_] Krml.Ast.map as super
    method! visit_EReturn _ _ = EBreak
    method! visit_EFor _ _ _ _ = failwith "nested loop in a loop body"

    method! visit_EApp env e es =
      match e.node with
      | EQualified lid when is_inline_loop lid -> failwith "nested loop in a loop body"
      | _ -> super#visit_EApp env e es
  end

let inline_loops =
  object
    inherit [_] Krml.Ast.map

    method! visit_DFunction () cc flags n_cgs n t name binders body =
      if is_inline_loop name then
        DFunction
          ( cc,
            [ Krml.Common.MustInline; MustDisappear ] @ flags,
            n_cgs,
            n,
            t,
            name,
            binders,
            return_becomes_break#visit_expr_w () body )
      else
        DFunction (cc, flags, n_cgs, n, t, name, binders, body)
  end

(** A better version of hoist (than [Krml.Simplify.hoist]), also work for [DGlobal]. *)
let hoist =
  object
    inherit Krml.Simplify.hoist

    method! visit_DGlobal loc flags name n ret expr =
      let loc = Krml.Loc.(InTop name :: loc) in
      let lhs, expr = Krml.Simplify.maybe_hoist_initializer field_types loc ret expr in
      let expr = H.nest lhs ret expr in
      DGlobal (flags, name, n, ret, expr)
  end

(** Also fix for [DGlobal] as [hoist] above *)
let fixup_hoist =
  object
    inherit [_] map

    method! visit_DFunction _ cc flags n_cgs n ret name binders expr =
      DFunction (cc, flags, n_cgs, n, ret, name, binders, Krml.Simplify.fixup_return_pos expr)

    method! visit_DGlobal () flags name n ret expr =
      DGlobal (flags, name, n, ret, Krml.Simplify.fixup_return_pos expr)
  end

(** For any [DGlobal], if the expression has any locals remaining We should let them also be
    globals, so to make the overall expr valid.

    I.e., we make: [T VAL = let v1 : T1 = e1 in let v2 : T2 = e2 in ... let vN : TN = eN in e;]
    become:
    [T1 VAL_local_1 = e1; T2 VAL_local_2 = e2[v1/VAL_local_1]; ... TN VAL_local_N =
     eN[v1/VAL_local_1; v2/VAL_local_2; ...; vN-1/VAL_local_(N-1)]; T VAL = e;]

    Notably, the locals should be renamed to avoid potential naming conflicts. *)
let globalize_global_locals files =
  let mapper = function
    | DGlobal (flags, name, n_cgs, ty, expr) ->
        let rec decompose_expr id info_acc expr =
          match expr.node with
          | ELet (_, e1, e2) ->
              let name =
                let lst, name = name in
                lst, name ^ "$local$" ^ string_of_int id
              in
              (* Replace the variable with the new globalised name. *)
              let e2 = subst Krml.Ast.(with_type e1.typ (EQualified name)) 0 e2 in
              decompose_expr (id + 1) ((name, e1) :: info_acc) e2
          | _ -> List.rev info_acc, expr
        in
        let info, expr = decompose_expr 0 [] expr in
        (* Make the new globals private if possible -- with exception that
       if it is a non-private macro, then the involved new globals should not be private *)
        let module NameSet = Krml.Idents.LidSet in
        let no_priv_names =
          if List.mem Krml.Common.Macro flags && not (List.mem Krml.Common.Private flags) then
            (object
               inherit [_] reduce
               method private zero = NameSet.empty
               method private plus = NameSet.union
               method! visit_EQualified _ name = NameSet.singleton name
            end)
              #visit_expr_w
              () expr
          else
            NameSet.empty
        in
        let make_decl (name, expr) =
          let flags =
            if NameSet.mem name no_priv_names then
              []
            else
              [ Krml.Common.Private ]
          in
          DGlobal (flags, name, n_cgs, expr.typ, expr)
        in
        List.map make_decl info @ [ DGlobal (flags, name, n_cgs, ty, expr) ]
    | decl -> [ decl ]
  in
  List.map (fun (name, decls) -> name, List.concat_map mapper decls) files

(* The elimination of single-field structs generates new types equations, which
   we need to substitute away. *)
let fixup_monomorphization_map map =
  (* Replace all occurences of lid, a struct that had a single field of type t,
     with t *)
  let replace =
    object (self)
      inherit [_] Krml.Ast.map

      method! visit_TQualified () lid =
        match Hashtbl.find_opt map lid with
        | Some (Krml.DataTypes.Eliminate t) -> self#visit_typ () t
        | _ -> TQualified lid
    end
  in
  (* Must convert the hashtbl keys to a list instead of a lazy sequence Seq,
     because this would result in modifying the hashtbl while accessing it. *)
  List.iter
    (fun ((lid, ts, cgs), v) ->
      let ts = List.map (replace#visit_typ ()) ts in
      Hashtbl.add Krml.MonomorphizationState.state (lid, ts, cgs) v)
    (List.of_seq (Hashtbl.to_seq Krml.MonomorphizationState.state))

(* Hoist comments to be attached to the nearest statement *)
let float_comments files =
  let comments = ref [] in
  let prepend c = comments := c :: !comments in
  let flush () =
    let r = List.rev !comments in
    comments := [];
    List.map (fun x -> CommentBefore x) r
  in
  let filter_meta meta =
    meta
    |> List.filter (function
         | CommentBefore c ->
             prepend c;
             false
         | _ -> true)
    |> List.filter (function
         | CommentAfter c ->
             prepend c;
             false
         | _ -> true)
  in
  (object (self)
     inherit [_] map as super

     method! visit_expr env e =
       let e = super#visit_expr env e in
       { e with meta = filter_meta e.meta }

     method private process_block e =
       let float_one e =
         let e = self#visit_expr_w () e in
         { e with meta = flush () }
       in
       match e.node with
       | ELet (b, e1, e2) ->
           let e1 = self#visit_expr_w () e1 in
           let e1 = { e1 with meta = filter_meta e1.meta } in
           let b = { b with meta = filter_meta b.meta } in
           let meta = flush () in
           { e with node = ELet (b, e1, self#process_block e2); meta }
       | ESequence es ->
           let es = List.map float_one es in
           { e with node = ESequence es; meta = filter_meta e.meta }
       | _ -> float_one e

     method! visit_EFor env b e1 e2 e3 e4 =
       let e4 = self#process_block e4 in
       EFor (b, self#visit_expr env e1, self#visit_expr env e2, self#visit_expr env e3, e4)

     method! visit_EWhile env e1 e2 =
       let e2 = self#process_block e2 in
       EWhile (self#visit_expr env e1, e2)

     method! visit_EIfThenElse env e1 e2 e3 =
       let e2 = self#process_block e2 in
       let e3 = self#process_block e3 in
       EIfThenElse (self#visit_expr env e1, e2, e3)

     method! visit_ESwitch env e bs =
       let bs = List.map (fun (c, e) -> c, self#process_block e) bs in
       ESwitch (self#visit_expr env e, bs)

     method! visit_DFunction _ cc flags n_cgs n t name bs e =
       DFunction (cc, flags, n_cgs, n, t, name, bs, self#process_block e)
  end)
    #visit_files
    () files

(* When krml is used with the F* frontend, all operations on signed integers
   must fit in the destination type -- no overflow allowed!

   When krml is used with the Rust frontend (here), overflow on signed integer
   types is UB, except for left-shift which *is* defined (provided the places we
   shift by do not exceed the width of the type, like in C).

   We rely on the invariant that for signed integer arithmetic, every
   subexpression may be as `int` as long as the representation is consistent
   (i.e. the sign-extended version of the original value).
   - add, mul, div: cannot overflow in Rust (panic)
   - right-shift: ok (sign-extension in practice even though
     implementation-defined)
   - left-shift: must cast to unsigned to avoid UB, then cast back to signed to
     clamp extra high bytes

   *)
let rewrite_signed_shifts files =
  let open Krml.Constant in
  (object (self)
     inherit [_] map as super

     method! visit_EApp env e es =
       match e.node, es with
       | EOp (BShiftL, TInt w), [ e1; e2 ] when is_signed w ->
           let unsigned_w = unsigned_of_signed w in
           (* No point in casting to uint16 or uint8: this will be promoted to
              `int` once in C, which AstToCStar defeats by casting to (uint32_t)
              -- we simply anticipate this fact and cast straight to uint32_t. *)
           let unsigned_w =
             match unsigned_w with
             | UInt8 | UInt16 -> UInt32
             | _ -> unsigned_w
           in
           let e1 = self#visit_expr env e1 in
           let e2 = self#visit_expr env e2 in
           (* Note that in C, casting to a signed type is implementation-defined
              (yay). We assume all implementations rely on two's complement. *)
           let e1_unsigned = with_type (TInt unsigned_w) (ECast (e1, TInt unsigned_w)) in
           let op_type = H.fold_arrow [ TInt unsigned_w; e2.typ ] (TInt unsigned_w) in
           let shift =
             with_type (TInt unsigned_w)
               (EApp (with_type op_type (EOp (BShiftL, TInt unsigned_w)), [ e1_unsigned; e2 ]))
           in
           ECast (shift, TInt w)
       | _ -> super#visit_EApp env e es
  end)
    #visit_files
    () files

(* Now that we have the allocation scheme of data types, we can eliminate the Eurydice_discriminant
   placeholder *)
let remove_discriminant_reads (map : Krml.DataTypes.map) files =
  let lookup_tag_lid lid =
    let open Krml.DataTypes in
    match Hashtbl.find (fst3 map) lid with
    | exception Not_found -> `Direct (* was compiled straight to an enum via AstOfLlbc *)
    | ToEnum -> `Direct
    | ToTaggedUnion branches | ToFlatTaggedUnion branches ->
        let tags = List.map (fun (cons, _) -> cons, None) branches in
        `TagField (Hashtbl.find (snd3 map) tags)
    | _ ->
        failwith "TODO: compile discriminant read for something that no longer has a discriminant"
  in
  (object (_self)
     inherit [_] map as super

     method! visit_expr (((), _) as env) e =
       match e with
       | [%cremepat {| Eurydice::discriminant<?, ?u>(?e) |}] -> (
           match lookup_tag_lid (H.assert_tlid e.typ) with
           | `Direct -> with_type u (ECast (e, u))
           | `TagField tag_lid ->
               with_type u (ECast (with_type (TQualified tag_lid) (EField (e, "tag")), u)))
       | _ -> super#visit_expr env e
  end)
    #visit_files
    () files


================================================
FILE: lib/Cleanup3.ml
================================================
(* Administrative cleanups that do not get checked. *)

(* CG-polymorphic external signatures generally cannot be implemented with C functions, and Eurydice
   expects those to be hand-written using macros. There is one exception, though:
   - all of the const generics appear in positions that would anyhow decay to pointers (e.g.,
     void f<N>(int x[N]) can be replaced by void f(int *x) -- it's the same in C)
   - the return type is unit -- the implementation doesn't need to receive the return type as an
     argument
*)

module B = Builtin
open Krml
open Ast

let decay_cg_externals =
  object (self)
    inherit [_] Krml.Ast.map as super

    (* Since we allocate new names, we reuse the C name allocation facility *)
    inherit Simplify.scope_helpers

    method! visit_file env f =
      current_file <- fst f;
      super#visit_file env f

    method! visit_TCgArray (env, under_external) t n =
      if under_external then
        raise Exit
      else
        super#visit_TCgArray (env, under_external) t n

    method! visit_TCgApp (env, under_external) t n =
      if under_external then
        raise Exit
      else
        super#visit_TCgApp (env, under_external) t n

    method! visit_DExternal (scope_env, _) cc flags n_cgs n name t hints =
      let t_ret, t_args = Helpers.flatten_arrow t in
      (* MSVC throws a tantrum if it receives a zero-sized array parameter,
         interpreting this as a stack allocation instead of an array type that
         ought to decay to pointer. *)
      let t_args =
        List.map
          (function
            | TArray (t, (_, "0")) -> TBuf (t, false)
            | t -> t)
          t_args
      in
      if t_ret = TUnit && n_cgs > 0 then
        let t_args =
          List.map
            (function
              | TCgArray (t, _) -> TBuf (t, false)
              | t -> t)
            t_args
        in
        try
          (* This throws and aborts if there are some const generics left. *)
          let t_args = List.map (self#visit_typ (scope_env, true)) t_args in

          (* We're good. Find the allocated C name for our declaration, and allocate a new C name for
             the extra declaration *)
          let c_name = Option.get (GlobalNames.lookup (fst scope_env) (name, Other)) in
          let new_name = fst name, snd name ^ "_" in
          self#record scope_env ~is_type:false ~is_external:true flags new_name;
          let new_c_name = Option.get (GlobalNames.lookup (fst scope_env) (new_name, Other)) in

          (* We build: #define <<c_name>>(x0, ..., xn, _ret_t) \
             <<new_c_name>>(x0, ..., xn) *)
          let prelude =
            (* Names of the arguments *)
            let names =
              if List.length hints = List.length t_args then
                hints
              else
                List.init (List.length t_args) (fun i -> KPrint.bsprintf "x_%d" i)
            in
            KPrint.bsprintf "#define %s(%s) %s(%s)" c_name
              (String.concat ", " (names @ [ "_ret_t" ]))
              new_c_name (String.concat ", " names)
          in
          DExternal
            ( cc,
              [ Common.Prologue prelude ] @ flags,
              0,
              n,
              new_name,
              Helpers.fold_arrow t_args t_ret,
              hints )
        with Exit -> DExternal (cc, flags, n_cgs, n, name, Helpers.fold_arrow t_args t_ret, hints)
      else
        DExternal (cc, flags, n_cgs, n, name, Helpers.fold_arrow t_args t_ret, hints)
  end

let build_cg_macros =
  object (self)
    inherit [_] Krml.Ast.reduce
    method private zero = Krml.Idents.LidSet.empty
    method private plus = Krml.Idents.LidSet.union

    method! visit_DExternal () _ _ n_cgs n name _ _ =
      if n > 0 || n_cgs > 0 then
        Krml.Idents.LidSet.singleton name
      else
        self#zero
  end

let distinguished_names =
  [
    (B.arr, [ TInt UInt8 ], [ CgConst (SizeT, "2") ]), ([ "Eurydice" ], "array_u8x2");
    (B.arr, [ TInt UInt8 ], [ CgConst (SizeT, "4") ]), ([ "Eurydice" ], "array_u8x4");
    (B.arr, [ TInt UInt8 ], [ CgConst (SizeT, "8") ]), ([ "Eurydice" ], "array_u8x8");
    (B.dst_ref_shared, [ TInt UInt8; TInt SizeT ], []), ([ "Eurydice" ], "borrow_slice_u8");
    (B.dst_ref_shared, [ TInt Int16; TInt SizeT ], []), ([ "Eurydice" ], "borrow_slice_i16");
    (B.dst_ref_mut, [ TInt UInt8; TInt SizeT ], []), ([ "Eurydice" ], "mut_borrow_slice_u8");
    (B.dst_ref_mut, [ TInt Int16; TInt SizeT ], []), ([ "Eurydice" ], "mut_borrow_slice_i16");
  ]

(*This identifies the decls which should be generated after monomorphism, but is already defined
 in eurydice_glue.h for implementing the builtin functions. The slices are for
 libcrux, specifically to be able to define the intrinsic function signatures *)
let is_builtin_lid lid =
  match lid with
  | [ "Prims" ], "string" (* used to pass the checker, defined in glue.h *) -> true
  | _ -> List.exists (fun (_, lid') -> lid' = lid) distinguished_names

let remove_builtin_decls files =
  let checker = function
    | DType (lid, _, _, _, _) when is_builtin_lid lid -> None
    | decl -> Some decl
  in
  List.map (fun (name, decls) -> name, List.filter_map checker decls) files

let also_skip_prefix_for_external_types (scope_env, _) =
  let open Krml in
  object (_self)
    inherit [_] iter as _super

    method! visit_TQualified () lid =
      if GlobalNames.lookup scope_env (lid, Type) = None && GlobalNames.skip_prefix lid then
        let target = GlobalNames.target_c_name ~attempt_shortening:true ~kind:Type lid in
        let actual = GlobalNames.extend scope_env scope_env false (lid, Type) target in
        if actual <> fst target then
          KPrint.bprintf "Warning! The skip_prefix options generate name conflicts\n"
  end


================================================
FILE: lib/LoadLlbc.ml
================================================
let load_file filename =
  match Charon.OfJson.crate_of_json_file filename with
  | Ok r -> r
  | Error e ->
      Printf.fprintf stderr
        "Error loading JSON. This is typically due to a discrepancy between charon-ml and charon. \
         See error below. (Search for \"failed on\"). \n\n\
         %s"
        e;
      exit 1


================================================
FILE: lib/Logging.ml
================================================
module StringSet = Set.Make (String)

type logging = None | All | Some of StringSet.t

let logging = ref None

let enable_logging (modules : string) =
  let modules = String.split_on_char ',' modules in
  if modules = [ "*" ] then
    logging := All
  else
    logging := Some (StringSet.of_list modules)

let has_logging m =
  match !logging with
  | None -> false
  | All -> true
  | Some s -> StringSet.mem m s

let dummy = Buffer.create 1

let log (type a) (m : string) (fmt : (a, Buffer.t, unit, unit) format4) =
  if has_logging m then
    Krml.KPrint.bfprintf stdout (fmt ^^ "\n")
  else
    Printf.ibprintf dummy fmt


================================================
FILE: lib/Options.ml
================================================
let log_level = ref ""
let config = ref ""
let comments = ref false
let fatal_errors = ref false
let keep_going = ref false
let no_const = ref false


================================================
FILE: lib/PreCleanup.ml
================================================
open Krml.Ast
module H = Krml.Helpers

(* All the transformations that need to happen in order for the program to type-check as valid Low*
   *)

let expr_of_constant (w, n) = with_type (TInt w) (EConstant (w, n))

let remove_array_eq =
  object
    inherit Krml.DeBruijn.map_counting_cg as super

    method! visit_expr (((n_cgs, n_binders) as env), _) e =
      match e with
      | [%cremepat {| core::array::equality::?impl::eq[#?n](#?..)<?t,?u>(?a1, ?a2) |}] ->
          let rec is_flat = function
            | TCgApp (TApp (lid, [ t ]), _) -> lid = Builtin.arr && is_flat t
            | TInt _ | TBool | TUnit -> true
            | _ -> false
          in
          assert (t = u);
          if is_flat t then
            let diff = n_binders - n_cgs in
            match impl with
            | "{core::cmp::PartialEq<[U; N]> for [T; N]}" ->
                with_type TBool
                  (EApp (Builtin.(expr_of_builtin_t ~cgs:(diff, [ n ]) array_eq [ t ]), [ a1; a2 ]))
            | "{core::cmp::PartialEq<&0 ([U])> for [T; N]}" ->
                let hd =
                  if !Options.no_const then
                    Builtin.array_eq_slice_mut
                  else
                    Builtin.array_eq_slice_shared
                in
                with_type TBool
                  (EApp (Builtin.(expr_of_builtin_t ~cgs:(diff, [ n ]) hd [ t ]), [ a1; a2 ]))
            | _ -> failwith ("unknown array eq impl: " ^ impl)
          else
            failwith "TODO: non-byteeq array comparison"
      | _ -> super#visit_expr (env, e.typ) e

    method! visit_DFunction _ cc flags n_cgs n t lid bs e =
      super#visit_DFunction (n_cgs, 0) cc flags n_cgs n t lid bs e
  end

let expression_of_cg (n_cgs, n_binders) (cg : cg) =
  match cg with
  | CgConst n -> H.mk_sizet (int_of_string (snd n))
  | CgVar var ->
      let diff = n_binders - n_cgs in
      with_type (TInt SizeT) (EBound (var + diff))

(* slice_to_array<&[T], [T; N], Error>(src) -> 
   let arr: Arr<T,N>; memcpy(arr.data, src.ptr, N); Ok arr 
   slice_to_ref_array<&[T], &[T;N], Error, len>(src) ->
   let arr: Arr<T,N>; memcpy(arr.data, src.ptr); slice_to_ref_array2<&[T], &[T;N], Error, len>(src, &arr)
   *)
let constness_of_slice_type t =
  match t with
  | TApp (lid, _) when lid = Builtin.dst_ref_shared -> true
  | TApp (lid, _) when lid = Builtin.dst_ref_mut -> false
  | _ -> assert false

let expand_slice_to_array =
  object (_self)
    inherit Krml.DeBruijn.map_counting_cg as super

    method! visit_expr ((count, _) as env) e =
      match e.node with
      | EApp
          ( {
              node =
                ETApp
                  ( { node = EQualified lid; _ },
                    _,
                    _,
                    [ _; (TCgApp (TApp (_, [ t ]), cg) as arr_t); _ ] );
              _;
            },
            es )
        when lid = Builtin.slice_to_array.name ->
          let src = Krml.KList.one es in
          let result_t = e.typ in
          (*let arr = .. *)
          let arr = with_type arr_t (EBound 0) in
          let src = Krml.DeBruijn.lift 1 src in
          let dst = with_type (TBuf (t, false)) (EField (arr, "data")) in
          let src = with_type (TBuf (t, constness_of_slice_type src.typ)) (EField (src, "ptr")) in
          let n = Krml.DeBruijn.lift 1 (expression_of_cg count cg) in
          let zero = H.zero SizeT in
          let memcpy = H.with_unit (EBufBlit (src, zero, dst, zero, n)) in
          (* let arr = any in {memcpy (src, slice); OK (arr);} *)
          with_type result_t
            (ELet
               ( H.fresh_binder "arr" arr_t,
                 H.any,
                 with_type result_t
                   (ESequence [ memcpy; with_type result_t (ECons ("Ok", [ arr ])) ]) ))
      | EApp
          ( {
              node =
                ETApp
                  ( { node = EQualified lid; _ },
                    cgs,
                    _,
                    [
                      slice_t;
                      (TBuf ((TCgApp (TApp (_, [ t ]), cg) as arr_t), _) as arr_ref_t);
                      err_t;
                    ] );
              _;
            },
            [ slice ] )
        when lid = Builtin.slice_to_ref_array.name ->
          (* allocate a Arr<T,C>, do memcpy and let the C macro do the choose and define the return
             or error value *)
          let const = constness_of_slice_type slice_t in
          let slice_to_ref_array2 = Builtin.(expr_of_builtin slice_to_ref_array2) in
          let ts = [ slice_t; arr_ref_t; err_t ] in
          let slice_to_ref_array2 =
            with_type
              (Krml.DeBruijn.subst_tn ts Builtin.slice_to_ref_array2.typ)
              (ETApp (slice_to_ref_array2, List.map (Krml.DeBruijn.lift 1) cgs, [], ts))
          in
          let arr = with_type arr_t (EBound 0) in
          let arr_ref = with_type arr_ref_t (EAddrOf arr) in
          let slice = Krml.DeBruijn.lift 1 slice in
          let dst = with_type (TBuf (t, true)) (EField (arr, "data")) in
          let src = with_type (TBuf (t, const)) (EField (slice, "ptr")) in
          let n = Krml.DeBruijn.lift 1 (expression_of_cg count cg) in
          (* let n = with_type (TInt SizeT) (EField (slice, "meta")) in *)
          let zero = H.zero SizeT in
          let memcpy = H.with_unit (EBufBlit (src, zero, dst, zero, n)) in
          with_type e.typ
            (ELet
               ( H.fresh_binder "arr" arr_t,
                 H.any,
                 with_type e.typ
                   (ESequence
                      [ memcpy; with_type e.typ (EApp (slice_to_ref_array2, [ slice; arr_ref ])) ])
               ))
      | _ -> super#visit_expr env e

    method! visit_DFunction _ cc flags n_cgs n t name bs e =
      super#visit_DFunction (n_cgs, 0) cc flags n_cgs n t name bs e
  end

(** Comes from [drop_unused] in Inlining.ml, we use it to remove the builtin function defined using
    abstract syntax when they are not used. Otherwise they will refer to the undefined Range type
    and fail the check *)

let builtin_func_lids = List.map lid_of_decl Builtin.builtin_defined_funcs

let drop_unused_builtin files =
  let open Krml in
  let open Krml.Common in
  let seen = Hashtbl.create 41 in

  let body_of_lid = Helpers.build_map files (fun map d -> Hashtbl.add map (lid_of_decl d) d) in

  let visitor =
    object (self)
      inherit [_] iter as super
      method! visit_EQualified (before, _) lid = self#discover before lid
      method! visit_TQualified before lid = self#discover before lid

      method! visit_TApp before lid ts =
        self#discover before lid;
        List.iter (self#visit_typ before) ts

      method private discover before lid =
        if not (Hashtbl.mem seen lid) then begin
          Hashtbl.add seen lid ();
          if Hashtbl.mem body_of_lid lid then
            ignore (super#visit_decl (lid :: before) (Hashtbl.find body_of_lid lid))
        end

      method! visit_decl _ d =
        let flags = flags_of_decl d in
        let lid = lid_of_decl d in
        if (not (List.exists (( = ) Private) flags)) && not (Drop.lid lid) then begin
          Hashtbl.add seen lid ();
          super#visit_decl [ lid ] d
        end
    end
  in
  visitor#visit_files [] files;
  Hashtbl.add seen ([ "LowStar"; "Ignore" ], "ignore") ();
  filter_decls
    (fun d ->
      let flags = flags_of_decl d in
      let lid = lid_of_decl d in
      if
        (List.exists (( = ) Private) flags || Drop.lid lid)
        && (not (Hashtbl.mem seen lid))
        && List.mem lid builtin_func_lids
      then
        None
      else
        Some d)
    files

let precleanup files =
  let files = remove_array_eq#visit_files (0, 0) files in
  let files = drop_unused_builtin files in
  let files = expand_slice_to_array#visit_files (0, 0) files in
  files

let merge files =
  let open Krml.Idents in
  let open Krml.PrintAst.Ops in
  let merge_decl lid d1 d2 =
    match d1, d2 with
    | _ when Krml.Idents.LidSet.mem lid Builtin.skip -> None
    | Some d1, None | None, Some d1 -> Some d1
    | None, None -> assert false
    | Some d1, Some d2 -> (
        let is_external = function
          | DExternal _ -> true
          | _ -> false
        in
        let check_equal () =
          if d1 <> d2 then begin
            Krml.KPrint.bprintf "%a is:\n%a\n\nVS\n\n%a\n" plid lid pdecl d1 pdecl d2;
            failwith "can't reconcile these two definitions"
          end
        in
        match d1, d2 with
        | DExternal _, d2 | d2, DExternal _ ->
            if is_external d2 then
              check_equal ();
            Some d2
        | _ ->
            check_equal ();
            Some d1)
  in
  let decl_map decls = LidMap.of_seq (List.to_seq (List.map (fun d -> lid_of_decl d, d) decls)) in
  let merge_decls decls1 decls2 = LidMap.merge merge_decl decls1 decls2 in
  let concat_filenames f1 f2 =
    if f1 = "" then
      f2
    else
      f1 ^ "_" ^ f2
  in
  let merge_files (f1, decls1) (f2, decls2) =
    concat_filenames f1 f2, merge_decls decls1 (decl_map decls2)
  in
  let f, decls = List.fold_left merge_files ("", LidMap.empty) files in
  let decls = List.map snd (List.of_seq (LidMap.to_seq decls)) in
  let decls = Bundles.topological_sort decls in
  f, decls


================================================
FILE: lib/Utf8.ml
================================================
let ascii_of_utf8_str (str : string) =
  let get_uchar_list (str : string) =
    let rec get_uchar_list acc idx =
      try
        let uchar = Uchar.utf_decode_uchar (String.get_utf_8_uchar str idx) in
        let char_len = Uchar.utf_8_byte_length uchar in
        get_uchar_list (uchar :: acc) (idx + char_len)
      with Invalid_argument _ -> List.rev acc
    in
    get_uchar_list [] 0
  in
  let uchar_list_to_ascii lst =
    let to_str uchar =
      if Uchar.is_char uchar then
        Uchar.to_char uchar |> Char.escaped
      else
        Printf.sprintf "\\u{%x}" @@ Uchar.to_int uchar
    in
    List.map to_str lst |> String.concat ""
  in
  get_uchar_list str |> uchar_list_to_ascii


================================================
FILE: lib/dune
================================================
(library
 (name eurydice)
 (libraries charon krml yaml)
 (preprocess
  (pps ppx_deriving.std cremepat)))

(env
 (_
  (flags
   (:standard -w @1-2@3-7@8..12@14..21@23..29-30@31..38-39-40-41@43@57))))


================================================
FILE: out/test-array/array.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "array.h"

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
static Eurydice_borrow_slice_u8
array_to_subslice_shared_d4(const Eurydice_arr_ec *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

uint8_t array_fun(Eurydice_dst_ref_shared_60 x)
{
  return
    array_to_subslice_shared_d4(&x.ptr[0U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)1U })).ptr[0U];
}

Eurydice_arr_ec array_init(void)
{
  return (KRML_CLITERAL(Eurydice_arr_ec){ .data = { 0U } });
}

array_Foo array_mk_foo(void)
{
  Eurydice_arr_a0 x = { .data = { 0U } };
  Eurydice_arr_a0 y;
  uint32_t repeat_expression[2U];
  for (uint32_t _i = 0U; _i < (size_t)2U; ++_i)
    repeat_expression[_i] = 1U;
  memcpy(y.data, repeat_expression, (size_t)2U * sizeof (uint32_t));
  return (KRML_CLITERAL(array_Foo){ .x = x, .y = y });
}

array_Foo array_mk_foo2(void)
{
  return array_mk_foo();
}

void array_mut_array(Eurydice_arr_a0 x)
{
  x.data[0U] = 1U;
}

void array_mut_foo(array_Foo f)
{
  f.x.data[0U] = 1U;
  Eurydice_arr_a0 copy = f.y;
  copy.data[0U] = 0U;
  EURYDICE_ASSERT(copy.data[0U] != 1U, "panic!");
}

/**
This function found in impl {core::ops::function::FnMut<(usize), u32> for array::mk_incr::closure<K>}
*/
/**
A monomorphic instance of array.mk_incr.call_mut_e2
with const generics
- K= 10
*/
uint32_t array_mk_incr_call_mut_e2_55(void **_, size_t tupled_args)
{
  size_t i = tupled_args;
  return (uint32_t)i;
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), u32> for array::mk_incr::closure<K>}
*/
/**
A monomorphic instance of array.mk_incr.call_once_b7
with const generics
- K= 10
*/
uint32_t array_mk_incr_call_once_b7_55(size_t _)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  return array_mk_incr_call_mut_e2_55(&lvalue, _);
}

/**
A monomorphic instance of array.mk_incr
with const generics
- K= 10
*/
Eurydice_arr_6c array_mk_incr_55(void)
{
  Eurydice_arr_6c arr_struct;
  KRML_MAYBE_FOR10(i,
    (size_t)0U,
    (size_t)10U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = array_mk_incr_call_mut_e2_55(&lvalue, i););
  return arr_struct;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), u32> for array::mk_incr2::closure<0, K>}
*/
/**
A monomorphic instance of array.mk_incr2.call_mut_eb
with const generics
- K= 10
*/
uint32_t array_mk_incr2_call_mut_eb_55(const uint32_t **_, size_t tupled_args)
{
  size_t i = tupled_args;
  return (uint32_t)i + _[0U][0U];
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), u32> for array::mk_incr2::closure<0, K>}
*/
/**
A monomorphic instance of array.mk_incr2.call_once_ad
with const generics
- K= 10
*/
uint32_t array_mk_incr2_call_once_ad_55(const uint32_t *_, size_t _0)
{
  return array_mk_incr2_call_mut_eb_55(&_, _0);
}

/**
A monomorphic instance of array.mk_incr2
with const generics
- K= 10
*/
Eurydice_arr_6c array_mk_incr2_55(void)
{
  uint32_t j = 1U;
  Eurydice_arr_6c arr_struct;
  KRML_MAYBE_FOR10(i,
    (size_t)0U,
    (size_t)10U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    const uint32_t *lvalue = &j;
    arr_struct.data[i] = array_mk_incr2_call_mut_eb_55(&lvalue, i););
  return arr_struct;
}

/**
This function found in impl {core::ops::function::FnMut<(u32), u16> for array::plus_one::closure<K>}
*/
/**
A monomorphic instance of array.plus_one.call_mut_8d
with const generics
- K= 1
*/
uint16_t array_plus_one_call_mut_8d_6c(void **_, uint32_t tupled_args)
{
  uint32_t x = tupled_args;
  return (uint16_t)(x + 1U);
}

/**
This function found in impl {core::ops::function::FnOnce<(u32), u16> for array::plus_one::closure<K>}
*/
/**
A monomorphic instance of array.plus_one.call_once_36
with const generics
- K= 1
*/
uint16_t array_plus_one_call_once_36_6c(uint32_t _)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  return array_plus_one_call_mut_8d_6c(&lvalue, _);
}

/**
A monomorphic instance of array.plus_one
with const generics
- K= 1
*/
Eurydice_arr_96 array_plus_one_6c(Eurydice_arr_d5 x)
{
  Eurydice_arr_96 arr_mapped_str;
  {
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_mapped_str.data[0U] = array_plus_one_call_mut_8d_6c(&lvalue, x.data[0U]);
  }
  return arr_mapped_str;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), usize> for array::nested_from_fn::closure::closure<0, K>}
*/
/**
A monomorphic instance of array.nested_from_fn.closure.call_mut_74
with const generics
- K= 4
*/
size_t array_nested_from_fn_closure_call_mut_74_23(const size_t **_, size_t tupled_args)
{
  size_t i = tupled_args;
  return i + _[0U][0U];
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), usize> for array::nested_from_fn::closure::closure<0, K>}
*/
/**
A monomorphic instance of array.nested_from_fn.closure.call_once_4d
with const generics
- K= 4
*/
size_t array_nested_from_fn_closure_call_once_4d_23(const size_t *_, size_t _0)
{
  return array_nested_from_fn_closure_call_mut_74_23(&_, _0);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [usize; K]> for array::nested_from_fn::closure<K>}
*/
/**
A monomorphic instance of array.nested_from_fn.call_mut_6c
with const generics
- K= 4
*/
Eurydice_arr_cc array_nested_from_fn_call_mut_6c_23(void **_, size_t tupled_args)
{
  size_t j = tupled_args;
  Eurydice_arr_cc arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    const size_t *lvalue = &j;
    arr_struct.data[i] = array_nested_from_fn_closure_call_mut_74_23(&lvalue, i););
  return arr_struct;
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), [usize; K]> for array::nested_from_fn::closure<K>}
*/
/**
A monomorphic instance of array.nested_from_fn.call_once_d9
with const generics
- K= 4
*/
Eurydice_arr_cc array_nested_from_fn_call_once_d9_23(size_t _)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  return array_nested_from_fn_call_mut_6c_23(&lvalue, _);
}

/**
A monomorphic instance of array.nested_from_fn
with const generics
- K= 4
*/
Eurydice_arr_89 array_nested_from_fn_23(void)
{
  Eurydice_arr_89 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = array_nested_from_fn_call_mut_6c_23(&lvalue, i););
  return arr_struct;
}

/**
A monomorphic instance of array.const_eq
with const generics
- K= 2
*/
bool array_const_eq_af(Eurydice_arr_a0 x, Eurydice_arr_a0 y)
{
  return Eurydice_array_eq((size_t)2U, &x, &y, uint32_t);
}

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

typedef struct const_uint16_t__x2_s
{
  const uint16_t *fst;
  const uint16_t *snd;
}
const_uint16_t__x2;

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

typedef struct const_bool__x2_s
{
  const bool *fst;
  const bool *snd;
}
const_bool__x2;

void array_main(void)
{
  /* XXX1 */
  array_Foo uu____0 = array_mk_foo2();
  Eurydice_arr_a0 x = uu____0.x;
  Eurydice_arr_a0 y = uu____0.y;
  uint32_t unsigned0 = 0U;
  array_mut_array(x);
  /* XXX2 */
  array_mut_foo((KRML_CLITERAL(array_Foo){ .x = x, .y = y }));
  /* XXX3
    XXX4 */
  const_uint32_t__x2 uu____1 = { .fst = x.data, .snd = &unsigned0 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  Eurydice_arr_6c a = array_mk_incr_55();
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue0 = 9U;
  const_uint32_t__x2 uu____2 = { .fst = &a.data[9U], .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  Eurydice_arr_6c a0 = array_mk_incr2_55();
  uint32_t expected = 10U;
  const_uint32_t__x2 uu____3 = { .fst = &a0.data[9U], .snd = &expected };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
  Eurydice_arr_96 a1 = array_plus_one_6c((KRML_CLITERAL(Eurydice_arr_d5){ .data = { 0U } }));
  /* original Rust expression is not an lvalue in C */
  uint16_t lvalue1 = 1U;
  const_uint16_t__x2 uu____4 = { .fst = a1.data, .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____4.fst[0U] == uu____4.snd[0U], "panic!");
  /* XXX5 */
  Eurydice_arr_89 a2 = array_nested_from_fn_23();
  /* original Rust expression is not an lvalue in C */
  size_t lvalue2 = (size_t)6U;
  const_size_t__x2 uu____5 = { .fst = &a2.data[3U].data[3U], .snd = &lvalue2 };
  EURYDICE_ASSERT(uu____5.fst[0U] == uu____5.snd[0U], "panic!");
  /* XXX6 */
  Eurydice_arr_a0 x0;
  uint32_t repeat_expression0[2U];
  for (uint32_t _i = 0U; _i < (size_t)2U; ++_i)
    repeat_expression0[_i] = 2U;
  memcpy(x0.data, repeat_expression0, (size_t)2U * sizeof (uint32_t));
  Eurydice_arr_a0 y0;
  uint32_t repeat_expression[2U];
  for (uint32_t _i = 0U; _i < (size_t)2U; ++_i)
    repeat_expression[_i] = 2U;
  memcpy(y0.data, repeat_expression, (size_t)2U * sizeof (uint32_t));
  bool b = array_const_eq_af(x0, y0);
  /* original Rust expression is not an lvalue in C */
  bool lvalue = true;
  const_bool__x2 uu____6 = { .fst = &b, .snd = &lvalue };
  EURYDICE_ASSERT(uu____6.fst[0U] == uu____6.snd[0U], "panic!");
}

void array_references(void)
{
  array_init();
}



================================================
FILE: out/test-array/array.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef array_H
#define array_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_a0_s { uint32_t data[2U]; } Eurydice_arr_a0;

typedef struct array_Foo_s
{
  Eurydice_arr_a0 x;
  Eurydice_arr_a0 y;
}
array_Foo;

extern bool
core_cmp_impls__core__cmp__PartialEq_u32__for_u32__eq(const uint32_t *x0, const uint32_t *x1);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_ec_s { uint8_t data[32U]; } Eurydice_arr_ec;

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_arr_ec, size_t

*/
typedef struct Eurydice_dst_ref_shared_60_s
{
  const Eurydice_arr_ec *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_60;

uint8_t array_fun(Eurydice_dst_ref_shared_60 x);

Eurydice_arr_ec array_init(void);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

array_Foo array_mk_foo(void);

array_Foo array_mk_foo2(void);

void array_mut_array(Eurydice_arr_a0 x);

void array_mut_foo(array_Foo f);

/**
This function found in impl {core::ops::function::FnMut<(usize), u32> for array::mk_incr::closure<K>}
*/
/**
A monomorphic instance of array.mk_incr.call_mut_e2
with const generics
- K= 10
*/
uint32_t array_mk_incr_call_mut_e2_55(void **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), u32> for array::mk_incr::closure<K>}
*/
/**
A monomorphic instance of array.mk_incr.call_once_b7
with const generics
- K= 10
*/
uint32_t array_mk_incr_call_once_b7_55(size_t _);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $10size_t
*/
typedef struct Eurydice_arr_6c_s { uint32_t data[10U]; } Eurydice_arr_6c;

/**
A monomorphic instance of array.mk_incr
with const generics
- K= 10
*/
Eurydice_arr_6c array_mk_incr_55(void);

/**
A monomorphic instance of array.mk_incr2.closure
with const generics
- $10size_t
*/
typedef const uint32_t *array_mk_incr2_closure_e4;

/**
This function found in impl {core::ops::function::FnMut<(usize), u32> for array::mk_incr2::closure<0, K>}
*/
/**
A monomorphic instance of array.mk_incr2.call_mut_eb
with const generics
- K= 10
*/
uint32_t array_mk_incr2_call_mut_eb_55(const uint32_t **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), u32> for array::mk_incr2::closure<0, K>}
*/
/**
A monomorphic instance of array.mk_incr2.call_once_ad
with const generics
- K= 10
*/
uint32_t array_mk_incr2_call_once_ad_55(const uint32_t *_, size_t _0);

/**
A monomorphic instance of array.mk_incr2
with const generics
- K= 10
*/
Eurydice_arr_6c array_mk_incr2_55(void);

/**
This function found in impl {core::ops::function::FnMut<(u32), u16> for array::plus_one::closure<K>}
*/
/**
A monomorphic instance of array.plus_one.call_mut_8d
with const generics
- K= 1
*/
uint16_t array_plus_one_call_mut_8d_6c(void **_, uint32_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(u32), u16> for array::plus_one::closure<K>}
*/
/**
A monomorphic instance of array.plus_one.call_once_36
with const generics
- K= 1
*/
uint16_t array_plus_one_call_once_36_6c(uint32_t _);

/**
A monomorphic instance of Eurydice.arr
with types uint16_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_96_s { uint16_t data[1U]; } Eurydice_arr_96;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_d5_s { uint32_t data[1U]; } Eurydice_arr_d5;

/**
A monomorphic instance of array.plus_one
with const generics
- K= 1
*/
Eurydice_arr_96 array_plus_one_6c(Eurydice_arr_d5 x);

/**
A monomorphic instance of array.nested_from_fn.closure.closure
with const generics
- $4size_t
*/
typedef const size_t *array_nested_from_fn_closure_closure_34;

/**
This function found in impl {core::ops::function::FnMut<(usize), usize> for array::nested_from_fn::closure::closure<0, K>}
*/
/**
A monomorphic instance of array.nested_from_fn.closure.call_mut_74
with const generics
- K= 4
*/
size_t array_nested_from_fn_closure_call_mut_74_23(const size_t **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), usize> for array::nested_from_fn::closure::closure<0, K>}
*/
/**
A monomorphic instance of array.nested_from_fn.closure.call_once_4d
with const generics
- K= 4
*/
size_t array_nested_from_fn_closure_call_once_4d_23(const size_t *_, size_t _0);

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cc_s { size_t data[4U]; } Eurydice_arr_cc;

/**
This function found in impl {core::ops::function::FnMut<(usize), [usize; K]> for array::nested_from_fn::closure<K>}
*/
/**
A monomorphic instance of array.nested_from_fn.call_mut_6c
with const generics
- K= 4
*/
Eurydice_arr_cc array_nested_from_fn_call_mut_6c_23(void **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), [usize; K]> for array::nested_from_fn::closure<K>}
*/
/**
A monomorphic instance of array.nested_from_fn.call_once_d9
with const generics
- K= 4
*/
Eurydice_arr_cc array_nested_from_fn_call_once_d9_23(size_t _);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_cc
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_89_s { Eurydice_arr_cc data[4U]; } Eurydice_arr_89;

/**
A monomorphic instance of array.nested_from_fn
with const generics
- K= 4
*/
Eurydice_arr_89 array_nested_from_fn_23(void);

/**
A monomorphic instance of array.const_eq
with const generics
- K= 2
*/
bool array_const_eq_af(Eurydice_arr_a0 x, Eurydice_arr_a0 y);

void array_main(void);

void array_references(void);

#define array_mk_incr_closure__core__marker__Destruct_for_array__mk_incr__closure_K___drop_in_place(x_0, x_1, _ret_t) array_mk_incr_closure__core__marker__Destruct_for_array__mk_incr__closure_K___drop_in_place_(x_0, x_1)

extern void
array_mk_incr_closure__core__marker__Destruct_for_array__mk_incr__closure_K___drop_in_place_(
  size_t x0,
  void **x1
);

#define array_nested_from_fn_closure__core__marker__Destruct_for_array__nested_from_fn__closure_K___drop_in_place(x_0, x_1, _ret_t) array_nested_from_fn_closure__core__marker__Destruct_for_array__nested_from_fn__closure_K___drop_in_place_(x_0, x_1)

extern void
array_nested_from_fn_closure__core__marker__Destruct_for_array__nested_from_fn__closure_K___drop_in_place_(
  size_t x0,
  void **x1
);

#define array_plus_one_closure__core__marker__Destruct_for_array__plus_one__closure_K___drop_in_place(x_0, x_1, _ret_t) array_plus_one_closure__core__marker__Destruct_for_array__plus_one__closure_K___drop_in_place_(x_0, x_1)

extern void
array_plus_one_closure__core__marker__Destruct_for_array__plus_one__closure_K___drop_in_place_(
  size_t x0,
  void **x1
);

#if defined(__cplusplus)
}
#endif

#define array_H_DEFINED
#endif /* array_H */


================================================
FILE: out/test-array2d/array2d.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "array2d.h"

bool array2d_f(Eurydice_arr_ac x)
{
  x.data[0U] = (KRML_CLITERAL(Eurydice_arr_a0){ .data = { 1U, 2U } });
  Eurydice_arr_ac
  y =
    {
      .data = {
        { .data = { 1U, 2U } },
        { .data = { 3U, 4U } },
        { .data = { 1U, 2U } },
        { .data = { 3U, 4U } }
      }
    };
  return Eurydice_array_eq((size_t)4U, &x, &y, Eurydice_arr_a0);
}

typedef struct const_bool__x2_s
{
  const bool *fst;
  const bool *snd;
}
const_bool__x2;

void array2d_main(void)
{
  Eurydice_arr_ac y;
  Eurydice_arr_a0 repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] = (KRML_CLITERAL(Eurydice_arr_a0){ .data = { 1U, 2U } }););
  memcpy(y.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_a0));
  y.data[1U] = (KRML_CLITERAL(Eurydice_arr_a0){ .data = { 3U, 4U } });
  y.data[3U] = (KRML_CLITERAL(Eurydice_arr_a0){ .data = { 3U, 4U } });
  bool actual = array2d_f(y);
  bool expected = true;
  const_bool__x2 uu____0 = { .fst = &actual, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-array2d/array2d.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef array2d_H
#define array2d_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern bool
core_cmp_impls__core__cmp__PartialEq_u32__for_u32__eq(const uint32_t *x0, const uint32_t *x1);

extern bool
core_cmp_impls__core__cmp__PartialEq_u32__for_u32__ne(const uint32_t *x0, const uint32_t *x1);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_a0_s { uint32_t data[2U]; } Eurydice_arr_a0;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_a0
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_ac_s { Eurydice_arr_a0 data[4U]; } Eurydice_arr_ac;

bool array2d_f(Eurydice_arr_ac x);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void array2d_main(void);

#if defined(__cplusplus)
}
#endif

#define array2d_H_DEFINED
#endif /* array2d_H */


================================================
FILE: out/test-castunsize/castunsize.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "castunsize.h"

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void castunsize_main1(void)
{
  castunsize_S_e9 x = { .foo = 0U, .my_data = { .data = { 0U } } };
  Eurydice_dst_ref_shared_8b x0 = { .ptr = (const castunsize_T *)&x, .meta = (size_t)4U };
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____0 = { .fst = &((const uint32_t *)x0.ptr->my_data)[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint32_t
with const generics
- N= 4
*/
static Eurydice_dst_ref_mut_0c array_to_slice_mut_32(Eurydice_arr_e5 *a)
{
  Eurydice_dst_ref_mut_0c lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

void castunsize_main3(void)
{
  Eurydice_dst_ref_mut_0c
  x =
    array_to_slice_mut_32(Eurydice_box_new((KRML_CLITERAL(Eurydice_arr_e5){ .data = { 0U } }),
        Eurydice_arr_e5,
        Eurydice_arr_e5 *));
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &x.ptr[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of castunsize.main2
with const generics
- K= 5
*/
void castunsize_main2_a5(void)
{
  castunsize_S_b9 x = { .foo = 0U, .my_data = { .data = { 0U } } };
  Eurydice_dst_ref_shared_8b x0 = { .ptr = (const castunsize_T *)&x, .meta = (size_t)5U };
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____0 = { .fst = &((const uint32_t *)x0.ptr->my_data)[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint32_t
with const generics
- N= 5
*/
static Eurydice_dst_ref_mut_0c array_to_slice_mut_d0(Eurydice_arr_fb *a)
{
  Eurydice_dst_ref_mut_0c lit;
  lit.ptr = a->data;
  lit.meta = (size_t)5U;
  return lit;
}

/**
A monomorphic instance of castunsize.main4
with const generics
- K= 5
*/
void castunsize_main4_a5(void)
{
  Eurydice_dst_ref_mut_0c
  x =
    array_to_slice_mut_d0(Eurydice_box_new((KRML_CLITERAL(Eurydice_arr_fb){ .data = { 0U } }),
        Eurydice_arr_fb,
        Eurydice_arr_fb *));
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &x.ptr[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void castunsize_main(void)
{
  castunsize_main1();
  castunsize_main2_a5();
  castunsize_main3();
  castunsize_main4_a5();
}



================================================
FILE: out/test-castunsize/castunsize.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef castunsize_H
#define castunsize_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

typedef struct castunsize_T_s
{
  uint32_t foo;
  uint32_t my_data[];
}
castunsize_T;

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_e5_s { uint32_t data[4U]; } Eurydice_arr_e5;

/**
A monomorphic instance of castunsize.S
with types Eurydice_arr_e5

*/
typedef struct castunsize_S_e9_s
{
  uint32_t foo;
  Eurydice_arr_e5 my_data;
}
castunsize_S_e9;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types castunsize_T, size_t

*/
typedef struct Eurydice_dst_ref_shared_8b_s
{
  const castunsize_T *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_8b;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0c_s
{
  const uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0c;

void castunsize_main1(void);

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_mut_0c_s
{
  uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_0c;

void castunsize_main3(void);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_fb_s { uint32_t data[5U]; } Eurydice_arr_fb;

/**
A monomorphic instance of castunsize.S
with types Eurydice_arr_fb

*/
typedef struct castunsize_S_b9_s
{
  uint32_t foo;
  Eurydice_arr_fb my_data;
}
castunsize_S_b9;

/**
A monomorphic instance of castunsize.main2
with const generics
- K= 5
*/
void castunsize_main2_a5(void);

/**
A monomorphic instance of castunsize.main4
with const generics
- K= 5
*/
void castunsize_main4_a5(void);

void castunsize_main(void);

#if defined(__cplusplus)
}
#endif

#define castunsize_H_DEFINED
#endif /* castunsize_H */


================================================
FILE: out/test-closure/closure.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "closure.h"

/**
This function found in impl {core::ops::function::FnMut<(usize), usize> for closure::f::closure::closure<0, 1>}
*/
size_t closure_f_closure_call_mut_8a(closure_f_closure_closure *_, size_t tupled_args)
{
  size_t j = tupled_args;
  return _->fst->data[0U] + _->snd[0U] + j;
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), usize> for closure::f::closure::closure<0, 1>}
*/
size_t closure_f_closure_call_once_b7(closure_f_closure_closure _, size_t _0)
{
  return closure_f_closure_call_mut_8a(&_, _0);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [usize; 1usize]> for closure::f::closure<0>}
*/
Eurydice_arr_58 closure_f_call_mut_82(const Eurydice_arr_58 **_, size_t tupled_args)
{
  size_t i0 = tupled_args;
  Eurydice_arr_58 arr_struct;
  {
    /* original Rust expression is not an lvalue in C */
    closure_f_closure_closure lvalue = { .fst = _[0U], .snd = &i0 };
    arr_struct.data[0U] = closure_f_closure_call_mut_8a(&lvalue, (size_t)0U);
  }
  return arr_struct;
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), [usize; 1usize]> for closure::f::closure<0>}
*/
Eurydice_arr_58 closure_f_call_once_86(const Eurydice_arr_58 *_, size_t _0)
{
  return closure_f_call_mut_82(&_, _0);
}

Eurydice_arr_2d closure_f(void)
{
  Eurydice_arr_58 s = { .data = { 0U } };
  Eurydice_arr_2d arr_struct;
  {
    /* original Rust expression is not an lvalue in C */
    const Eurydice_arr_58 *lvalue = &s;
    arr_struct.data[0U] = closure_f_call_mut_82(&lvalue, (size_t)0U);
  }
  Eurydice_arr_2d a = arr_struct;
  return a;
}

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

void closure_main(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_2d lvalue = closure_f();
  size_t actual = lvalue.data->data[0U];
  size_t expected = (size_t)0U;
  const_size_t__x2 uu____0 = { .fst = &actual, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-closure/closure.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef closure_H
#define closure_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

typedef struct Eurydice_arr_58_s Eurydice_arr_58;

typedef const Eurydice_arr_58 *closure_f_closure;

typedef struct closure_f_closure_closure_s
{
  const Eurydice_arr_58 *fst;
  const size_t *snd;
}
closure_f_closure_closure;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_58_s { size_t data[1U]; } Eurydice_arr_58;

/**
This function found in impl {core::ops::function::FnMut<(usize), usize> for closure::f::closure::closure<0, 1>}
*/
size_t closure_f_closure_call_mut_8a(closure_f_closure_closure *_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), usize> for closure::f::closure::closure<0, 1>}
*/
size_t closure_f_closure_call_once_b7(closure_f_closure_closure _, size_t _0);

/**
This function found in impl {core::ops::function::FnMut<(usize), [usize; 1usize]> for closure::f::closure<0>}
*/
Eurydice_arr_58 closure_f_call_mut_82(const Eurydice_arr_58 **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), [usize; 1usize]> for closure::f::closure<0>}
*/
Eurydice_arr_58 closure_f_call_once_86(const Eurydice_arr_58 *_, size_t _0);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_58
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_2d_s { Eurydice_arr_58 data[1U]; } Eurydice_arr_2d;

Eurydice_arr_2d closure_f(void);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void closure_main(void);

extern void
closure_f_closure_closure__core__marker__Destruct_for_closure__f__closure__closure_0__1___drop_in_place(
  closure_f_closure_closure *x0
);

extern void
closure_f_closure__core__marker__Destruct_for_closure__f__closure_0___drop_in_place(
  const Eurydice_arr_58 **x0
);

#if defined(__cplusplus)
}
#endif

#define closure_H_DEFINED
#endif /* closure_H */


================================================
FILE: out/test-closure_fn_cast/closure_fn_cast.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "closure_fn_cast.h"

/**
This function found in impl {core::ops::function::Fn<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_fd(void *const *_, int32_t tupled_args)
{
  int32_t x = tupled_args;
  return x + 42;
}

/**
This function found in impl {core::ops::function::FnMut<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_mut_68(void **state, int32_t args)
{
  return closure_fn_cast_main_call_fd(state, args);
}

/**
This function found in impl {core::ops::function::FnOnce<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_once_fd(int32_t _)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  return closure_fn_cast_main_call_mut_68(&lvalue, _);
}

int32_t closure_fn_cast_main_closure_as_fn(int32_t arg1)
{
  int32_t args = arg1;
  void *state = (void *)0U;
  return closure_fn_cast_main_call_once_fd(args);
}

void closure_fn_cast_main(void)
{
  int32_t (*f)(int32_t x0) = closure_fn_cast_main_closure_as_fn;
  KRML_HOST_IGNORE(f(1));
}



================================================
FILE: out/test-closure_fn_cast/closure_fn_cast.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef closure_fn_cast_H
#define closure_fn_cast_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
This function found in impl {core::ops::function::Fn<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_fd(void *const *_, int32_t tupled_args);

/**
This function found in impl {core::ops::function::FnMut<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_mut_68(void **state, int32_t args);

/**
This function found in impl {core::ops::function::FnOnce<(i32), i32> for closure_fn_cast::main::closure}
*/
int32_t closure_fn_cast_main_call_once_fd(int32_t _);

int32_t closure_fn_cast_main_closure_as_fn(int32_t arg1);

void closure_fn_cast_main(void);

extern void
closure_fn_cast_main_closure__core__marker__Destruct_for_closure_fn_cast__main__closure__drop_in_place(
  void **x0
);

#if defined(__cplusplus)
}
#endif

#define closure_fn_cast_H_DEFINED
#endif /* closure_fn_cast_H */


================================================
FILE: out/test-collision/collision.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "collision.h"

int32_t collision_collision(collision_Either a, collision_Direction b)
{
  int32_t x;
  if (a.tag == collision_Left0)
  {
    x = 1;
  }
  else
  {
    x = 2;
  }
  int32_t y;
  if (b.tag == collision_Left)
  {
    y = 3;
  }
  else if (b.tag == collision_Middle)
  {
    y = 0;
  }
  else
  {
    y = 4;
  }
  return x + y;
}

void collision_main(void)
{
  EURYDICE_ASSERT(collision_collision((
        KRML_CLITERAL(collision_Either){ .tag = collision_Left0, .val = { .case_Left = 10 } }
      ),
      (KRML_CLITERAL(collision_Direction){ .tag = collision_Right, .val = { .case_Right = 20ULL } }))
    > 0,
    "panic!");
}



================================================
FILE: out/test-collision/collision.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef collision_H
#define collision_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define collision_Left 0
#define collision_Middle 1
#define collision_Right 2

typedef uint8_t collision_Direction_tags;

typedef struct collision_Direction_s
{
  collision_Direction_tags tag;
  union {
    uint64_t case_Left;
    uint64_t case_Right;
  }
  val;
}
collision_Direction;

#define collision_Left0 0
#define collision_Right0 1

typedef uint8_t collision_Either_tags;

typedef struct collision_Either_s
{
  collision_Either_tags tag;
  union {
    int32_t case_Left;
    bool case_Right;
  }
  val;
}
collision_Either;

int32_t collision_collision(collision_Either a, collision_Direction b);

void collision_main(void);

#if defined(__cplusplus)
}
#endif

#define collision_H_DEFINED
#endif /* collision_H */


================================================
FILE: out/test-const_generics/const_generics.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "const_generics.h"

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_to_mut_21(Eurydice_array_u8x8 *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4
*/
static Eurydice_borrow_slice_u8 array_to_slice_shared_98(const Eurydice_array_u8x4 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_from_mut_5f(Eurydice_array_u8x8 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)8U - r });
}

/**
A monomorphic instance of const_generics.serialize
with const generics
- OUT_LEN= 8
*/
Eurydice_array_u8x8 const_generics_serialize_70(Eurydice_dst_ref_shared_0c re)
{
  Eurydice_array_u8x8 out = { .data = { 0U } };
  Eurydice_mut_borrow_slice_u8 uu____0 = array_to_subslice_to_mut_21(&out, (size_t)4U);
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue0 = core_num__u32__to_be_bytes(re.ptr[0U]);
  Eurydice_slice_copy(uu____0, array_to_slice_shared_98(&lvalue0), uint8_t);
  Eurydice_mut_borrow_slice_u8 uu____1 = array_to_subslice_from_mut_5f(&out, (size_t)4U);
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue = core_num__u32__to_be_bytes(re.ptr[1U]);
  Eurydice_slice_copy(uu____1, array_to_slice_shared_98(&lvalue), uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint32_t
with const generics
- N= 2
*/
static Eurydice_dst_ref_shared_0c array_to_slice_shared_49(const Eurydice_arr_a0 *a)
{
  Eurydice_dst_ref_shared_0c lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2U;
  return lit;
}

void const_generics_main(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_a0 lvalue = { .data = { 1U, 2U } };
  Eurydice_array_u8x8 s = const_generics_serialize_70(array_to_slice_shared_49(&lvalue));
  EURYDICE_ASSERT(s.data[3U] == 1U, "panic!");
  EURYDICE_ASSERT(s.data[7U] == 2U, "panic!");
}

/**
A monomorphic instance of const_generics.mk_pairs
with types uint32_t, uint64_t
with const generics
- N= 2
- M= 4
*/
const_generics_Pair_30 const_generics_mk_pairs_67(uint32_t x, uint64_t y)
{
  Eurydice_arr_a0 a1;
  uint32_t repeat_expression0[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression0[i] = x;);
  memcpy(a1.data, repeat_expression0, (size_t)2U * sizeof (uint32_t));
  Eurydice_arr_e4 a2;
  uint64_t repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = y;);
  memcpy(a2.data, repeat_expression, (size_t)4U * sizeof (uint64_t));
  const_generics_Pair_67 p1 = { .left = a1, .right = a2 };
  const_generics_Pair_54 p2 = { .left = a2, .right = a1 };
  return (KRML_CLITERAL(const_generics_Pair_30){ .left = p1.left, .right = p2.right });
}

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void const_generics_main1(void)
{
  const_generics_Pair_30 uu____0 = const_generics_mk_pairs_67(0U, 0ULL);
  Eurydice_arr_a0 left = uu____0.left;
  Eurydice_arr_a0 right = uu____0.right;
  uint32_t expected = 0U;
  const_uint32_t__x2 uu____1 = { .fst = left.data, .snd = &expected };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  const_uint32_t__x2 uu____2 = { .fst = &left.data[1U], .snd = &expected };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  const_uint32_t__x2 uu____3 = { .fst = right.data, .snd = &expected };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
  const_uint32_t__x2 uu____4 = { .fst = &right.data[1U], .snd = &expected };
  EURYDICE_ASSERT(uu____4.fst[0U] == uu____4.snd[0U], "panic!");
}

/**
A monomorphic instance of const_generics.f
with const generics
- FOO= 1
- BAR= 2
*/
bool const_generics_f_06(uint32_t x, size_t y)
{
  Eurydice_arr_d5 arr1;
  uint32_t repeat_expression0[1U];
  {
    repeat_expression0[0U] = x;
  }
  memcpy(arr1.data, repeat_expression0, (size_t)1U * sizeof (uint32_t));
  Eurydice_arr_58 arr2;
  size_t repeat_expression[1U];
  {
    repeat_expression[0U] = y;
  }
  memcpy(arr2.data, repeat_expression, (size_t)1U * sizeof (size_t));
  bool uu____0;
  if (arr1.data[0U] == 2U)
  {
    uu____0 = arr2.data[0U] == (size_t)1U;
  }
  else
  {
    uu____0 = false;
  }
  return uu____0;
}

/**
A monomorphic instance of const_generics.f
with const generics
- FOO= 3
- BAR= 4
*/
bool const_generics_f_16(uint32_t x, size_t y)
{
  Eurydice_arr_a5 arr1;
  uint32_t repeat_expression0[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression0[i] = x;);
  memcpy(arr1.data, repeat_expression0, (size_t)3U * sizeof (uint32_t));
  Eurydice_arr_eb arr2;
  size_t repeat_expression[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = y;);
  memcpy(arr2.data, repeat_expression, (size_t)3U * sizeof (size_t));
  bool uu____0;
  if (arr1.data[0U] == 4U)
  {
    uu____0 = arr2.data[0U] == (size_t)3U;
  }
  else
  {
    uu____0 = false;
  }
  return uu____0;
}

/**
A monomorphic instance of const_generics.g
with const generics
- BAR= 3
- FOO= 4
*/
bool const_generics_g_16(uint32_t x, size_t y)
{
  bool uu____0;
  if (const_generics_f_16(x, y))
  {
    if (x == 4U)
    {
      uu____0 = y == (size_t)3U;
    }
    else
    {
      uu____0 = false;
    }
  }
  else
  {
    uu____0 = false;
  }
  return uu____0;
}

typedef struct const_bool__x2_s
{
  const bool *fst;
  const bool *snd;
}
const_bool__x2;

void const_generics_main3(void)
{
  bool x;
  if (const_generics_f_06(0U, (size_t)0U))
  {
    x = const_generics_g_16(0U, (size_t)0U);
  }
  else
  {
    x = false;
  }
  bool expected = false;
  const_bool__x2 uu____0 = { .fst = &x, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-const_generics/const_generics.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef const_generics_H
#define const_generics_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

static inline Eurydice_array_u8x4 core_num__u32__to_be_bytes(uint32_t x0);

/**
A monomorphic instance of core.ops.range.RangeTo
with types size_t

*/
typedef size_t core_ops_range_RangeTo_87;

/**
A monomorphic instance of core.ops.range.RangeFrom
with types size_t

*/
typedef size_t core_ops_range_RangeFrom_87;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0c_s
{
  const uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0c;

/**
A monomorphic instance of const_generics.serialize
with const generics
- OUT_LEN= 8
*/
Eurydice_array_u8x8 const_generics_serialize_70(Eurydice_dst_ref_shared_0c re);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_a0_s { uint32_t data[2U]; } Eurydice_arr_a0;

void const_generics_main(void);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of const_generics.Pair
with types uint32_t, uint32_t
with const generics
- $2size_t
- $2size_t
*/
typedef struct const_generics_Pair_30_s
{
  Eurydice_arr_a0 left;
  Eurydice_arr_a0 right;
}
const_generics_Pair_30;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_e4_s { uint64_t data[4U]; } Eurydice_arr_e4;

/**
A monomorphic instance of const_generics.Pair
with types uint32_t, uint64_t
with const generics
- $2size_t
- $4size_t
*/
typedef struct const_generics_Pair_67_s
{
  Eurydice_arr_a0 left;
  Eurydice_arr_e4 right;
}
const_generics_Pair_67;

/**
A monomorphic instance of const_generics.Pair
with types uint64_t, uint32_t
with const generics
- $4size_t
- $2size_t
*/
typedef struct const_generics_Pair_54_s
{
  Eurydice_arr_e4 left;
  Eurydice_arr_a0 right;
}
const_generics_Pair_54;

/**
A monomorphic instance of const_generics.mk_pairs
with types uint32_t, uint64_t
with const generics
- N= 2
- M= 4
*/
const_generics_Pair_30 const_generics_mk_pairs_67(uint32_t x, uint64_t y);

void const_generics_main1(void);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_d5_s { uint32_t data[1U]; } Eurydice_arr_d5;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_58_s { size_t data[1U]; } Eurydice_arr_58;

/**
A monomorphic instance of const_generics.f
with const generics
- FOO= 1
- BAR= 2
*/
bool const_generics_f_06(uint32_t x, size_t y);

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_a5_s { uint32_t data[3U]; } Eurydice_arr_a5;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_eb_s { size_t data[3U]; } Eurydice_arr_eb;

/**
A monomorphic instance of const_generics.f
with const generics
- FOO= 3
- BAR= 4
*/
bool const_generics_f_16(uint32_t x, size_t y);

/**
A monomorphic instance of const_generics.g
with const generics
- BAR= 3
- FOO= 4
*/
bool const_generics_g_16(uint32_t x, size_t y);

void const_generics_main3(void);

extern uint32_t core_clone_impls__core__clone__Clone_for_u32__clone(const uint32_t *x0);

extern uint64_t core_clone_impls__core__clone__Clone_for_u64__clone(const uint64_t *x0);

extern uint8_t core_clone_impls__core__clone__Clone_for_u8__clone(const uint8_t *x0);

#if defined(__cplusplus)
}
#endif

#define const_generics_H_DEFINED
#endif /* const_generics_H */


================================================
FILE: out/test-core_num/core_num.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "core_num.h"

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void core_num_main(void)
{
  uint32_t x = CORE_NUM__U32__BITS;
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 32U;
  const_uint32_t__x2 uu____0 = { .fst = &x, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-core_num/core_num.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef core_num_H
#define core_num_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

static inline uint32_t core_num__u32__count_ones(uint32_t x0);

#define CORE_NUM__U32__MAX (~0U)

#define CORE_NUM__U32__BITS (core_num__u32__count_ones(CORE_NUM__U32__MAX))

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void core_num_main(void);

#if defined(__cplusplus)
}
#endif

#define core_num_H_DEFINED
#endif /* core_num_H */


================================================
FILE: out/test-dst/dst.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "dst.h"

Eurydice_dst_ref_mut_2f dst_alloc(void)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_mut_2f){
        .ptr = (dst_T *)Eurydice_box_new((
            KRML_CLITERAL(dst_S_e9){ .foo = 0U, .my_data = { .data = { 0U } } }
          ),
          dst_S_e9,
          dst_S_e9 *),
        .meta = (size_t)4U
      }
    );
}

Eurydice_dst_ref_mut_bb dst_alloc3(void)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_mut_bb){
        .ptr = (dst_T3 *)Eurydice_box_new((
            KRML_CLITERAL(dst_S_93){
              .foo = 0U,
              .my_data = {
                .data = {
                  { .data = { 0U } },
                  { .data = { 0U } },
                  { .data = { 0U } },
                  { .data = { 0U } }
                }
              }
            }
          ),
          dst_S_93,
          dst_S_93 *),
        .meta = (size_t)4U
      }
    );
}

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void dst_check_regular_field(Eurydice_dst_ref_mut_2f x)
{
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &x.ptr->foo, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_check_regular_field_ref(Eurydice_dst_ref_shared_2f x)
{
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &x.ptr->foo, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_check_var_field(Eurydice_dst_ref_mut_2f x)
{
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____0 = { .fst = &((const uint32_t *)x.ptr->my_data)[0U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_check_var_field_ref(Eurydice_dst_ref_shared_2f x)
{
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____0 = { .fst = &((const uint32_t *)x.ptr->my_data)[0U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_check_var_field_ref3(Eurydice_dst_ref_shared_bb x)
{
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____0 = { .fst = ((const Eurydice_arr_a5 *)x.ptr->my_data)->data, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_main3(void)
{
  Eurydice_dst_ref_mut_bb x = dst_alloc3();
  const Eurydice_dst_ref_mut_bb *uu____0 = &x;
  dst_check_var_field_ref3((
      KRML_CLITERAL(Eurydice_dst_ref_shared_bb){ .ptr = uu____0->ptr, .meta = uu____0->meta }
    ));
}

Eurydice_dst_ref_mut_b7 dst_mk(void)
{
  dst_T2_e9 x = { .header = (size_t)0U, .my_data = { .data = { 0U } } };
  x.my_data.data[1U] = 2U;
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_mut_b7){
        .ptr = (dst_T2_be *)Eurydice_box_new(x, dst_T2_e9, dst_T2_e9 *),
        .meta = (size_t)4U
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint32_t
with const generics
- N= 4
*/
static Eurydice_dst_ref_mut_0c array_to_slice_mut_32(Eurydice_arr_e5 *a)
{
  Eurydice_dst_ref_mut_0c lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

void dst_main4(void)
{
  Eurydice_dst_ref_mut_0c
  x =
    array_to_slice_mut_32(Eurydice_box_new((KRML_CLITERAL(Eurydice_arr_e5){ .data = { 0U } }),
        Eurydice_arr_e5,
        Eurydice_arr_e5 *));
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &x.ptr[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void dst_main(void)
{
  dst_check_regular_field(dst_alloc());
  dst_check_var_field(dst_alloc());
  dst_S_e9 x = { .foo = 0U, .my_data = { .data = { 0U } } };
  Eurydice_dst_ref_shared_2f x0 = { .ptr = (const dst_T *)&x, .meta = (size_t)4U };
  dst_check_regular_field_ref(x0);
  dst_check_var_field_ref(x0);
  dst_main3();
  Eurydice_dst_ref_mut_b7 uu____0 = dst_mk();
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue0 = 0U;
  const_uint32_t__x2
  uu____1 = { .fst = &((const uint32_t *)uu____0.ptr->my_data)[0U], .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  Eurydice_dst_ref_mut_b7 uu____2 = dst_mk();
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 2U;
  const_uint32_t__x2
  uu____3 = { .fst = &((const uint32_t *)uu____2.ptr->my_data)[1U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
  dst_main4();
}



================================================
FILE: out/test-dst/dst.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef dst_H
#define dst_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

typedef struct dst_T_s
{
  uint32_t foo;
  uint32_t my_data[];
}
dst_T;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_a5_s { uint32_t data[3U]; } Eurydice_arr_a5;

typedef struct dst_T3_s
{
  uint32_t foo;
  Eurydice_arr_a5 my_data[];
}
dst_T3;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types dst_T, size_t

*/
typedef struct Eurydice_dst_ref_mut_2f_s
{
  dst_T *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_2f;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_e5_s { uint32_t data[4U]; } Eurydice_arr_e5;

/**
A monomorphic instance of dst.S
with types Eurydice_arr_e5

*/
typedef struct dst_S_e9_s
{
  uint32_t foo;
  Eurydice_arr_e5 my_data;
}
dst_S_e9;

Eurydice_dst_ref_mut_2f dst_alloc(void);

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types dst_T3, size_t

*/
typedef struct Eurydice_dst_ref_mut_bb_s
{
  dst_T3 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_bb;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_a5
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_53_s { Eurydice_arr_a5 data[4U]; } Eurydice_arr_53;

/**
A monomorphic instance of dst.S
with types Eurydice_arr_53

*/
typedef struct dst_S_93_s
{
  uint32_t foo;
  Eurydice_arr_53 my_data;
}
dst_S_93;

Eurydice_dst_ref_mut_bb dst_alloc3(void);

void dst_check_regular_field(Eurydice_dst_ref_mut_2f x);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types dst_T, size_t

*/
typedef struct Eurydice_dst_ref_shared_2f_s
{
  const dst_T *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_2f;

void dst_check_regular_field_ref(Eurydice_dst_ref_shared_2f x);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0c_s
{
  const uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0c;

void dst_check_var_field(Eurydice_dst_ref_mut_2f x);

void dst_check_var_field_ref(Eurydice_dst_ref_shared_2f x);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types dst_T3, size_t

*/
typedef struct Eurydice_dst_ref_shared_bb_s
{
  const dst_T3 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_bb;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_arr_a5, size_t

*/
typedef struct Eurydice_dst_ref_shared_d3_s
{
  const Eurydice_arr_a5 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_d3;

void dst_check_var_field_ref3(Eurydice_dst_ref_shared_bb x);

void dst_main3(void);

typedef struct dst_T2_be_s dst_T2_be;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types dst_T2_be, size_t

*/
typedef struct Eurydice_dst_ref_mut_b7_s
{
  dst_T2_be *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_b7;

/**
A monomorphic instance of dst.T2
with types Eurydice_arr_e5

*/
typedef struct dst_T2_e9_s
{
  size_t header;
  Eurydice_arr_e5 my_data;
}
dst_T2_e9;

Eurydice_dst_ref_mut_b7 dst_mk(void);

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_mut_0c_s
{
  uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_0c;

void dst_main4(void);

/**
A monomorphic instance of dst.T2
with types Eurydice_derefed_slice uint32_t

*/
typedef struct dst_T2_be_s
{
  size_t header;
  uint32_t my_data[];
}
dst_T2_be;

void dst_main(void);

#if defined(__cplusplus)
}
#endif

#define dst_H_DEFINED
#endif /* dst_H */


================================================
FILE: out/test-dyn_trait_struct_type/dyn_trait_struct_type.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "dyn_trait_struct_type.h"

void dyn_trait_struct_type_main(void)
{

}

void dyn_trait_struct_type_use_trait(Eurydice_dst_ref_shared_06 t)
{
  Eurydice_dst_ref_shared_06 uu____0 = t;
  uu____0.meta->method_method(uu____0);
}



================================================
FILE: out/test-dyn_trait_struct_type/dyn_trait_struct_type.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef dyn_trait_struct_type_H
#define dyn_trait_struct_type_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

typedef struct core_marker_MetaSized__vtable__s core_marker_MetaSized__vtable_;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_c_void_t,  core_marker_MetaSized_{vtable}*

*/
typedef struct Eurydice_dst_ref_mut_05_s
{
  Eurydice_c_void_t *ptr;
  core_marker_MetaSized__vtable_ *meta;
}
Eurydice_dst_ref_mut_05;

typedef struct core_marker_MetaSized__vtable__s
{
  size_t size;
  size_t align;
  void (*drop)(Eurydice_dst_ref_mut_05 x0);
}
core_marker_MetaSized__vtable_;

void dyn_trait_struct_type_main(void);

typedef struct dyn_trait_struct_type_Trait__vtable__s dyn_trait_struct_type_Trait__vtable_;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_c_void_t,  dyn_trait_struct_type_Trait_{vtable}*

*/
typedef struct Eurydice_dst_ref_mut_06_s
{
  Eurydice_c_void_t *ptr;
  dyn_trait_struct_type_Trait__vtable_ *meta;
}
Eurydice_dst_ref_mut_06;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_c_void_t,  dyn_trait_struct_type_Trait_{vtable}*

*/
typedef struct Eurydice_dst_ref_shared_06_s
{
  const Eurydice_c_void_t *ptr;
  dyn_trait_struct_type_Trait__vtable_ *meta;
}
Eurydice_dst_ref_shared_06;

typedef struct dyn_trait_struct_type_Trait__vtable__s
{
  size_t size;
  size_t align;
  void (*drop)(Eurydice_dst_ref_mut_06 x0);
  void (*method_method)(Eurydice_dst_ref_shared_06 x0);
  const core_marker_MetaSized__vtable_ *super_trait_0;
}
dyn_trait_struct_type_Trait__vtable_;

void dyn_trait_struct_type_use_trait(Eurydice_dst_ref_shared_06 t);

#if defined(__cplusplus)
}
#endif

#define dyn_trait_struct_type_H_DEFINED
#endif /* dyn_trait_struct_type_H */


================================================
FILE: out/test-floating_points/floating_points.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "floating_points.h"

typedef struct const_float32_t__x2_s
{
  const float32_t *fst;
  const float32_t *snd;
}
const_float32_t__x2;

typedef struct const_float64_t__x2_s
{
  const float64_t *fst;
  const float64_t *snd;
}
const_float64_t__x2;

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

void floating_points_main(void)
{
  float32_t f = (float32_t)1;
  Eurydice_arr_fe arr;
  float32_t repeat_expression0[100U];
  for (size_t i = (size_t)0U; i < (size_t)100U; i++)
  {
    repeat_expression0[i] = f;
  }
  memcpy(arr.data, repeat_expression0, (size_t)100U * sizeof (float32_t));
  float64_t d = (float64_t)1;
  Eurydice_arr_9f arr2;
  float64_t repeat_expression[100U];
  for (size_t i = (size_t)0U; i < (size_t)100U; i++)
  {
    repeat_expression[i] = d;
  }
  memcpy(arr2.data, repeat_expression, (size_t)100U * sizeof (float64_t));
  /* original Rust expression is not an lvalue in C */
  float32_t lvalue0 = (float32_t)1;
  const_float32_t__x2 uu____0 = { .fst = arr.data, .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  float64_t lvalue1 = (float64_t)1;
  const_float64_t__x2 uu____1 = { .fst = arr2.data, .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  size_t lvalue2 = (size_t)100U;
  /* original Rust expression is not an lvalue in C */
  size_t lvalue3 = (size_t)100U;
  const_size_t__x2 uu____2 = { .fst = &lvalue2, .snd = &lvalue3 };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  size_t lvalue4 = (size_t)100U;
  /* original Rust expression is not an lvalue in C */
  size_t lvalue = (size_t)100U;
  const_size_t__x2 uu____3 = { .fst = &lvalue4, .snd = &lvalue };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
}



================================================
FILE: out/test-floating_points/floating_points.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef floating_points_H
#define floating_points_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of Eurydice.arr
with types float32_t
with const generics
- $100size_t
*/
typedef struct Eurydice_arr_fe_s { float32_t data[100U]; } Eurydice_arr_fe;

/**
A monomorphic instance of Eurydice.arr
with types float64_t
with const generics
- $100size_t
*/
typedef struct Eurydice_arr_9f_s { float64_t data[100U]; } Eurydice_arr_9f;

void floating_points_main(void);

#if defined(__cplusplus)
}
#endif

#define floating_points_H_DEFINED
#endif /* floating_points_H */


================================================
FILE: out/test-fn_cast/fn_cast.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "fn_cast.h"

/**
A monomorphic instance of fn_cast.applies
with types int32_t, int32_t

*/
const int32_t *fn_cast_applies_99(const int32_t *(*f)(const int32_t *x0), const int32_t *arg)
{
  return f(arg);
}

/**
A monomorphic instance of fn_cast.id_ref
with types int32_t

*/
const int32_t *fn_cast_id_ref_a8(const int32_t *x)
{
  return x;
}

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

void fn_cast_main(void)
{
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue0 = 1;
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue = 1;
  const_int32_t__x2
  uu____0 =
    {
      .fst = fn_cast_applies_99((const int32_t *(*)(const int32_t *x0))fn_cast_id_ref_a8, &lvalue0),
      .snd = &lvalue
    };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-fn_cast/fn_cast.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef fn_cast_H
#define fn_cast_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of fn_cast.applies
with types int32_t, int32_t

*/
const int32_t *fn_cast_applies_99(const int32_t *(*f)(const int32_t *x0), const int32_t *arg);

/**
A monomorphic instance of fn_cast.id_ref
with types int32_t

*/
const int32_t *fn_cast_id_ref_a8(const int32_t *x);

void fn_cast_main(void);

#if defined(__cplusplus)
}
#endif

#define fn_cast_H_DEFINED
#endif /* fn_cast_H */


================================================
FILE: out/test-fn_higher_order/fn_higher_order.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "fn_higher_order.h"

int32_t fn_higher_order_empty_ptr(int32_t (*f)(void))
{
  return f();
}

int32_t fn_higher_order_more_sum_lst(const Eurydice_arr_bf *l)
{
  int32_t sum = 0;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    sum += l->data[i0];);
  return sum;
}

/**
A monomorphic instance of fn_higher_order.compose_cg_apply
with types size_t, size_t, size_t
with const generics
- N= 5
*/
size_t
fn_higher_order_compose_cg_apply_4d(
  size_t (*f)(const Eurydice_arr_2b *x0),
  size_t (*g)(size_t x0),
  const Eurydice_arr_2b *arg
)
{
  size_t (*uu____0)(size_t x0) = g;
  return uu____0(f(arg));
}

/**
A monomorphic instance of fn_higher_order.sum_lst
with const generics
- N= 5
*/
size_t fn_higher_order_sum_lst_a5(const Eurydice_arr_2b *lst)
{
  size_t sum = (size_t)0U;
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i0 = i;
    sum += lst->data[i0];);
  return sum + (size_t)5U;
}

/**
A monomorphic instance of fn_higher_order.id
with types size_t

*/
size_t fn_higher_order_id_60(size_t r)
{
  return r;
}

/**
A monomorphic instance of fn_higher_order.compose_cg_apply
with types int32_t, int32_t, int32_t
with const generics
- N= 3
*/
int32_t
fn_higher_order_compose_cg_apply_36(
  int32_t (*f)(const Eurydice_arr_bf *x0),
  int32_t (*g)(int32_t x0),
  const Eurydice_arr_bf *arg
)
{
  int32_t (*uu____0)(int32_t x0) = g;
  return uu____0(f(arg));
}

/**
A monomorphic instance of fn_higher_order.id
with types int32_t

*/
int32_t fn_higher_order_id_a8(int32_t r)
{
  return r;
}

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

void fn_higher_order_use_compose_cg(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_2b
  lvalue0 = { .data = { (size_t)1U, (size_t)2U, (size_t)3U, (size_t)4U, (size_t)5U } };
  size_t
  x =
    fn_higher_order_compose_cg_apply_4d(fn_higher_order_sum_lst_a5,
      fn_higher_order_id_60,
      &lvalue0);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_bf lvalue1 = { .data = { 10, 11, 12 } };
  int32_t
  y =
    fn_higher_order_compose_cg_apply_36(fn_higher_order_more_sum_lst,
      fn_higher_order_id_a8,
      &lvalue1);
  /* original Rust expression is not an lvalue in C */
  size_t lvalue = (size_t)20U;
  const_size_t__x2 uu____0 = { .fst = &x, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue2 = 33;
  const_int32_t__x2 uu____1 = { .fst = &y, .snd = &lvalue2 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}

void fn_higher_order_main(void)
{
  fn_higher_order_use_compose_cg();
}

void fn_higher_order_unit_empty_ptr(void (*f)(void))
{
  f();
}



================================================
FILE: out/test-fn_higher_order/fn_higher_order.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef fn_higher_order_H
#define fn_higher_order_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern int32_t core_clone_impls__core__clone__Clone_for_i32__clone(const int32_t *x0);

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern bool
core_cmp_impls__core__cmp__PartialEq_usize__for_usize__eq(const size_t *x0, const size_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_usize__for_usize__partial_cmp(
  const size_t *x0,
  const size_t *x1
);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__backward_checked(size_t x0, size_t x1);

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__forward_checked(size_t x0, size_t x1);

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_usize__steps_between(
  const size_t *x0,
  const size_t *x1
);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

int32_t fn_higher_order_empty_ptr(int32_t (*f)(void));

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_bf_s { int32_t data[3U]; } Eurydice_arr_bf;

int32_t fn_higher_order_more_sum_lst(const Eurydice_arr_bf *l);

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_2b_s { size_t data[5U]; } Eurydice_arr_2b;

/**
A monomorphic instance of fn_higher_order.compose_cg_apply
with types size_t, size_t, size_t
with const generics
- N= 5
*/
size_t
fn_higher_order_compose_cg_apply_4d(
  size_t (*f)(const Eurydice_arr_2b *x0),
  size_t (*g)(size_t x0),
  const Eurydice_arr_2b *arg
);

/**
A monomorphic instance of fn_higher_order.sum_lst
with const generics
- N= 5
*/
size_t fn_higher_order_sum_lst_a5(const Eurydice_arr_2b *lst);

/**
A monomorphic instance of fn_higher_order.id
with types size_t

*/
size_t fn_higher_order_id_60(size_t r);

/**
A monomorphic instance of fn_higher_order.compose_cg_apply
with types int32_t, int32_t, int32_t
with const generics
- N= 3
*/
int32_t
fn_higher_order_compose_cg_apply_36(
  int32_t (*f)(const Eurydice_arr_bf *x0),
  int32_t (*g)(int32_t x0),
  const Eurydice_arr_bf *arg
);

/**
A monomorphic instance of fn_higher_order.id
with types int32_t

*/
int32_t fn_higher_order_id_a8(int32_t r);

void fn_higher_order_use_compose_cg(void);

void fn_higher_order_main(void);

void fn_higher_order_unit_empty_ptr(void (*f)(void));

#if defined(__cplusplus)
}
#endif

#define fn_higher_order_H_DEFINED
#endif /* fn_higher_order_H */


================================================
FILE: out/test-for/for.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "for.h"

void for_main(void)
{

}

uint8_t for_other(Eurydice_borrow_slice_u8 input)
{
  for (int32_t i = 0; i < 5; i++)
  {
    int32_t i0 = i;
    if (i0 == 2)
    {
      return 6U;
    }
  }
  return input.ptr[0U];
}



================================================
FILE: out/test-for/for.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef for_H
#define for_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern int32_t core_clone_impls__core__clone__Clone_for_i32__clone(const int32_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern bool
core_cmp_impls__core__cmp__PartialEq_i32__for_i32__eq(const int32_t *x0, const int32_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_i32__for_i32__partial_cmp(
  const int32_t *x0,
  const int32_t *x1
);

/**
A monomorphic instance of core.option.Option
with types int32_t

*/
typedef struct core_option_Option_9e_s
{
  core_option_Option_77_tags tag;
  int32_t f0;
}
core_option_Option_9e;

extern core_option_Option_9e
core_iter_range__core__iter__range__Step_for_i32__backward_checked(int32_t x0, size_t x1);

extern core_option_Option_9e
core_iter_range__core__iter__range__Step_for_i32__forward_checked(int32_t x0, size_t x1);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_i32__steps_between(
  const int32_t *x0,
  const int32_t *x1
);

void for_main(void);

uint8_t for_other(Eurydice_borrow_slice_u8 input);

#if defined(__cplusplus)
}
#endif

#define for_H_DEFINED
#endif /* for_H */


================================================
FILE: out/test-global_ref/global_ref.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "global_ref.h"

static void *C_VAL_local_0 = (void *)0U;

static void *const *C_VAL_local_1 = &C_VAL_local_0;

void *const *const *global_ref_C_VAL_local_2 = &C_VAL_local_1;

static int32_t S_VAL_local_0 = 0;

static const int32_t *S_VAL_local_1 = &S_VAL_local_0;

static const int32_t *const *S_VAL_local_2 = &S_VAL_local_1;

const int32_t *const *const *const global_ref_S_VAL = &S_VAL_local_2;

typedef struct const_____x2_s
{
  void *const *fst;
  void *const *snd;
}
const_____x2;

void global_ref_main(void)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  const_____x2 uu____0 = { .fst = GLOBAL_REF_C_VAL[0U][0U], .snd = &lvalue };
  EURYDICE_ASSERT(core_cmp_impls__core__cmp__PartialEq_____for_____eq(uu____0.fst, uu____0.snd),
    "panic!");
  EURYDICE_ASSERT(global_ref_S_VAL[0U][0U][0U] == 0, "panic!");
}



================================================
FILE: out/test-global_ref/global_ref.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef global_ref_H
#define global_ref_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern bool
core_cmp_impls__core__cmp__PartialEq_____for_____eq(void *const *x0, void *const *x1);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

extern void *const *const *global_ref_C_VAL_local_2;

#define GLOBAL_REF_C_VAL (&global_ref_C_VAL_local_2)

extern const int32_t *const *const *const global_ref_S_VAL;

void global_ref_main(void);

#if defined(__cplusplus)
}
#endif

#define global_ref_H_DEFINED
#endif /* global_ref_H */


================================================
FILE: out/test-i32_shl/i32_shl.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "i32_shl.h"

typedef struct const_int16_t__x2_s
{
  const int16_t *fst;
  const int16_t *snd;
}
const_int16_t__x2;

void i32_shl_main(void)
{
  int16_t x = (int16_t)((uint32_t)-1 << 8U);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue0 = -256;
  const_int16_t__x2 uu____0 = { .fst = &x, .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  int16_t y = (int16_t)((uint32_t)(-1 & (int16_t)65280U) << 8U) >> 8U;
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue = 0;
  const_int16_t__x2 uu____1 = { .fst = &y, .snd = &lvalue };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}



================================================
FILE: out/test-i32_shl/i32_shl.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef i32_shl_H
#define i32_shl_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void i32_shl_main(void);

#if defined(__cplusplus)
}
#endif

#define i32_shl_H_DEFINED
#endif /* i32_shl_H */


================================================
FILE: out/test-inline_attributes/inline_attributes.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "inline_attributes.h"

inline uint32_t inline_attributes_f(void)
{
  return 1U;
}

KRML_NOINLINE uint32_t inline_attributes_g(void)
{
  return 2U;
}

KRML_MUSTINLINE uint32_t inline_attributes_h(void)
{
  return 3U;
}

void inline_attributes_main(void)
{
  inline_attributes_f();
  inline_attributes_g();
  inline_attributes_h();
}



================================================
FILE: out/test-inline_attributes/inline_attributes.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef inline_attributes_H
#define inline_attributes_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

uint32_t inline_attributes_f(void);

uint32_t inline_attributes_g(void);

uint32_t inline_attributes_h(void);

void inline_attributes_main(void);

#if defined(__cplusplus)
}
#endif

#define inline_attributes_H_DEFINED
#endif /* inline_attributes_H */


================================================
FILE: out/test-int_switch/int_switch.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "int_switch.h"

uint32_t int_switch_f(void)
{
  return 0U;
}

void int_switch_main(void)
{
  switch (int_switch_f())
  {
    case 0U:
      {
        break;
      }
    case 1U:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
}



================================================
FILE: out/test-int_switch/int_switch.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef int_switch_H
#define int_switch_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

uint32_t int_switch_f(void);

void int_switch_main(void);

#if defined(__cplusplus)
}
#endif

#define int_switch_H_DEFINED
#endif /* int_switch_H */


================================================
FILE: out/test-issue_102/issue_102.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_102.h"

void issue_102_main(void)
{

}



================================================
FILE: out/test-issue_102/issue_102.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_102_H
#define issue_102_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define issue_102_Error1_Reason1 1
#define issue_102_Error1_Reason2 2

typedef uint8_t issue_102_Error1;

#define issue_102_Error2_Reason1 3
#define issue_102_Error2_Reason2 4

typedef uint8_t issue_102_Error2;

void issue_102_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_102_H_DEFINED
#endif /* issue_102_H */


================================================
FILE: out/test-issue_104/issue_104.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_104.h"

/**
A monomorphic instance of issue_104.sth
with types issue_104_S
with const generics

*/
uint8_t issue_104_sth_50(void)
{
  return ISSUE_104__ISSUE_104__FUN_FOR_ISSUE_104__S__VAL;
}

uint8_t issue_104_call(void)
{
  return issue_104_sth_50();
}

typedef struct const_uint8_t__x2_s
{
  const uint8_t *fst;
  const uint8_t *snd;
}
const_uint8_t__x2;

void issue_104_main(void)
{
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue0 = issue_104_call();
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue = 5U;
  const_uint8_t__x2 uu____0 = { .fst = &lvalue0, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-issue_104/issue_104.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_104_H
#define issue_104_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

#define ISSUE_104__ISSUE_104__FUN_FOR_ISSUE_104__S__VAL (5U)

/**
A monomorphic instance of issue_104.sth
with types issue_104_S
with const generics

*/
uint8_t issue_104_sth_50(void);

uint8_t issue_104_call(void);

void issue_104_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_104_H_DEFINED
#endif /* issue_104_H */


================================================
FILE: out/test-issue_105/issue_105.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_105.h"

/**
This function found in impl {core::cmp::PartialEq<()> for ()}
*/
inline bool core_cmp_impls_eq_cf(void *const *self, void *const *_other)
{
  return true;
}

/**
This function found in impl {core::cmp::PartialEq<()> for ()}
*/
inline bool core_cmp_impls_ne_cf(void *const *self, void *const *_other)
{
  return false;
}

/**
This function found in impl {core::cmp::PartialEq<u8> for u8}
*/
inline bool core_cmp_impls_eq_c3(const uint8_t *self, const uint8_t *other)
{
  return self[0U] == other[0U];
}

/**
This function found in impl {core::cmp::PartialEq<u8> for u8}
*/
inline bool core_cmp_impls_ne_c3(const uint8_t *self, const uint8_t *other)
{
  return self[0U] != other[0U];
}

core_result_Result_1d issue_105_inner(void)
{
  return (KRML_CLITERAL(core_result_Result_1d){ .tag = core_result_Err, .f0 = 1U });
}

/**
This function found in impl {core::ops::try_trait::Try<T, core::result::Result<core::convert::Infallible, E>[core::marker::Sized<core::convert::Infallible>, TraitClause@1]> for core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.branch_71
with types (), uint8_t

*/
inline core_ops_control_flow_ControlFlow_19
core_result_branch_71_e9(core_result_Result_1d self)
{
  if (!(self.tag == core_result_Ok))
  {
    uint8_t e = self.f0;
    return
      (
        KRML_CLITERAL(core_ops_control_flow_ControlFlow_19){
          .tag = core_ops_control_flow_Break,
          .f0 = { .tag = core_result_Err, .val = { .case_Err = e } }
        }
      );
  }
  return
    (KRML_CLITERAL(core_ops_control_flow_ControlFlow_19){ .tag = core_ops_control_flow_Continue });
}

/**
This function found in impl {core::ops::try_trait::FromResidual<core::result::Result<core::convert::Infallible, E>[core::marker::Sized<core::convert::Infallible>, TraitClause@1]> for core::result::Result<T, F>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of core.result.from_residual_1f
with types (), uint8_t, uint8_t
with const generics

*/
inline core_result_Result_1d core_result_from_residual_1f_48(core_result_Result_8f residual)
{
  uint8_t e = residual.val.case_Err;
  return
    (
      KRML_CLITERAL(core_result_Result_1d){
        .tag = core_result_Err,
        .f0 = core_convert_from_61_90(e)
      }
    );
}

core_result_Result_1d issue_105_call_it(void)
{
  core_ops_control_flow_ControlFlow_19 uu____0 = core_result_branch_71_e9(issue_105_inner());
  if (!(uu____0.tag == core_ops_control_flow_Continue))
  {
    core_result_Result_8f residual = uu____0.f0;
    return core_result_from_residual_1f_48(residual);
  }
  return (KRML_CLITERAL(core_result_Result_1d){ .tag = core_result_Ok });
}

/**
This function found in impl {core::cmp::PartialEq<core::result::Result<T, E>[TraitClause@0, TraitClause@1]> for core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.eq_0b
with types (), uint8_t
with const generics

*/
inline bool
core_result_eq_0b_74(const core_result_Result_1d *self, const core_result_Result_1d *other)
{
  ptrdiff_t __self_discr = (ptrdiff_t)self->tag;
  ptrdiff_t __arg1_discr = (ptrdiff_t)other->tag;
  bool uu____0;
  if (__self_discr == __arg1_discr)
  {
    if (self->tag == core_result_Ok)
    {
      EURYDICE_ASSERT(!!((ptrdiff_t)other->tag == (ptrdiff_t)0), "assert failure");
      /* original Rust expression is not an lvalue in C */
      void *lvalue0 = (void *)0U;
      void *const *__self_0 = &lvalue0;
      /* original Rust expression is not an lvalue in C */
      void *lvalue = (void *)0U;
      void *const *__arg1_0 = &lvalue;
      uu____0 = core_cmp_impls_eq_cf(__self_0, __arg1_0);
    }
    else
    {
      EURYDICE_ASSERT(!!((ptrdiff_t)other->tag == (ptrdiff_t)1), "assert failure");
      const uint8_t *__self_0 = &self->f0;
      const uint8_t *__arg1_0 = &other->f0;
      uu____0 = core_cmp_impls_eq_c3(__self_0, __arg1_0);
    }
  }
  else
  {
    uu____0 = false;
  }
  return uu____0;
}

typedef struct const_core_result_Result_1d__x2_s
{
  const core_result_Result_1d *fst;
  const core_result_Result_1d *snd;
}
const_core_result_Result_1d__x2;

void issue_105_main(void)
{
  /* original Rust expression is not an lvalue in C */
  core_result_Result_1d lvalue0 = issue_105_call_it();
  /* original Rust expression is not an lvalue in C */
  core_result_Result_1d lvalue = { .tag = core_result_Err, .f0 = 1U };
  const_core_result_Result_1d__x2 uu____0 = { .fst = &lvalue0, .snd = &lvalue };
  EURYDICE_ASSERT(core_result_eq_0b_74(uu____0.fst, uu____0.snd), "panic!");
}



================================================
FILE: out/test-issue_105/issue_105.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_105_H
#define issue_105_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
This function found in impl {core::cmp::PartialEq<()> for ()}
*/
bool core_cmp_impls_eq_cf(void *const *self, void *const *_other);

/**
This function found in impl {core::cmp::PartialEq<()> for ()}
*/
bool core_cmp_impls_ne_cf(void *const *self, void *const *_other);

/**
This function found in impl {core::cmp::PartialEq<u8> for u8}
*/
bool core_cmp_impls_eq_c3(const uint8_t *self, const uint8_t *other);

/**
This function found in impl {core::cmp::PartialEq<u8> for u8}
*/
bool core_cmp_impls_ne_c3(const uint8_t *self, const uint8_t *other);



typedef uint8_t core_convert_Infallible;

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_1d_tags;

/**
A monomorphic instance of core.result.Result
with types (), uint8_t

*/
typedef struct core_result_Result_1d_s
{
  core_result_Result_1d_tags tag;
  uint8_t f0;
}
core_result_Result_1d;

core_result_Result_1d issue_105_inner(void);

/**
A monomorphic instance of core.result.Result
with types core_convert_Infallible, uint8_t

*/
typedef struct core_result_Result_8f_s
{
  core_result_Result_1d_tags tag;
  union {
    core_convert_Infallible case_Ok;
    uint8_t case_Err;
  }
  val;
}
core_result_Result_8f;

#define core_ops_control_flow_Continue 0
#define core_ops_control_flow_Break 1

typedef uint8_t core_ops_control_flow_ControlFlow_19_tags;

/**
A monomorphic instance of core.ops.control_flow.ControlFlow
with types core_result_Result_8f, ()

*/
typedef struct core_ops_control_flow_ControlFlow_19_s
{
  core_ops_control_flow_ControlFlow_19_tags tag;
  core_result_Result_8f f0;
}
core_ops_control_flow_ControlFlow_19;

/**
This function found in impl {core::ops::try_trait::Try<T, core::result::Result<core::convert::Infallible, E>[core::marker::Sized<core::convert::Infallible>, TraitClause@1]> for core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.branch_71
with types (), uint8_t

*/
core_ops_control_flow_ControlFlow_19 core_result_branch_71_e9(core_result_Result_1d self);

/**
 Returns the argument unchanged.
*/
/**
This function found in impl {core::convert::From<T> for T}
*/
/**
A monomorphic instance of core.convert.from_61
with types uint8_t

*/
static KRML_MUSTINLINE uint8_t core_convert_from_61_90(uint8_t t)
{
  return t;
}

/**
This function found in impl {core::ops::try_trait::FromResidual<core::result::Result<core::convert::Infallible, E>[core::marker::Sized<core::convert::Infallible>, TraitClause@1]> for core::result::Result<T, F>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of core.result.from_residual_1f
with types (), uint8_t, uint8_t
with const generics

*/
core_result_Result_1d core_result_from_residual_1f_48(core_result_Result_8f residual);

core_result_Result_1d issue_105_call_it(void);

/**
This function found in impl {core::cmp::PartialEq<core::result::Result<T, E>[TraitClause@0, TraitClause@1]> for core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.eq_0b
with types (), uint8_t
with const generics

*/
bool
core_result_eq_0b_74(const core_result_Result_1d *self, const core_result_Result_1d *other);

void issue_105_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_105_H_DEFINED
#endif /* issue_105_H */


================================================
FILE: out/test-issue_106/issue_106.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_106.h"

uint8_t issue_106_generate(void)
{
  return 5U;
}

void issue_106_main(void)
{

}

uint8_t issue_106_use_it(const uint8_t *x)
{
  return x[0U];
}

uint8_t issue_106_use_ref(void)
{
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue = issue_106_generate();
  return issue_106_use_it(&lvalue);
}



================================================
FILE: out/test-issue_106/issue_106.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_106_H
#define issue_106_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

typedef uint8_t issue_106_MyStruct;

uint8_t issue_106_generate(void);

void issue_106_main(void);

uint8_t issue_106_use_it(const uint8_t *x);

uint8_t issue_106_use_ref(void);

#if defined(__cplusplus)
}
#endif

#define issue_106_H_DEFINED
#endif /* issue_106_H */


================================================
FILE: out/test-issue_107/issue_107.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_107.h"

void issue_107_main(void)
{

}

/**
This function found in impl {issue_107::Fun for issue_107::MyStruct}
*/
uint8_t issue_107_f_90(void)
{
  return 5U;
}



================================================
FILE: out/test-issue_107/issue_107.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_107_H
#define issue_107_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

void issue_107_main(void);

/**
This function found in impl {issue_107::Fun for issue_107::MyStruct}
*/
uint8_t issue_107_f_90(void);

#if defined(__cplusplus)
}
#endif

#define issue_107_H_DEFINED
#endif /* issue_107_H */


================================================
FILE: out/test-issue_123/issue_123.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_123.h"

int32_t issue_123_fun(issue_123_E e)
{
  return (int32_t)(ptrdiff_t)e;
}

typedef struct const_ptrdiff_t__x2_s
{
  const ptrdiff_t *fst;
  const ptrdiff_t *snd;
}
const_ptrdiff_t__x2;

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

void issue_123_main(void)
{
  /* original Rust expression is not an lvalue in C */
  ptrdiff_t lvalue0 = (ptrdiff_t)((ptrdiff_t)-1 + (ptrdiff_t)0);
  /* original Rust expression is not an lvalue in C */
  ptrdiff_t lvalue1 = (ptrdiff_t)-1;
  const_ptrdiff_t__x2 uu____0 = { .fst = &lvalue0, .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue2 = issue_123_fun(issue_123_E_One);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue = 1;
  const_int32_t__x2 uu____1 = { .fst = &lvalue2, .snd = &lvalue };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}

/**
This function found in impl {core::cmp::PartialEq<issue_123::E2> for issue_123::E2}
*/
inline bool issue_123_eq_e3(const issue_123_E2 *self, const issue_123_E2 *other)
{
  ptrdiff_t __self_discr = (ptrdiff_t)self[0U];
  ptrdiff_t __arg1_discr = (ptrdiff_t)other[0U];
  return __self_discr == __arg1_discr;
}



================================================
FILE: out/test-issue_123/issue_123.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_123_H
#define issue_123_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

#define issue_123_E_One 1
#define issue_123_E_Five 5

typedef uint8_t issue_123_E;

#define issue_123_E1_C1 4294967295
#define issue_123_E1_C2 -4294967295
#define issue_123_E1_C3 268435455

typedef int64_t issue_123_E1;

#define issue_123_E2_C1 255
#define issue_123_E2_C2 -1

typedef int16_t issue_123_E2;

#define issue_123_E3_C1 255

typedef uint8_t issue_123_E3;

#define issue_123_E4_C1 127
#define issue_123_E4_C2 -126

typedef int8_t issue_123_E4;

#define issue_123_Gamma2_V95_232 95232
#define issue_123_Gamma2_V261_888 261888

typedef uint32_t issue_123_Gamma2;

int32_t issue_123_fun(issue_123_E e);

void issue_123_main(void);

/**
This function found in impl {core::cmp::PartialEq<issue_123::E2> for issue_123::E2}
*/
bool issue_123_eq_e3(const issue_123_E2 *self, const issue_123_E2 *other);

#if defined(__cplusplus)
}
#endif

#define issue_123_H_DEFINED
#endif /* issue_123_H */


================================================
FILE: out/test-issue_128/issue_128.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_128.h"

void issue_128_fun_a(Eurydice_borrow_slice_u8 _x)
{

}

void issue_128_fun_b(Eurydice_borrow_slice_u8 _x)
{

}

void issue_128_use_enum(issue_128_E e, Eurydice_borrow_slice_u8 x)
{
  switch (e)
  {
    case issue_128_E_A:
      {
        break;
      }
    case issue_128_E_B:
      {
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 0
*/
static Eurydice_borrow_slice_u8 array_to_slice_shared_08(const Eurydice_arr_bb *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)0U;
  return lit;
}

void issue_128_main(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_bb lvalue = Eurydice_empty_array((void *)0U, uint8_t, Eurydice_arr_bb);
  issue_128_use_enum(issue_128_E_A, array_to_slice_shared_08(&lvalue));
}



================================================
FILE: out/test-issue_128/issue_128.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_128_H
#define issue_128_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define issue_128_E_A 1
#define issue_128_E_B 2

typedef uint8_t issue_128_E;

void issue_128_fun_a(Eurydice_borrow_slice_u8 _x);

void issue_128_fun_b(Eurydice_borrow_slice_u8 _x);

void issue_128_use_enum(issue_128_E e, Eurydice_borrow_slice_u8 x);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $0size_t
*/
typedef struct Eurydice_arr_bb_s { uint8_t data[0U]; } Eurydice_arr_bb;

void issue_128_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_128_H_DEFINED
#endif /* issue_128_H */


================================================
FILE: out/test-issue_212/issue_212.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_212.h"

/**
A monomorphic instance of issue_212.id_mut
with types Eurydice_arr int32_t[[$3size_t]]

*/
const Eurydice_arr_bf *issue_212_id_mut_25(const Eurydice_arr_bf *x)
{
  return x;
}

void issue_212_main(void)
{
  Eurydice_arr_bf arr = { .data = { 1, 2, 3 } };
  const Eurydice_arr_bf *r = issue_212_id_mut_25(&arr);
  EURYDICE_ASSERT(r->data[0U] > 0, "panic!");
}



================================================
FILE: out/test-issue_212/issue_212.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_212_H
#define issue_212_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_bf_s { int32_t data[3U]; } Eurydice_arr_bf;

/**
A monomorphic instance of issue_212.id_mut
with types Eurydice_arr int32_t[[$3size_t]]

*/
const Eurydice_arr_bf *issue_212_id_mut_25(const Eurydice_arr_bf *x);

void issue_212_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_212_H_DEFINED
#endif /* issue_212_H */


================================================
FILE: out/test-issue_37/issue_37.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_37.h"

Eurydice_arr_ec issue_37_b(Eurydice_borrow_slice_u8 x)
{
  return (KRML_CLITERAL(Eurydice_arr_ec){ .data = { 0U } });
}

Eurydice_arr_ec issue_37_bb(Eurydice_borrow_slice_u8 x)
{
  return core_hint_black_box(issue_37_b(x), Eurydice_arr_ec, Eurydice_arr_ec);
}

void issue_37_main(void)
{

}



================================================
FILE: out/test-issue_37/issue_37.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_37_H
#define issue_37_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_ec_s { uint8_t data[32U]; } Eurydice_arr_ec;

Eurydice_arr_ec issue_37_b(Eurydice_borrow_slice_u8 x);

Eurydice_arr_ec issue_37_bb(Eurydice_borrow_slice_u8 x);

void issue_37_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_37_H_DEFINED
#endif /* issue_37_H */


================================================
FILE: out/test-issue_49/issue_49.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_49.h"

size_t issue_49_f(size_t a, size_t b)
{
  return core_cmp_impls__core__cmp__Ord_for_usize__min(a, b);
}

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

void issue_49_main(void)
{
  size_t expected = (size_t)0U;
  size_t actual = issue_49_f((size_t)0U, (size_t)0U);
  const_size_t__x2 uu____0 = { .fst = &expected, .snd = &actual };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-issue_49/issue_49.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_49_H
#define issue_49_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern size_t core_cmp_impls__core__cmp__Ord_for_usize__min(size_t x0, size_t x1);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

size_t issue_49_f(size_t a, size_t b);

void issue_49_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_49_H_DEFINED
#endif /* issue_49_H */


================================================
FILE: out/test-issue_96/issue_96.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_96.h"

void issue_96_use_it(const Eurydice_arr_48 *x)
{

}

void issue_96_use_it2(const issue_96_MyStruct2 *x)
{

}

void issue_96_main(void)
{
  Eurydice_arr_48 x = { .data = { 0U } };
  issue_96_MyStruct2 x0 = { .fst = { .data = { 0U } }, .snd = 2U };
}



================================================
FILE: out/test-issue_96/issue_96.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_96_H
#define issue_96_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_48_s { uint8_t data[5U]; } Eurydice_arr_48;

typedef Eurydice_arr_48 issue_96_MyStruct;

typedef struct issue_96_MyStruct2_s
{
  Eurydice_arr_48 fst;
  uint32_t snd;
}
issue_96_MyStruct2;

void issue_96_use_it(const Eurydice_arr_48 *x);

void issue_96_use_it2(const issue_96_MyStruct2 *x);

void issue_96_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_96_H_DEFINED
#endif /* issue_96_H */


================================================
FILE: out/test-issue_k630/issue_k630.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_k630.h"

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void issue_k630_main(void)
{
  Eurydice_arr_21 v;
  Eurydice_arr_d5 repeat_expression0[5U];
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    Eurydice_arr_d5 lit;
    uint32_t repeat_expression = 2U;
    memcpy(lit.data, &repeat_expression, (size_t)1U * sizeof (uint32_t));
    repeat_expression0[i] = lit;);
  memcpy(v.data, repeat_expression0, (size_t)5U * sizeof (Eurydice_arr_d5));
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 2U;
  const_uint32_t__x2 uu____0 = { .fst = v.data->data, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-issue_k630/issue_k630.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_k630_H
#define issue_k630_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_d5_s { uint32_t data[1U]; } Eurydice_arr_d5;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_d5
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_21_s { Eurydice_arr_d5 data[5U]; } Eurydice_arr_21;

void issue_k630_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_k630_H_DEFINED
#endif /* issue_k630_H */


================================================
FILE: out/test-issue_shift/issue_shift.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "issue_shift.h"

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

typedef struct const_int8_t__x2_s
{
  const int8_t *fst;
  const int8_t *snd;
}
const_int8_t__x2;

typedef struct const_int16_t__x2_s
{
  const int16_t *fst;
  const int16_t *snd;
}
const_int16_t__x2;

typedef struct const_int64_t__x2_s
{
  const int64_t *fst;
  const int64_t *snd;
}
const_int64_t__x2;

void issue_shift_main(void)
{
  int32_t x = -1;
  int32_t y = (int32_t)((uint32_t)x << 1U);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue0 = -2;
  const_int32_t__x2 uu____0 = { .fst = &y, .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  int8_t x0 = -1;
  int8_t y0 = (int8_t)((uint32_t)x0 << 1U);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue1 = -2;
  const_int8_t__x2 uu____1 = { .fst = &y0, .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  int16_t x1 = -1;
  int16_t y1 = (int16_t)((uint32_t)x1 << 1U);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue2 = -2;
  const_int16_t__x2 uu____2 = { .fst = &y1, .snd = &lvalue2 };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  int64_t x2 = -1LL;
  int64_t y2 = (int64_t)((uint64_t)x2 << 1U);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue = -2LL;
  const_int64_t__x2 uu____3 = { .fst = &y2, .snd = &lvalue };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
}



================================================
FILE: out/test-issue_shift/issue_shift.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef issue_shift_H
#define issue_shift_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void issue_shift_main(void);

#if defined(__cplusplus)
}
#endif

#define issue_shift_H_DEFINED
#endif /* issue_shift_H */


================================================
FILE: out/test-libcrux-ml-dsa/internal/libcrux_mldsa_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mldsa_avx2_H
#define internal_libcrux_mldsa_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "../libcrux_mldsa_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $8size_t
*/
typedef struct Eurydice_arr_53_s { Eurydice_arr_cd0 data[8U]; } Eurydice_arr_53;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b, size_t

*/
typedef struct Eurydice_dst_ref_shared_2a_s
{
  const Eurydice_arr_cd0 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_2a;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_15_s { Eurydice_arr_cd0 data[4U]; } Eurydice_arr_15;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $6size_t
*/
typedef struct Eurydice_arr_b50_s { Eurydice_arr_cd0 data[6U]; } Eurydice_arr_b50;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_dd_s { Eurydice_arr_cd0 data[5U]; } Eurydice_arr_dd;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $7size_t
*/
typedef struct Eurydice_arr_39_s { Eurydice_arr_cd0 data[7U]; } Eurydice_arr_39;

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mldsa_avx2_H_DEFINED
#endif /* internal_libcrux_mldsa_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/internal/libcrux_mldsa_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mldsa_core_H
#define internal_libcrux_mldsa_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "../libcrux_mldsa_core.h"

static inline uint32_t core_num__i32__count_ones(int32_t x0);

#define LIBCRUX_ML_DSA_SIMD_TRAITS_SIMD_UNITS_IN_RING_ELEMENT ((size_t)32U)

#define LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS_MINUS_ONE_BIT_LENGTH ((size_t)23U)

#define LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_UPPER_PART_OF_T (LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS_MINUS_ONE_BIT_LENGTH - LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T)

#define LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH ((size_t)64U)

#define LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT ((size_t)256U)

#define LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN ((size_t)255U)

#define LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS ((int32_t)8380417)

#define LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN ((size_t)814U)

#define LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE (LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T * LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE (LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_UPPER_PART_OF_T * LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE ((size_t)32U)

#define LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE ((size_t)64U)

#define LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE ((size_t)32U)

int32_t
libcrux_ml_dsa_constants_beta(
  size_t ones_in_verifier_challenge,
  libcrux_ml_dsa_constants_Eta eta
);

size_t
libcrux_ml_dsa_constants_commitment_ring_element_size(size_t bits_per_commitment_coefficient);

size_t libcrux_ml_dsa_constants_error_ring_element_size(size_t bits_per_error_coefficient);

size_t libcrux_ml_dsa_constants_gamma1_ring_element_size(size_t bits_per_gamma1_coefficient);

size_t
libcrux_ml_dsa_constants_signature_size(
  size_t rows_in_a,
  size_t columns_in_a,
  size_t max_ones_in_hint,
  size_t commitment_hash_size,
  size_t bits_per_gamma1_coefficient
);

size_t libcrux_ml_dsa_constants_verification_key_size(size_t rows_in_a);

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_COMMITMENT_COEFFICIENT ((size_t)6U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_ERROR_COEFFICIENT ((size_t)3U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_GAMMA1_COEFFICIENT ((size_t)18U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A ((size_t)4U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE ((size_t)32U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA (libcrux_ml_dsa_constants_Eta_Two)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT ((size_t)17U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2 ((LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS - (int32_t)1) / (int32_t)88)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT ((size_t)80U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE ((size_t)39U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A ((size_t)4U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_COMMITMENT_COEFFICIENT ((size_t)4U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_ERROR_COEFFICIENT ((size_t)4U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_GAMMA1_COEFFICIENT ((size_t)20U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A ((size_t)5U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE ((size_t)48U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA (libcrux_ml_dsa_constants_Eta_Four)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT ((size_t)19U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2 ((LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS - (int32_t)1) / (int32_t)32)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT ((size_t)55U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE ((size_t)49U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A ((size_t)6U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_COMMITMENT_COEFFICIENT ((size_t)4U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_ERROR_COEFFICIENT ((size_t)3U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_GAMMA1_COEFFICIENT ((size_t)20U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A ((size_t)7U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE ((size_t)64U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA (libcrux_ml_dsa_constants_Eta_Two)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT ((size_t)19U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2 ((LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS - (int32_t)1) / (int32_t)32)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT ((size_t)75U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE ((size_t)60U)

#define LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A ((size_t)8U)

size_t libcrux_ml_dsa_encoding_error_chunk_size(libcrux_ml_dsa_constants_Eta eta);

typedef struct Eurydice_arr_c3_s Eurydice_arr_c3;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_arr_c3, size_t

*/
typedef struct Eurydice_dst_ref_mut_22_s
{
  Eurydice_arr_c3 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_22;

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_c3_s { int32_t data[256U]; } Eurydice_arr_c3;

void
libcrux_ml_dsa_encoding_signature_set_hint(
  Eurydice_dst_ref_mut_22 out_hint,
  size_t i,
  size_t j
);

#define LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT ((size_t)13U)

#define LIBCRUX_ML_DSA_ENCODING_T1_DESERIALIZE_WINDOW ((size_t)10U)

#define LIBCRUX_ML_DSA_ENCODING_T1_SERIALIZE_OUTPUT_BYTES_PER_SIMD_UNIT ((size_t)10U)

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $66size_t
*/
typedef struct Eurydice_arr_a2_s { uint8_t data[66U]; } Eurydice_arr_a2;

Eurydice_arr_a2
libcrux_ml_dsa_sample_add_error_domain_separator(
  Eurydice_borrow_slice_u8 slice,
  uint16_t domain_separator
);

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_error_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_ERROR_COEFFICIENT))

#define LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS ((int32_t)8380417)

#define LIBCRUX_ML_DSA_SIMD_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R (58728449ULL)

typedef struct uint8_t_x2_s
{
  uint8_t fst;
  uint8_t snd;
}
uint8_t_x2;

uint8_t_x2
libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(size_t index, size_t width);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $34size_t
*/
typedef struct Eurydice_arr_48_s { uint8_t data[34U]; } Eurydice_arr_48;

Eurydice_arr_48
libcrux_ml_dsa_sample_add_domain_separator(Eurydice_borrow_slice_u8 slice, uint8_t_x2 indices);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $11size_t
*/
typedef struct Eurydice_arr_cb_s { uint8_t data[11U]; } Eurydice_arr_cb;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_cb

*/
typedef struct core_option_Option_b5_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_cb f0;
}
core_option_Option_b5;

typedef struct libcrux_ml_dsa_pre_hash_DomainSeparationContext_s
{
  Eurydice_borrow_slice_u8 context;
  core_option_Option_b5 pre_hash_oid;
}
libcrux_ml_dsa_pre_hash_DomainSeparationContext;

#define libcrux_ml_dsa_pre_hash_DomainSeparationError_ContextTooLongError 0

typedef uint8_t libcrux_ml_dsa_pre_hash_DomainSeparationError;

/**
A monomorphic instance of core.result.Result
with types libcrux_ml_dsa_pre_hash_DomainSeparationContext, libcrux_ml_dsa_pre_hash_DomainSeparationError

*/
typedef struct core_result_Result_a8_s
{
  core_result_Result_a8_tags tag;
  union {
    libcrux_ml_dsa_pre_hash_DomainSeparationContext case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationError case_Err;
  }
  val;
}
core_result_Result_a8;

/**
 `context` must be at most 255 bytes long.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
core_result_Result_a8
libcrux_ml_dsa_pre_hash_new_88(
  Eurydice_borrow_slice_u8 context,
  core_option_Option_b5 pre_hash_oid
);

/**
 Returns the pre-hash OID, if any.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
const
core_option_Option_b5
*libcrux_ml_dsa_pre_hash_pre_hash_oid_88(
  const libcrux_ml_dsa_pre_hash_DomainSeparationContext *self
);

/**
 Returns the context, guaranteed to be at most 255 bytes long.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
Eurydice_borrow_slice_u8
libcrux_ml_dsa_pre_hash_context_88(const libcrux_ml_dsa_pre_hash_DomainSeparationContext *self);

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_COMMITMENT_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_commitment_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_COMMITMENT_COEFFICIENT))

bool
libcrux_ml_dsa_sample_inside_out_shuffle(
  Eurydice_borrow_slice_u8 randomness,
  size_t *out_index,
  uint64_t *signs,
  Eurydice_arr_c3 *result
);

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA (libcrux_ml_dsa_constants_beta(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_GAMMA1_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_gamma1_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_GAMMA1_COEFFICIENT))

/**
This function found in impl {libcrux_ml_dsa::pre_hash::PreHash for libcrux_ml_dsa::pre_hash::SHAKE128_PH}
*/
Eurydice_arr_cb libcrux_ml_dsa_pre_hash_oid_30(void);

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_VERIFICATION_KEY_SIZE (libcrux_ml_dsa_constants_verification_key_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_SIGNATURE_SIZE (libcrux_ml_dsa_constants_signature_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_BITS_PER_GAMMA1_COEFFICIENT))

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t

*/
Eurydice_dst_ref_shared_fc
Eurydice_slice_subslice_shared_46(Eurydice_dst_ref_shared_fc s, core_ops_range_Range_08 r);

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_error_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_ERROR_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_COMMITMENT_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_commitment_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_COMMITMENT_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA (libcrux_ml_dsa_constants_beta(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_GAMMA1_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_gamma1_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_GAMMA1_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_VERIFICATION_KEY_SIZE (libcrux_ml_dsa_constants_verification_key_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_SIGNATURE_SIZE (libcrux_ml_dsa_constants_signature_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_BITS_PER_GAMMA1_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_error_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_ERROR_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_COMMITMENT_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_commitment_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_COMMITMENT_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA (libcrux_ml_dsa_constants_beta(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_GAMMA1_RING_ELEMENT_SIZE (libcrux_ml_dsa_constants_gamma1_ring_element_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_GAMMA1_COEFFICIENT))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_VERIFICATION_KEY_SIZE (libcrux_ml_dsa_constants_verification_key_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A))

#define LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_SIGNATURE_SIZE (libcrux_ml_dsa_constants_signature_size(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE, LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_BITS_PER_GAMMA1_COEFFICIENT))

typedef Eurydice_arr_38 libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87Signature;

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 4627
*/
const Eurydice_arr_38 *libcrux_ml_dsa_types_as_ref_c5_c2(const Eurydice_arr_38 *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 2592
*/
const Eurydice_arr_51 *libcrux_ml_dsa_types_as_ref_7f_d8(const Eurydice_arr_51 *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 4896
*/
const Eurydice_arr_180 *libcrux_ml_dsa_types_as_ref_9b_32(const Eurydice_arr_180 *self);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 2592
*/
Eurydice_arr_51 libcrux_ml_dsa_types_new_7f_d8(Eurydice_arr_51 value);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 4896
*/
Eurydice_arr_180 libcrux_ml_dsa_types_new_9b_32(Eurydice_arr_180 value);

typedef Eurydice_arr_400 libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44Signature;

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 2420
*/
const Eurydice_arr_400 *libcrux_ml_dsa_types_as_ref_c5_1a(const Eurydice_arr_400 *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 1312
*/
const Eurydice_arr_40 *libcrux_ml_dsa_types_as_ref_7f_db(const Eurydice_arr_40 *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 2560
*/
const Eurydice_arr_18 *libcrux_ml_dsa_types_as_ref_9b_ff(const Eurydice_arr_18 *self);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 1312
*/
Eurydice_arr_40 libcrux_ml_dsa_types_new_7f_db(Eurydice_arr_40 value);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 2560
*/
Eurydice_arr_18 libcrux_ml_dsa_types_new_9b_ff(Eurydice_arr_18 value);

typedef Eurydice_arr_96 libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65Signature;

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 3309
*/
const Eurydice_arr_96 *libcrux_ml_dsa_types_as_ref_c5_fa(const Eurydice_arr_96 *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 1952
*/
const Eurydice_arr_4a *libcrux_ml_dsa_types_as_ref_7f_97(const Eurydice_arr_4a *self);

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 4032
*/
const Eurydice_arr_d1 *libcrux_ml_dsa_types_as_ref_9b_09(const Eurydice_arr_d1 *self);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 1952
*/
Eurydice_arr_4a libcrux_ml_dsa_types_new_7f_97(Eurydice_arr_4a value);

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 4032
*/
Eurydice_arr_d1 libcrux_ml_dsa_types_new_9b_09(Eurydice_arr_d1 value);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_6d_s { uint8_t data[24U]; } Eurydice_arr_6d;

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 24
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_363(const Eurydice_arr_6d *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 24
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_369(Eurydice_arr_6d *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_46(Eurydice_arr_88 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_362(const Eurydice_arr_88 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_368(Eurydice_arr_88 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $19size_t
*/
typedef struct Eurydice_arr_91_s { uint8_t data[19U]; } Eurydice_arr_91;

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 19
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_361(const Eurydice_arr_91 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 19
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_367(Eurydice_arr_91 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t

*/
Eurydice_dst_ref_mut_fc
Eurydice_slice_subslice_mut_46(Eurydice_dst_ref_mut_fc s, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_46(const Eurydice_arr_88 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_6e(Eurydice_arr_60 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4627
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_24(const Eurydice_arr_38 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2592
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_f7(const Eurydice_arr_51 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4896
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e2(const Eurydice_arr_180 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c3
with const generics
- $8size_t
*/
typedef struct Eurydice_arr_fb_s { Eurydice_arr_c3 data[8U]; } Eurydice_arr_fb;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_fb

*/
typedef struct core_option_Option_b9_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_fb f0;
}
core_option_Option_b9;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $7size_t
*/
typedef struct Eurydice_arr_25_s { Eurydice_arr_a4 data[7U]; } Eurydice_arr_25;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_25

*/
typedef struct core_option_Option_0d_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_25 f0;
}
core_option_Option_0d;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_060

*/
typedef struct core_option_Option_d9_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_060 f0;
}
core_option_Option_d9;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4627
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_24(Eurydice_arr_38 *a);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_arr_c3, size_t

*/
typedef struct Eurydice_dst_ref_shared_22_s
{
  const Eurydice_arr_c3 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_22;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d1(const Eurydice_arr_fb *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 8
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d1(Eurydice_arr_fb *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1024size_t
*/
typedef struct Eurydice_arr_9e_s { uint8_t data[1024U]; } Eurydice_arr_9e;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1024
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_fd(const Eurydice_arr_9e *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1024
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_fd(Eurydice_arr_9e *a);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8, size_t

*/
typedef struct Eurydice_dst_ref_shared_e7_s
{
  const Eurydice_arr_a4 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_e7;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $56size_t
*/
typedef struct Eurydice_arr_46_s { Eurydice_arr_a4 data[56U]; } Eurydice_arr_46;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 56
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_718(const Eurydice_arr_46 *a);

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 4627
*/
Eurydice_arr_38 libcrux_ml_dsa_types_zero_c5_c2(void);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2592
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f7(Eurydice_arr_51 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4896
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e2(Eurydice_arr_180 *a);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $15size_t
*/
typedef struct Eurydice_arr_f8_s { Eurydice_arr_a4 data[15U]; } Eurydice_arr_f8;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_717(const Eurydice_arr_f8 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 7
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_716(const Eurydice_arr_25 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c31(const Eurydice_arr_f8 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 7
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_718(Eurydice_arr_25 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 56
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_717(Eurydice_arr_46 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_716(Eurydice_arr_f8 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 3309
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ee0(const Eurydice_arr_96 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1952
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_5b(const Eurydice_arr_4a *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4032
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ef(const Eurydice_arr_d1 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c3
with const generics
- $6size_t
*/
typedef struct Eurydice_arr_b5_s { Eurydice_arr_c3 data[6U]; } Eurydice_arr_b5;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_b5

*/
typedef struct core_option_Option_cb_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_b5 f0;
}
core_option_Option_cb;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_b0_s { Eurydice_arr_a4 data[5U]; } Eurydice_arr_b0;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_b0

*/
typedef struct core_option_Option_c8_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_b0 f0;
}
core_option_Option_c8;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_5f

*/
typedef struct core_option_Option_a6_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_5f f0;
}
core_option_Option_a6;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 3309
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ee0(Eurydice_arr_96 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 6
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d0(const Eurydice_arr_b5 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 6
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d0(Eurydice_arr_b5 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 48
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_95(const Eurydice_arr_5f *a);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $30size_t
*/
typedef struct Eurydice_arr_a1_s { Eurydice_arr_a4 data[30U]; } Eurydice_arr_a1;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 30
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_715(const Eurydice_arr_a1 *a);

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 3309
*/
Eurydice_arr_96 libcrux_ml_dsa_types_zero_c5_fa(void);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1952
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5b(Eurydice_arr_4a *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4032
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ef(Eurydice_arr_d1 *a);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $6size_t
*/
typedef struct Eurydice_arr_a3_s { Eurydice_arr_a4 data[6U]; } Eurydice_arr_a3;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 6
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_714(const Eurydice_arr_a3 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 6
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_715(Eurydice_arr_a3 *a);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $11size_t
*/
typedef struct Eurydice_arr_58_s { Eurydice_arr_a4 data[11U]; } Eurydice_arr_58;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_713(const Eurydice_arr_58 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 5
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_712(const Eurydice_arr_b0 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c30(const Eurydice_arr_58 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 5
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_714(Eurydice_arr_b0 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 30
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_713(Eurydice_arr_a1 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_712(Eurydice_arr_58 *a);

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.zero_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
Eurydice_arr_a4 libcrux_ml_dsa_polynomial_zero_ff_37(void);

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.from_i32_array_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_polynomial_from_i32_array_ff_37(
  Eurydice_dst_ref_shared_fc array,
  Eurydice_arr_a4 *result
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 256
*/
Eurydice_dst_ref_shared_fc Eurydice_array_to_slice_shared_200(const Eurydice_arr_c3 *a);

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.use_hint
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_use_hint_37(
  int32_t gamma2,
  Eurydice_dst_ref_shared_22 hint,
  Eurydice_dst_ref_mut_e7 re_vector
);

/**
A monomorphic instance of libcrux_ml_dsa.ntt.ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void libcrux_ml_dsa_ntt_ntt_37(Eurydice_arr_a4 *re);

/**
 Compute InvertNTT(Â ◦ ẑ - ĉ ◦ NTT(t₁2ᵈ))
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_w_approx
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_w_approx_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_e7 matrix,
  Eurydice_dst_ref_shared_e7 signer_response,
  const Eurydice_arr_a4 *verifier_challenge_as_ntt,
  Eurydice_dst_ref_mut_e7 t1
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2420
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_180(const Eurydice_arr_400 *a);

typedef struct Eurydice_borrow_slice_u8_x2_s
{
  Eurydice_borrow_slice_u8 fst;
  Eurydice_borrow_slice_u8 snd;
}
Eurydice_borrow_slice_u8_x2;

/**
A monomorphic instance of libcrux_ml_dsa.encoding.gamma1.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_gamma1_deserialize_37(
  size_t gamma1_exponent,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_a4 *result
);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
core_result_Result_41
libcrux_ml_dsa_encoding_signature_deserialize_37(
  size_t columns_in_a,
  size_t rows_in_a,
  size_t commitment_hash_size,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  size_t signature_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_mut_borrow_slice_u8 out_commitment_hash,
  Eurydice_dst_ref_mut_e7 out_signer_response,
  Eurydice_dst_ref_mut_22 out_hint
);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_verification_key_deserialize_37(
  size_t rows_in_a,
  size_t verification_key_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 t1
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1312
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_bb(const Eurydice_arr_40 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2560
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_59(const Eurydice_arr_18 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c3
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_83_s { Eurydice_arr_c3 data[4U]; } Eurydice_arr_83;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_83

*/
typedef struct core_option_Option_cf_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_83 f0;
}
core_option_Option_cf;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_a80_s { Eurydice_arr_a4 data[4U]; } Eurydice_arr_a80;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_a80

*/
typedef struct core_option_Option_43_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_a80 f0;
}
core_option_Option_43;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_60

*/
typedef struct core_option_Option_90_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_60 f0;
}
core_option_Option_90;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2420
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_180(Eurydice_arr_400 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d(const Eurydice_arr_83 *a);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_signature_serialize_37(
  Eurydice_borrow_slice_u8 commitment_hash,
  Eurydice_dst_ref_shared_e7 signer_response,
  Eurydice_dst_ref_shared_22 hint,
  size_t commitment_hash_size,
  size_t columns_in_a,
  size_t rows_in_a,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  Eurydice_mut_borrow_slice_u8 signature
);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d(Eurydice_arr_83 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t
with const generics
- N= 256
*/
Eurydice_dst_ref_mut_fc
Eurydice_array_to_subslice_mut_7f(Eurydice_arr_c3 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.make_hint
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
size_t
libcrux_ml_dsa_arithmetic_make_hint_37(
  Eurydice_dst_ref_shared_e7 low,
  Eurydice_dst_ref_shared_e7 high,
  int32_t gamma2,
  Eurydice_dst_ref_mut_22 hint
);

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.vector_infinity_norm_exceeds
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(
  Eurydice_dst_ref_shared_e7 vector,
  int32_t bound
);

/**
A monomorphic instance of libcrux_ml_dsa.matrix.subtract_vectors
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_subtract_vectors_37(
  size_t dimension,
  Eurydice_dst_ref_mut_e7 lhs,
  Eurydice_dst_ref_shared_e7 rhs
);

/**
A monomorphic instance of libcrux_ml_dsa.matrix.add_vectors
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_add_vectors_37(
  size_t dimension,
  Eurydice_dst_ref_mut_e7 lhs,
  Eurydice_dst_ref_shared_e7 rhs
);

/**
A monomorphic instance of libcrux_ml_dsa.matrix.vector_times_ring_element
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_vector_times_ring_element_37(
  Eurydice_dst_ref_mut_e7 vector,
  const Eurydice_arr_a4 *ring_element
);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_8c(const Eurydice_arr_3d *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_360(const Eurydice_arr_3d *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $768size_t
*/
typedef struct Eurydice_arr_56_s { uint8_t data[768U]; } Eurydice_arr_56;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ee(const Eurydice_arr_56 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ee(Eurydice_arr_56 *a);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.commitment.serialize_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_commitment_serialize_vector_37(
  size_t ring_element_size,
  Eurydice_dst_ref_shared_e7 vector,
  Eurydice_mut_borrow_slice_u8 serialized
);

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.decompose_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_decompose_vector_37(
  size_t dimension,
  int32_t gamma2,
  Eurydice_dst_ref_shared_e7 t,
  Eurydice_dst_ref_mut_e7 low,
  Eurydice_dst_ref_mut_e7 high
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_66_s { Eurydice_arr_a4 data[16U]; } Eurydice_arr_66;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 16
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_711(const Eurydice_arr_66 *a);

/**
 Compute InvertNTT(Â ◦ ŷ)
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_matrix_x_mask
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_matrix_x_mask_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_e7 matrix,
  Eurydice_dst_ref_shared_e7 mask,
  Eurydice_dst_ref_mut_e7 result
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 640
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7d0(const Eurydice_arr_c30 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 640
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_7d(Eurydice_arr_c30 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 576
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_fa(const Eurydice_arr_5f0 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 576
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_fa(Eurydice_arr_5f0 *a);

/**
A monomorphic instance of core.option.Option
with types libcrux_ml_dsa_pre_hash_DomainSeparationContext

*/
typedef struct core_option_Option_84_s
{
  core_option_Option_08_tags tag;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext f0;
}
core_option_Option_84;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 11
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_da(const Eurydice_arr_cb *a);

/**
 Returns `true` if the option is a [`Some`] value.

 # Examples

 ```
 let x: Option<u32> = Some(2);
 assert_eq!(x.is_some(), true);

 let x: Option<u32> = None;
 assert_eq!(x.is_some(), false);
 ```
*/
/**
This function found in impl {core::option::Option<T>[TraitClause@0]}
*/
/**
A monomorphic instance of core.option.is_some_cd
with types Eurydice_arr uint8_t[[$11size_t]]

*/
bool core_option_is_some_cd_4e(const core_option_Option_b5 *self);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_f10_s { uint8_t data[1U]; } Eurydice_arr_f10;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_07(const Eurydice_arr_f10 *a);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_t0_deserialize_to_vector_then_ntt_37(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 ring_elements
);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(
  libcrux_ml_dsa_constants_Eta eta,
  size_t ring_element_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 ring_elements
);

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 2420
*/
Eurydice_arr_400 libcrux_ml_dsa_types_zero_c5_1a(void);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1312
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_bb(Eurydice_arr_40 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2560
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_59(Eurydice_arr_18 *a);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_t0_serialize_37(
  const Eurydice_arr_a4 *re,
  Eurydice_mut_borrow_slice_u8 serialized
);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_error_serialize_37(
  libcrux_ml_dsa_constants_Eta eta,
  const Eurydice_arr_a4 *re,
  Eurydice_mut_borrow_slice_u8 serialized
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d8(const Eurydice_arr_060 *a);

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.generate_serialized
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_verification_key_generate_serialized_37(
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_shared_e7 t1,
  Eurydice_mut_borrow_slice_u8 verification_key_serialized
);

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.power2round_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_power2round_vector_37(
  Eurydice_dst_ref_mut_e7 t,
  Eurydice_dst_ref_mut_e7 t1
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8
with const generics
- $8size_t
*/
typedef struct Eurydice_arr_db_s { Eurydice_arr_a4 data[8U]; } Eurydice_arr_db;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_710(const Eurydice_arr_db *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 4
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_71(const Eurydice_arr_a80 *a);

/**
 Compute InvertNTT(Â ◦ ŝ₁) + s₂
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_as1_plus_s2
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_as1_plus_s2_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_mut_e7 a_as_ntt,
  Eurydice_dst_ref_shared_e7 s1_ntt,
  Eurydice_dst_ref_shared_e7 s1_s2,
  Eurydice_dst_ref_mut_e7 result
);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c3(const Eurydice_arr_db *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_711(Eurydice_arr_a80 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 16
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_710(Eurydice_arr_66 *a);

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $263size_t
*/
typedef struct Eurydice_arr_13_s { int32_t data[263U]; } Eurydice_arr_13;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_arr_13, size_t

*/
typedef struct Eurydice_dst_ref_mut_4c_s
{
  Eurydice_arr_13 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_4c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_13
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_380_s { Eurydice_arr_13 data[4U]; } Eurydice_arr_380;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$263size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_4c Eurydice_array_to_slice_mut_f6(Eurydice_arr_380 *a);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_arr_13, size_t

*/
typedef struct Eurydice_dst_ref_shared_4c_s
{
  const Eurydice_arr_13 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_4c;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 840
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_a8(const Eurydice_arr_12 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types int32_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice int32_t
with const generics
- N= 263
*/
Eurydice_dst_ref_mut_fc Eurydice_array_to_subslice_from_mut_96(Eurydice_arr_13 *a, size_t r);

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_field_modulus
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 34
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_8d(const Eurydice_arr_48 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_71(Eurydice_arr_db *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 263
*/
Eurydice_dst_ref_shared_fc Eurydice_array_to_slice_shared_20(const Eurydice_arr_13 *a);

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled,
  Eurydice_arr_13 *out
);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 66
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_39(const Eurydice_arr_a2 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $128size_t
*/
typedef struct Eurydice_arr_d10_s { uint8_t data[128U]; } Eurydice_arr_d10;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 128
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_18(const Eurydice_arr_d10 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_18(Eurydice_arr_d10 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_26(const Eurydice_array_u8x2 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_6e(const Eurydice_arr_60 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_7b(Eurydice_arr_27 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 840
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_a8(Eurydice_arr_12 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d4(Eurydice_arr_3d *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_36(const Eurydice_arr_60 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_3d
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_1a_s { Eurydice_arr_3d data[4U]; } Eurydice_arr_1a;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_27
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_b3_s { Eurydice_arr_27 data[4U]; } Eurydice_arr_b3;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_borrow_slice_u8
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cd_s { Eurydice_borrow_slice_u8 data[4U]; } Eurydice_arr_cd;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_364(Eurydice_arr_60 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_27
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_3a_s { Eurydice_arr_27 data[1U]; } Eurydice_arr_3a;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d8(Eurydice_arr_060 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $72size_t
*/
typedef struct Eurydice_arr_a0_s { uint8_t data[72U]; } Eurydice_arr_a0;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 72
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7d(const Eurydice_arr_a0 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_363(Eurydice_arr_a0 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.slice_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_to_shared_c6(Eurydice_borrow_slice_u8 s, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_8c(Eurydice_arr_3d *a, size_t r);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mldsa_core_H_DEFINED
#endif /* internal_libcrux_mldsa_core_H */


================================================
FILE: out/test-libcrux-ml-dsa/internal/libcrux_mldsa_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mldsa_portable_H
#define internal_libcrux_mldsa_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mldsa_core.h"
#include "libcrux_mldsa_core.h"
#include "../libcrux_mldsa_portable.h"

/**
 This corresponds to line 6 in algorithm 7 in FIPS 204 (line 7 in algorithm
 8, resp.).

 If `domain_separation_context` is supplied, applies domain
 separation and length encoding to the context string,
 before appending the message (in the regular variant) or the
 pre-hash OID as well as the pre-hashed message digest. Otherwise,
 it is assumed that `message` already contains domain separation
 information.

 In FIPS 204 M' is the concatenation of the domain separated context, any
 potential pre-hash OID and the message (or the message pre-hash). We do not
 explicitely construct the concatenation in memory since it is of statically unknown
 length, but feed its components directly into the incremental XOF.

 Refer to line 10 of Algorithm 2 (and line 5 of Algorithm 3, resp.) in [FIPS
 204](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.204.pdf#section.5)
 for details on the domain separation for regular ML-DSA. Line
 23 of Algorithm 4 (and line 18 of Algorithm 5,resp.) describe domain separation for the HashMl-DSA
 variant.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.derive_message_representative
with types libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
void
libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(
  Eurydice_borrow_slice_u8 verification_key_hash,
  const core_option_Option_84 *domain_separation_context,
  Eurydice_borrow_slice_u8 message,
  Eurydice_arr_060 *message_representative
);

/**
This function found in impl {libcrux_ml_dsa::pre_hash::PreHash for libcrux_ml_dsa::pre_hash::SHAKE128_PH}
*/
/**
A monomorphic instance of libcrux_ml_dsa.pre_hash.hash_30
with types libcrux_ml_dsa_hash_functions_portable_Shake128
with const generics

*/
void
libcrux_ml_dsa_pre_hash_hash_30_83(
  Eurydice_borrow_slice_u8 message,
  Eurydice_mut_borrow_slice_u8 output
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mldsa_portable_H_DEFINED
#endif /* internal_libcrux_mldsa_portable_H */


================================================
FILE: out/test-libcrux-ml-dsa/internal/libcrux_sha3_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_sha3_avx2_H
#define internal_libcrux_sha3_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mldsa_core.h"
#include "libcrux_mldsa_core.h"
#include "../libcrux_sha3_avx2.h"

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
Eurydice_arr_05 libcrux_sha3_generic_keccak_new_80_a6(void);

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_traits_set_ij_a6(Eurydice_arr_05 *arr, size_t i, size_t j, __m256i value);

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
const __m256i *libcrux_sha3_traits_get_ij_a6(const Eurydice_arr_05 *arr, size_t i, size_t j);

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_c0_s { __m256i data[5U]; } Eurydice_arr_c0;

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
const
__m256i
*libcrux_sha3_generic_keccak_index_c2_a6(const Eurydice_arr_05 *self, size_t_x2 index);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
Eurydice_arr_c0 libcrux_sha3_generic_keccak_theta_80_a6(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void
libcrux_sha3_generic_keccak_set_80_a6(Eurydice_arr_05 *self, size_t i, size_t j, __m256i v);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_0_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_1_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_2_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_3_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_4_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_rho_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_0_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_1_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_2_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_3_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_4_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_pi_80_a6(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_chi_80_a6(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_iota_80_a6(Eurydice_arr_05 *self, size_t i);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void libcrux_sha3_generic_keccak_keccakf1600_80_a6(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 168
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_fb(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_fb0(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_97(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_sha3_avx2_H_DEFINED
#endif /* internal_libcrux_sha3_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/internal/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_sha3_internal_H
#define internal_libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mldsa_core.h"
#include "libcrux_mldsa_core.h"
#include "../libcrux_sha3_internal.h"

/**
 Create a new SHAKE-128 state object.
*/
static KRML_MUSTINLINE Eurydice_arr_26 libcrux_sha3_portable_incremental_shake128_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_04();
}

/**
 Absorb
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_absorb_final(
  Eurydice_arr_26 *s,
  Eurydice_borrow_slice_u8 data0
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_06 lvalue = { .data = { data0 } };
  libcrux_sha3_generic_keccak_absorb_final_80_9e(s, &lvalue, (size_t)0U, data0.meta);
}

/**
 Create a new SHAKE-256 state object.
*/
static KRML_MUSTINLINE Eurydice_arr_26 libcrux_sha3_portable_incremental_shake256_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_04();
}

/**
 Absorb some data for SHAKE-256 for the last time
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_absorb_final(
  Eurydice_arr_26 *s,
  Eurydice_borrow_slice_u8 data
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_06 lvalue = { .data = { data } };
  libcrux_sha3_generic_keccak_absorb_final_80_9e0(s, &lvalue, (size_t)0U, data.meta);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_5b(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_5b(self, out, (size_t)0U, (size_t)136U);
}

/**
 Squeeze the first SHAKE-256 block
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_first_block(
  Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_5b(&s[0U], out);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_3a(
  Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)3U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_3a(s, out0);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_3a(
  Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, start, (size_t)168U);
}

/**
 Squeeze another block
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_squeeze_next_block(
  Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_3a(s, out0, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_5b(
  Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_5b(self, out, start, (size_t)136U);
}

/**
 Squeeze the next SHAKE-256 block
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_next_block(
  Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_5b(s, out, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.fill_buffer_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline size_t
libcrux_sha3_generic_keccak_xof_fill_buffer_35_c6(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  const Eurydice_arr_06 *inputs
)
{
  size_t input_len = inputs->data->meta;
  size_t uu____0;
  if (self->buf_len != (size_t)0U)
  {
    if (input_len >= (size_t)136U - self->buf_len)
    {
      size_t consumed = (size_t)136U - self->buf_len;
      {
        size_t i = (size_t)0U;
        Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_8c(&self->buf.data[i],
            self->buf_len),
          Eurydice_slice_subslice_to_shared_c6(inputs->data[i], consumed),
          uint8_t);
      }
      self->buf_len = (size_t)136U;
      uu____0 = consumed;
    }
    else
    {
      uu____0 = (size_t)0U;
    }
  }
  else
  {
    uu____0 = (size_t)0U;
  }
  return uu____0;
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.buf_to_slices.closure
with const generics
- $1size_t
- $136size_t
*/
typedef const Eurydice_arr_3e *libcrux_sha3_generic_keccak_xof_buf_to_slices_closure_cc;

/**
This function found in impl {core::ops::function::FnMut<(usize), &'_ ([u8])> for libcrux_sha3::generic_keccak::xof::buf_to_slices::closure<0, PARALLEL_LANES, RATE>}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.buf_to_slices.call_mut_2a
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline Eurydice_borrow_slice_u8
libcrux_sha3_generic_keccak_xof_buf_to_slices_call_mut_2a_5b(
  const Eurydice_arr_3e **_,
  size_t tupled_args
)
{
  size_t i = tupled_args;
  return
    core_array___T__N___as_slice((size_t)136U,
      &_[0U]->data[i],
      uint8_t,
      Eurydice_borrow_slice_u8);
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), &'_ ([u8])> for libcrux_sha3::generic_keccak::xof::buf_to_slices::closure<0, PARALLEL_LANES, RATE>}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.buf_to_slices.call_once_fa
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline Eurydice_borrow_slice_u8
libcrux_sha3_generic_keccak_xof_buf_to_slices_call_once_fa_5b(
  const Eurydice_arr_3e *_,
  size_t _0
)
{
  return libcrux_sha3_generic_keccak_xof_buf_to_slices_call_mut_2a_5b(&_, _0);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.buf_to_slices
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static KRML_MUSTINLINE Eurydice_arr_06
libcrux_sha3_generic_keccak_xof_buf_to_slices_5b(const Eurydice_arr_3e *buf)
{
  Eurydice_arr_06 arr_struct;
  {
    arr_struct.data[0U] =
      libcrux_sha3_generic_keccak_xof_buf_to_slices_call_mut_2a_5b(&buf,
        (size_t)0U);
  }
  return arr_struct;
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_full_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline size_t
libcrux_sha3_generic_keccak_xof_absorb_full_35_c6(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  const Eurydice_arr_06 *inputs
)
{
  size_t consumed = libcrux_sha3_generic_keccak_xof_fill_buffer_35_c6(self, inputs);
  if (self->buf_len == (size_t)136U)
  {
    Eurydice_arr_06 borrowed = libcrux_sha3_generic_keccak_xof_buf_to_slices_5b(&self->buf);
    libcrux_sha3_simd_portable_load_block_a1_5b(&self->inner, &borrowed, (size_t)0U);
    libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
    self->buf_len = (size_t)0U;
  }
  size_t input_to_consume = inputs->data->meta - consumed;
  size_t num_blocks = input_to_consume / (size_t)136U;
  size_t remainder = input_to_consume % (size_t)136U;
  for (size_t i = (size_t)0U; i < num_blocks; i++)
  {
    size_t i0 = i;
    size_t start = i0 * (size_t)136U + consumed;
    libcrux_sha3_simd_portable_load_block_a1_5b(&self->inner, inputs, start);
    libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
  }
  return remainder;
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_xof_absorb_35_c6(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  const Eurydice_arr_06 *inputs
)
{
  size_t remainder = libcrux_sha3_generic_keccak_xof_absorb_full_35_c6(self, inputs);
  if (remainder > (size_t)0U)
  {
    size_t input_len = inputs->data->meta;
    {
      size_t i = (size_t)0U;
      Eurydice_slice_copy(Eurydice_array_to_subslice_mut_362(&self->buf.data[i],
          (
            KRML_CLITERAL(core_ops_range_Range_08){
              .start = self->buf_len,
              .end = self->buf_len + remainder
            }
          )),
        Eurydice_slice_subslice_shared_7e(inputs->data[i],
          (
            KRML_CLITERAL(core_ops_range_Range_08){
              .start = input_len - remainder,
              .end = input_len
            }
          )),
        uint8_t);
    }
    self->buf_len = self->buf_len + remainder;
  }
}

/**
 Shake256 absorb
*/
/**
This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> for libcrux_sha3::portable::incremental::Shake256Xof}
*/
static inline void
libcrux_sha3_portable_incremental_absorb_42(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_06 lvalue = { .data = { input } };
  libcrux_sha3_generic_keccak_xof_absorb_35_c6(self, &lvalue);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_final_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_xof_absorb_final_35_9e(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  const Eurydice_arr_06 *inputs
)
{
  libcrux_sha3_generic_keccak_xof_absorb_35_c6(self, inputs);
  Eurydice_arr_06 borrowed = libcrux_sha3_generic_keccak_xof_buf_to_slices_5b(&self->buf);
  libcrux_sha3_simd_portable_load_last_a1_ad(&self->inner, &borrowed, (size_t)0U, self->buf_len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
}

/**
 Shake256 absorb final
*/
/**
This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> for libcrux_sha3::portable::incremental::Shake256Xof}
*/
static inline void
libcrux_sha3_portable_incremental_absorb_final_42(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_06 lvalue = { .data = { input } };
  libcrux_sha3_generic_keccak_xof_absorb_final_35_9e(self, &lvalue);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.zero_block_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline Eurydice_arr_3d libcrux_sha3_generic_keccak_xof_zero_block_35_c6(void)
{
  return (KRML_CLITERAL(Eurydice_arr_3d){ .data = { 0U } });
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.new_35
with types uint64_t
with const generics
- PARALLEL_LANES= 1
- RATE= 136
*/
static inline libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
libcrux_sha3_generic_keccak_xof_new_35_c6(void)
{
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 lit;
  lit.inner = libcrux_sha3_generic_keccak_new_80_04();
  Eurydice_arr_3d repeat_expression[1U];
  {
    repeat_expression[0U] = libcrux_sha3_generic_keccak_xof_zero_block_35_c6();
  }
  memcpy(lit.buf.data, repeat_expression, (size_t)1U * sizeof (Eurydice_arr_3d));
  lit.buf_len = (size_t)0U;
  lit.sponge = false;
  return lit;
}

/**
 Shake256 new state
*/
/**
This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> for libcrux_sha3::portable::incremental::Shake256Xof}
*/
static inline libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
libcrux_sha3_portable_incremental_new_42(void)
{
  return libcrux_sha3_generic_keccak_xof_new_35_c6();
}

/**
This function found in impl {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, 1usize, RATE>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.squeeze_85
with types uint64_t
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_xof_squeeze_85_c7(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  size_t out_len = out.meta;
  if (!(out_len == (size_t)0U))
  {
    if (self->sponge)
    {
      libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
    }
    if (out_len > (size_t)0U)
    {
      size_t blocks = out_len / (size_t)136U;
      size_t last = out_len - out_len % (size_t)136U;
      if (blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&self->inner, out, (size_t)0U, out_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&self->inner, out, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&self->inner,
            out,
            i0 * (size_t)136U,
            (size_t)136U);
        }
        if (last < out_len)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&self->inner, out, last, out_len - last);
        }
      }
    }
    self->sponge = true;
  }
}

/**
 Shake256 squeeze
*/
/**
This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> for libcrux_sha3::portable::incremental::Shake256Xof}
*/
static inline void
libcrux_sha3_portable_incremental_squeeze_42(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_xof_squeeze_85_c7(self, out);
}

#define libcrux_sha3_Algorithm_Sha224 1
#define libcrux_sha3_Algorithm_Sha256 2
#define libcrux_sha3_Algorithm_Sha384 3
#define libcrux_sha3_Algorithm_Sha512 4

typedef uint8_t libcrux_sha3_Algorithm;

#define LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE ((size_t)28U)

#define LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE ((size_t)32U)

#define LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE ((size_t)48U)

#define LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE ((size_t)64U)

/**
 Returns the output size of a digest.
*/
static inline size_t libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode)
{
  switch (mode)
  {
    case libcrux_sha3_Algorithm_Sha224:
      {
        break;
      }
    case libcrux_sha3_Algorithm_Sha256:
      {
        return LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha384:
      {
        return LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha512:
      {
        return LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 72
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_f8(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_26 state_flat = { .data = { 0U } };
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = (size_t)72U / (size_t)8U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)72U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_04(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_7e(blocks,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 72
- DELIMITER= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_96(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_a0 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_363(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)72U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_f8(state,
    Eurydice_array_to_slice_shared_7d(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 72
- DELIMITER= 6
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_96(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_96(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
- DELIM= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e1(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_96(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 72
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_f8(
  const Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_41(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_6e(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 72
*/
static inline void
libcrux_sha3_simd_portable_squeeze_9b_f8(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_f8(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 72
*/
static inline void
libcrux_sha3_simd_portable_load_block_a1_f8(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_f8(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_c6(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_f8(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 72
- DELIM= 6
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_96(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)72U;
  size_t input_rem = input_len % (size_t)72U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e1(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)72U;
      size_t output_rem = output_len % (size_t)72U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_f8(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_f8(&s, output, (size_t)0U, (size_t)72U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_f8(&s, output, i0 * (size_t)72U, (size_t)72U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_f8(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c6(&s, &lvalue, i * (size_t)72U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 512 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_sha512(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_96(data, digest);
}

/**
 SHA3 512
*/
static inline void
libcrux_sha3_sha512_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha512(digest, payload);
}

/**
 SHA3 512
*/
static inline Eurydice_arr_060 libcrux_sha3_sha512(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_060 out = { .data = { 0U } };
  libcrux_sha3_sha512_ema(Eurydice_array_to_slice_mut_d8(&out), data);
  return out;
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $168size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_97_s
{
  Eurydice_arr_26 inner;
  Eurydice_arr_3a buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_97;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_97
libcrux_sha3_portable_incremental_Shake128Xof;

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_3a(
  Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
  libcrux_sha3_simd_portable_squeeze_9b_3a(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_3a(s, out0);
}

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_sha3_internal_H_DEFINED
#endif /* internal_libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa44_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa44_avx2.h"

#include "libcrux_mldsa_core.h"
#include "libcrux_mldsa_avx2.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-44 Key Pair
*/
KRML_ATTRIBUTE_TARGET("avx2")
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair
libcrux_ml_dsa_ml_dsa_44_avx2_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_18 signing_key = { .data = { 0U } };
  Eurydice_arr_40 verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair(randomness,
    Eurydice_array_to_slice_mut_59(&signing_key),
    Eurydice_array_to_slice_mut_bb(&verification_key));
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_ff(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_db(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_avx2_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign(libcrux_ml_dsa_types_as_ref_9b_ff(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_44_avx2_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut(libcrux_ml_dsa_types_as_ref_9b_ff(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_18 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_ff(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_avx2_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify(libcrux_ml_dsa_types_as_ref_7f_db(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_1a(signature));
}

/**
 Verify a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_40 *uu____0 = libcrux_ml_dsa_types_as_ref_7f_db(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_1a(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa44_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa44_avx2_H
#define libcrux_mldsa44_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-44 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair
libcrux_ml_dsa_ml_dsa_44_avx2_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_avx2_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_44_avx2_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
);

/**
 Generate a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_avx2_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

/**
 Verify a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa44_avx2_H_DEFINED
#endif /* libcrux_mldsa44_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa44_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa44_portable.h"

#include "libcrux_mldsa_portable.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-44 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair
libcrux_ml_dsa_ml_dsa_44_portable_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_18 signing_key = { .data = { 0U } };
  Eurydice_arr_40 verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_generate_key_pair(randomness,
    &signing_key,
    &verification_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_ff(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_db(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_portable_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign(libcrux_ml_dsa_types_as_ref_9b_ff(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_44_portable_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_mut(libcrux_ml_dsa_types_as_ref_9b_ff(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_18 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_ff(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_portable_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify(libcrux_ml_dsa_types_as_ref_7f_db(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_1a(signature));
}

/**
 Verify a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_40 *uu____0 = libcrux_ml_dsa_types_as_ref_7f_db(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_1a(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa44_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa44_portable_H
#define libcrux_mldsa44_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-44 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair
libcrux_ml_dsa_ml_dsa_44_portable_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_portable_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_44_portable_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
);

/**
 Generate a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_44_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-44 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_portable_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

/**
 Verify a HashML-DSA-44 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_44_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa44_portable_H_DEFINED
#endif /* libcrux_mldsa44_portable_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa65_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa65_avx2.h"

#include "libcrux_mldsa_core.h"
#include "libcrux_mldsa_avx2.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-65 Key Pair
*/
KRML_ATTRIBUTE_TARGET("avx2")
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair
libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_d1 signing_key = { .data = { 0U } };
  Eurydice_arr_4a verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair(randomness,
    Eurydice_array_to_slice_mut_ef(&signing_key),
    Eurydice_array_to_slice_mut_5b(&verification_key));
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_09(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_97(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-65 Key Pair
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair_mut(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
)
{
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair(randomness,
    Eurydice_array_to_slice_mut_ef(signing_key),
    Eurydice_array_to_slice_mut_5b(verification_key));
}

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_avx2_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign(libcrux_ml_dsa_types_as_ref_9b_09(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_65_avx2_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut(signing_key,
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_d1 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_09(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_avx2_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify(libcrux_ml_dsa_types_as_ref_7f_97(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_fa(signature));
}

/**
 Verify a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_4a *uu____0 = libcrux_ml_dsa_types_as_ref_7f_97(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_fa(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa65_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa65_avx2_H
#define libcrux_mldsa65_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-65 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair
libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-65 Key Pair
*/
void
libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair_mut(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
);

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_avx2_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_65_avx2_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
);

/**
 Generate a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_avx2_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

/**
 Verify a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa65_avx2_H_DEFINED
#endif /* libcrux_mldsa65_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa65_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa65_portable.h"

#include "libcrux_mldsa_portable.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-65 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair
libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_d1 signing_key = { .data = { 0U } };
  Eurydice_arr_4a verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_generate_key_pair(randomness,
    &signing_key,
    &verification_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_09(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_97(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-65 Key Pair
*/
void
libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair_mut(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
)
{
  libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_generate_key_pair(randomness,
    signing_key,
    verification_key);
}

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_portable_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign(libcrux_ml_dsa_types_as_ref_9b_09(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_65_portable_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_mut(signing_key,
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_d1 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_09(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_portable_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify(libcrux_ml_dsa_types_as_ref_7f_97(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_fa(signature));
}

/**
 Verify a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_4a *uu____0 = libcrux_ml_dsa_types_as_ref_7f_97(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_fa(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa65_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa65_portable_H
#define libcrux_mldsa65_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-65 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair
libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-65 Key Pair
*/
void
libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair_mut(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
);

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_portable_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_65_portable_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
);

/**
 Generate a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_65_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-65 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_portable_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

/**
 Verify a HashML-DSA-65 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_65_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa65_portable_H_DEFINED
#endif /* libcrux_mldsa65_portable_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa87_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa87_avx2.h"

#include "libcrux_mldsa_core.h"
#include "libcrux_mldsa_avx2.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-87 Key Pair
*/
KRML_ATTRIBUTE_TARGET("avx2")
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair
libcrux_ml_dsa_ml_dsa_87_avx2_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_180 signing_key = { .data = { 0U } };
  Eurydice_arr_51 verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair(randomness,
    Eurydice_array_to_slice_mut_e2(&signing_key),
    Eurydice_array_to_slice_mut_f7(&verification_key));
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_32(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_d8(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_avx2_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign(libcrux_ml_dsa_types_as_ref_9b_32(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_87_avx2_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut(libcrux_ml_dsa_types_as_ref_9b_32(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_180 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_32(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_avx2_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify(libcrux_ml_dsa_types_as_ref_7f_d8(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_c2(signature));
}

/**
 Verify a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_51 *uu____0 = libcrux_ml_dsa_types_as_ref_7f_d8(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_c2(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa87_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa87_avx2_H
#define libcrux_mldsa87_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-87 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair
libcrux_ml_dsa_ml_dsa_87_avx2_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_avx2_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_87_avx2_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
);

/**
 Generate a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_avx2_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_avx2_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

/**
 Verify a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_avx2_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa87_avx2_H_DEFINED
#endif /* libcrux_mldsa87_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa87_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_mldsa87_portable.h"

#include "libcrux_mldsa_portable.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-87 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair
libcrux_ml_dsa_ml_dsa_87_portable_generate_key_pair(Eurydice_arr_60 randomness)
{
  Eurydice_arr_180 signing_key = { .data = { 0U } };
  Eurydice_arr_51 verification_key = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_generate_key_pair(randomness,
    &signing_key,
    &verification_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair){
        .signing_key = libcrux_ml_dsa_types_new_9b_32(signing_key),
        .verification_key = libcrux_ml_dsa_types_new_7f_d8(verification_key)
      }
    );
}

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_portable_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign(libcrux_ml_dsa_types_as_ref_9b_32(signing_key),
      message,
      context,
      randomness);
}

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_87_portable_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_mut(libcrux_ml_dsa_types_as_ref_9b_32(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Generate a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_180 *uu____0 = libcrux_ml_dsa_types_as_ref_9b_32(signing_key);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_pre_hashed_shake128(uu____0,
      message,
      context,
      Eurydice_array_to_slice_mut_6e(&pre_hash_buffer),
      randomness);
}

/**
 Verify an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_portable_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify(libcrux_ml_dsa_types_as_ref_7f_d8(verification_key),
      message,
      context,
      libcrux_ml_dsa_types_as_ref_c5_c2(signature));
}

/**
 Verify a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  Eurydice_arr_60 pre_hash_buffer = { .data = { 0U } };
  const Eurydice_arr_51 *uu____0 = libcrux_ml_dsa_types_as_ref_7f_d8(verification_key);
  Eurydice_borrow_slice_u8 uu____1 = message;
  Eurydice_borrow_slice_u8 uu____2 = context;
  Eurydice_mut_borrow_slice_u8 uu____3 = Eurydice_array_to_slice_mut_6e(&pre_hash_buffer);
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify_pre_hashed_shake128(uu____0,
      uu____1,
      uu____2,
      uu____3,
      libcrux_ml_dsa_types_as_ref_c5_c2(signature));
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa87_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa87_portable_H
#define libcrux_mldsa87_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_mldsa_core.h"

/**
 Generate an ML-DSA-87 Key Pair
*/
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair
libcrux_ml_dsa_ml_dsa_87_portable_generate_key_pair(Eurydice_arr_60 randomness);

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_portable_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Generate an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_87_portable_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
);

/**
 Generate a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_87_portable_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Verify an ML-DSA-87 Signature

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_portable_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

/**
 Verify a HashML-DSA-87 Signature, with a SHAKE128 pre-hashing

 The parameter `context` is used for domain separation
 and is a byte string of length at most 255 bytes. It
 may also be empty.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_87_portable_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa87_portable_H_DEFINED
#endif /* libcrux_mldsa87_portable_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mldsa_avx2.h"

#include "libcrux_sha3_internal.h"
#include "libcrux_sha3_avx2.h"
#include "libcrux_sha3.h"
#include "libcrux_mldsa_portable.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_sha3_internal.h"
#include "internal/libcrux_mldsa_portable.h"
#include "internal/libcrux_mldsa_core.h"

/**
 Init the state and absorb 4 blocks in parallel.
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  Eurydice_arr_05 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state, input0, input1, input2, input3);
  return state;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_26
libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_shake256(
  Eurydice_borrow_slice_u8 input
)
{
  Eurydice_arr_26 state = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state, input);
  return state;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  Eurydice_arr_05 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(&state, input0, input1, input2, input3);
  return state;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_shake256(Eurydice_arr_26 *state)
{
  Eurydice_arr_3d out = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(state,
    Eurydice_array_to_slice_mut_d4(&out));
  return out;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4(Eurydice_arr_05 *state)
{
  Eurydice_arr_3d out0 = { .data = { 0U } };
  Eurydice_arr_3d out1 = { .data = { 0U } };
  Eurydice_arr_3d out2 = { .data = { 0U } };
  Eurydice_arr_3d out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(state,
    Eurydice_array_to_slice_mut_d4(&out0),
    Eurydice_array_to_slice_mut_d4(&out1),
    Eurydice_array_to_slice_mut_d4(&out2),
    Eurydice_array_to_slice_mut_d4(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_3d_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks(
  Eurydice_arr_05 *state,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
)
{
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(state,
    Eurydice_array_to_slice_mut_a8(out0),
    Eurydice_array_to_slice_mut_a8(out1),
    Eurydice_array_to_slice_mut_a8(out2),
    Eurydice_array_to_slice_mut_a8(out3));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block(Eurydice_arr_05 *state)
{
  Eurydice_arr_27 out0 = { .data = { 0U } };
  Eurydice_arr_27 out1 = { .data = { 0U } };
  Eurydice_arr_27 out2 = { .data = { 0U } };
  Eurydice_arr_27 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(state,
    Eurydice_array_to_slice_mut_7b(&out0),
    Eurydice_array_to_slice_mut_7b(&out1),
    Eurydice_array_to_slice_mut_7b(&out2),
    Eurydice_array_to_slice_mut_7b(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_27_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_shake256(Eurydice_arr_26 *state)
{
  Eurydice_arr_3d out = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(state,
    Eurydice_array_to_slice_mut_d4(&out));
  return out;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4(Eurydice_arr_05 *state)
{
  Eurydice_arr_3d out0 = { .data = { 0U } };
  Eurydice_arr_3d out1 = { .data = { 0U } };
  Eurydice_arr_3d out2 = { .data = { 0U } };
  Eurydice_arr_3d out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(state,
    Eurydice_array_to_slice_mut_d4(&out0),
    Eurydice_array_to_slice_mut_d4(&out1),
    Eurydice_array_to_slice_mut_d4(&out2),
    Eurydice_array_to_slice_mut_d4(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_3d_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

/**
 Init the state and absorb 4 blocks in parallel.
*/
/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_3b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  return libcrux_ml_dsa_hash_functions_simd256_init_absorb(input0, input1, input2, input3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks_3b(
  Eurydice_arr_05 *self,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
)
{
  libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks(self, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(Eurydice_arr_05 *self)
{
  return libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_26
libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_8c(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_shake256(input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_8c(Eurydice_arr_26 *self)
{
  return libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_shake256(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_8c(Eurydice_arr_26 *self)
{
  return libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_shake256(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4_ad(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  return libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4(input0, input1, input2, input3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4_ad(Eurydice_arr_05 *self)
{
  return libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(Eurydice_arr_05 *self)
{
  return libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4(self);
}

/**
 Create an all-zero vector coefficient
*/
KRML_ATTRIBUTE_TARGET("avx2") __m256i libcrux_ml_dsa_simd_avx2_vector_type_zero(void)
{
  return mm256_setzero_si256();
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2") KRML_MUSTINLINE __m256i libcrux_ml_dsa_simd_avx2_zero_a2(void)
{
  return libcrux_ml_dsa_simd_avx2_vector_type_zero();
}

/**
 Create a coefficient from an `i32` array
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_vector_type_from_coefficient_array(
  Eurydice_dst_ref_shared_fc coefficient_array,
  __m256i *out
)
{
  out[0U] = mm256_loadu_si256_i32(coefficient_array);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_from_coefficient_array_a2(
  Eurydice_dst_ref_shared_fc coefficient_array,
  __m256i *out
)
{
  libcrux_ml_dsa_simd_avx2_vector_type_from_coefficient_array(coefficient_array, out);
}

/**
 Write out the coefficient to an `i32` array
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_vector_type_to_coefficient_array(
  const __m256i *value,
  Eurydice_dst_ref_mut_fc out
)
{
  mm256_storeu_si256_i32(out, value[0U]);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_to_coefficient_array_a2(
  const __m256i *value,
  Eurydice_dst_ref_mut_fc out
)
{
  libcrux_ml_dsa_simd_avx2_vector_type_to_coefficient_array(value, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_add(__m256i *lhs, const __m256i *rhs)
{
  lhs[0U] = mm256_add_epi32(lhs[0U], rhs[0U]);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_add_a2(__m256i *lhs, const __m256i *rhs)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_add(lhs, rhs);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_subtract(__m256i *lhs, const __m256i *rhs)
{
  lhs[0U] = mm256_sub_epi32(lhs[0U], rhs[0U]);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_subtract_a2(__m256i *lhs, const __m256i *rhs)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_subtract(lhs, rhs);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline bool
libcrux_ml_dsa_simd_avx2_arithmetic_infinity_norm_exceeds(
  const __m256i *simd_unit,
  int32_t bound
)
{
  __m256i absolute_values = mm256_abs_epi32(simd_unit[0U]);
  __m256i bound0 = mm256_set1_epi32(bound - (int32_t)1);
  __m256i compare_with_bound = mm256_cmpgt_epi32(absolute_values, bound0);
  int32_t result = mm256_testz_si256(compare_with_bound, compare_with_bound);
  return result != (int32_t)1;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE bool
libcrux_ml_dsa_simd_avx2_infinity_norm_exceeds_a2(const __m256i *simd_unit, int32_t bound)
{
  return libcrux_ml_dsa_simd_avx2_arithmetic_infinity_norm_exceeds(simd_unit, bound);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline __m256i
libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives_ret(const __m256i *t)
{
  __m256i signs = mm256_srai_epi32((int32_t)31, t[0U], __m256i);
  __m256i
  conditional_add_field_modulus =
    mm256_and_si256(signs,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS));
  return mm256_add_epi32(t[0U], conditional_add_field_modulus);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_arithmetic_decompose(
  int32_t gamma2,
  const __m256i *r,
  __m256i *r0,
  __m256i *r1
)
{
  __m256i r2 = libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives_ret(r);
  __m256i ceil_of_r_by_128 = mm256_add_epi32(r2, mm256_set1_epi32((int32_t)127));
  __m256i ceil_of_r_by_1280 = mm256_srai_epi32((int32_t)7, ceil_of_r_by_128, __m256i);
  switch (gamma2)
  {
    case 95232:
      {
        __m256i result = mm256_mullo_epi32(ceil_of_r_by_1280, mm256_set1_epi32((int32_t)11275));
        __m256i result0 = mm256_add_epi32(result, mm256_set1_epi32((int32_t)1 << 23U));
        __m256i result1 = mm256_srai_epi32((int32_t)24, result0, __m256i);
        __m256i mask = mm256_sub_epi32(mm256_set1_epi32((int32_t)43), result1);
        __m256i mask0 = mm256_srai_epi32((int32_t)31, mask, __m256i);
        __m256i not_result = mm256_xor_si256(result1, mask0);
        r1[0U] = mm256_and_si256(result1, not_result);
        break;
      }
    case 261888:
      {
        __m256i result = mm256_mullo_epi32(ceil_of_r_by_1280, mm256_set1_epi32((int32_t)1025));
        __m256i result0 = mm256_add_epi32(result, mm256_set1_epi32((int32_t)1 << 21U));
        __m256i result1 = mm256_srai_epi32((int32_t)22, result0, __m256i);
        r1[0U] = mm256_and_si256(result1, mm256_set1_epi32((int32_t)15));
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  int32_t alpha = gamma2 * (int32_t)2;
  __m256i r0_tmp = mm256_mullo_epi32(r1[0U], mm256_set1_epi32(alpha));
  __m256i r0_tmp0 = mm256_sub_epi32(r2, r0_tmp);
  __m256i
  field_modulus_halved =
    mm256_set1_epi32((LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS - (int32_t)1) / (int32_t)2);
  __m256i mask = mm256_sub_epi32(field_modulus_halved, r0_tmp0);
  __m256i mask0 = mm256_srai_epi32((int32_t)31, mask, __m256i);
  __m256i
  field_modulus_and_mask =
    mm256_and_si256(mask0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS));
  r0[0U] = mm256_sub_epi32(r0_tmp0, field_modulus_and_mask);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_decompose_a2(
  int32_t gamma2,
  const __m256i *simd_unit,
  __m256i *low,
  __m256i *high
)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_decompose(gamma2, simd_unit, low, high);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_arithmetic_compute_hint(
  const __m256i *low,
  const __m256i *high,
  int32_t gamma2,
  __m256i *hint
)
{
  __m256i minus_gamma2 = mm256_set1_epi32(-gamma2);
  __m256i gamma20 = mm256_set1_epi32(gamma2);
  __m256i low_within_bound = mm256_cmpgt_epi32(mm256_abs_epi32(low[0U]), gamma20);
  __m256i low_equals_minus_gamma2 = mm256_cmpeq_epi32(low[0U], minus_gamma2);
  __m256i
  low_equals_minus_gamma2_and_high_is_nonzero =
    mm256_sign_epi32(low_equals_minus_gamma2,
      high[0U]);
  hint[0U] = mm256_or_si256(low_within_bound, low_equals_minus_gamma2_and_high_is_nonzero);
  int32_t hints_mask = mm256_movemask_ps(mm256_castsi256_ps(hint[0U]));
  hint[0U] = mm256_and_si256(hint[0U], mm256_set1_epi32((int32_t)1));
  return (size_t)core_num__i32__count_ones(hints_mask);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_compute_hint_a2(
  const __m256i *low,
  const __m256i *high,
  int32_t gamma2,
  __m256i *hint
)
{
  return libcrux_ml_dsa_simd_avx2_arithmetic_compute_hint(low, high, gamma2, hint);
}

typedef struct core_core_arch_x86___m256i_x2_s
{
  __m256i fst;
  __m256i snd;
}
core_core_arch_x86___m256i_x2;

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_arithmetic_use_hint(int32_t gamma2, const __m256i *r, __m256i *hint)
{
  core_core_arch_x86___m256i_x2
  uu____0 = { .fst = mm256_setzero_si256(), .snd = mm256_setzero_si256() };
  __m256i r0 = uu____0.fst;
  __m256i r1 = uu____0.snd;
  libcrux_ml_dsa_simd_avx2_arithmetic_decompose(gamma2, r, &r0, &r1);
  __m256i all_zeros = mm256_setzero_si256();
  __m256i negate_hints = vec256_blendv_epi32(all_zeros, hint[0U], r0);
  __m256i negate_hints0 = mm256_slli_epi32((int32_t)1, negate_hints, __m256i);
  __m256i hints = mm256_sub_epi32(hint[0U], negate_hints0);
  __m256i r1_plus_hints = mm256_add_epi32(r1, hints);
  switch (gamma2)
  {
    case 95232:
      {
        __m256i max = mm256_set1_epi32((int32_t)43);
        r1_plus_hints = vec256_blendv_epi32(r1_plus_hints, max, r1_plus_hints);
        __m256i greater_than_or_equal_to_max = mm256_cmpgt_epi32(r1_plus_hints, max);
        hint[0U] = vec256_blendv_epi32(r1_plus_hints, all_zeros, greater_than_or_equal_to_max);
        break;
      }
    case 261888:
      {
        hint[0U] = mm256_and_si256(r1_plus_hints, mm256_set1_epi32((int32_t)15));
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_use_hint_a2(int32_t gamma2, const __m256i *simd_unit, __m256i *hint)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_use_hint(gamma2, simd_unit, hint);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_aux(
  __m256i field_modulus,
  __m256i inverse_of_modulus_mod_montgomery_r,
  __m256i *lhs,
  const __m256i *rhs
)
{
  __m256i prod02 = mm256_mul_epi32(lhs[0U], rhs[0U]);
  __m256i
  prod13 =
    mm256_mul_epi32(mm256_shuffle_epi32((int32_t)245, lhs[0U], __m256i),
      mm256_shuffle_epi32((int32_t)245, rhs[0U], __m256i));
  __m256i k02 = mm256_mul_epi32(prod02, inverse_of_modulus_mod_montgomery_r);
  __m256i k13 = mm256_mul_epi32(prod13, inverse_of_modulus_mod_montgomery_r);
  __m256i c02 = mm256_mul_epi32(k02, field_modulus);
  __m256i c13 = mm256_mul_epi32(k13, field_modulus);
  __m256i res02 = mm256_sub_epi32(prod02, c02);
  __m256i res13 = mm256_sub_epi32(prod13, c13);
  __m256i res02_shifted = mm256_shuffle_epi32((int32_t)245, res02, __m256i);
  lhs[0U] = mm256_blend_epi32((int32_t)170, res02_shifted, res13, __m256i);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(__m256i *lhs, const __m256i *rhs)
{
  __m256i field_modulus = mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  __m256i
  inverse_of_modulus_mod_montgomery_r =
    mm256_set1_epi32((int32_t)LIBCRUX_ML_DSA_SIMD_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_aux(field_modulus,
    inverse_of_modulus_mod_montgomery_r,
    lhs,
    rhs);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_montgomery_multiply_a2(__m256i *lhs, const __m256i *rhs)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(lhs, rhs);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives(__m256i *t)
{
  t[0U] = libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives_ret(t);
}

KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_power2round(__m256i *r0, __m256i *r1)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives(r0);
  r1[0U] =
    mm256_add_epi32(r0[0U],
      mm256_set1_epi32(((int32_t)1 <<
          (uint32_t)(LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T - (size_t)1U))
        - (int32_t)1));
  r1[0U] = mm256_srai_epi32((int32_t)13, r1[0U], __m256i);
  __m256i tmp = mm256_slli_epi32((int32_t)13, r1[0U], __m256i);
  r0[0U] = mm256_sub_epi32(r0[0U], tmp);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_power2round_a2(__m256i *t0, __m256i *t1)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_power2round(t0, t1);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_bytestream_to_potential_coefficients(
  Eurydice_borrow_slice_u8 serialized
)
{
  Eurydice_arr_60 serialized_extended = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_to_mut_6e(&serialized_extended, (size_t)24U),
    serialized,
    uint8_t);
  __m256i
  coefficients = mm256_loadu_si256_u8(Eurydice_array_to_slice_shared_6e(&serialized_extended));
  __m256i
  coefficients0 =
    mm256_permutevar8x32_epi32(coefficients,
      mm256_set_epi32((int32_t)0,
        (int32_t)5,
        (int32_t)4,
        (int32_t)3,
        (int32_t)0,
        (int32_t)2,
        (int32_t)1,
        (int32_t)0));
  __m256i
  coefficients1 =
    mm256_shuffle_epi8(coefficients0,
      mm256_set_epi8((int8_t)-1,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)5,
        (int8_t)4,
        (int8_t)3,
        (int8_t)-1,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0,
        (int8_t)-1,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)5,
        (int8_t)4,
        (int8_t)3,
        (int8_t)-1,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0));
  return
    mm256_and_si256(coefficients1,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_LESS_THAN_FIELD_MODULUS_BYTESTREAM_TO_POTENTIAL_COEFFICIENTS_COEFFICIENT_MASK));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_sample(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
)
{
  __m256i field_modulus = mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  __m256i
  potential_coefficients =
    libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_bytestream_to_potential_coefficients(input);
  __m256i compare_with_field_modulus = mm256_cmpgt_epi32(field_modulus, potential_coefficients);
  int32_t good = mm256_movemask_ps(mm256_castsi256_ps(compare_with_field_modulus));
  int32_t good_lower_half = good & (int32_t)15;
  int32_t good_upper_half = good >> 4U;
  Eurydice_arr_88
  lower_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_lower_half];
  __m128i lower_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&lower_shuffles));
  __m128i lower_coefficients = mm256_castsi256_si128(potential_coefficients);
  __m128i lower_coefficients0 = mm_shuffle_epi8(lower_coefficients, lower_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)4U })),
    lower_coefficients0);
  size_t sampled_count = (size_t)core_num__i32__count_ones(good_lower_half);
  Eurydice_arr_88
  upper_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_upper_half];
  __m128i upper_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&upper_shuffles));
  __m128i
  upper_coefficients = mm256_extracti128_si256((int32_t)1, potential_coefficients, __m128i);
  __m128i upper_coefficients0 = mm_shuffle_epi8(upper_coefficients, upper_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = sampled_count,
          .end = sampled_count + (size_t)4U
        }
      )),
    upper_coefficients0);
  size_t uu____0 = sampled_count;
  return uu____0 + (size_t)core_num__i32__count_ones(good_upper_half);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return
    libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_sample(randomness,
      out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_4(
  Eurydice_borrow_slice_u8 bytes
)
{
  __m256i
  bytes_in_simd_unit =
    mm256_set_epi32((int32_t)bytes.ptr[3U],
      (int32_t)bytes.ptr[3U],
      (int32_t)bytes.ptr[2U],
      (int32_t)bytes.ptr[2U],
      (int32_t)bytes.ptr[1U],
      (int32_t)bytes.ptr[1U],
      (int32_t)bytes.ptr[0U],
      (int32_t)bytes.ptr[0U]);
  __m256i
  coefficients =
    mm256_srlv_epi32(bytes_in_simd_unit,
      mm256_set_epi32((int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0));
  return
    mm256_and_si256(coefficients,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_DESERIALIZE_TO_UNSIGNED_WHEN_ETA_IS_4_COEFFICIENT_MASK));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_2(
  Eurydice_borrow_slice_u8 bytes
)
{
  __m256i
  bytes_in_simd_unit =
    mm256_set_epi32((int32_t)bytes.ptr[2U],
      (int32_t)bytes.ptr[2U],
      (int32_t)bytes.ptr[2U] << 8U | (int32_t)bytes.ptr[1U],
      (int32_t)bytes.ptr[1U],
      (int32_t)bytes.ptr[1U],
      (int32_t)bytes.ptr[1U] << 8U | (int32_t)bytes.ptr[0U],
      (int32_t)bytes.ptr[0U],
      (int32_t)bytes.ptr[0U]);
  __m256i
  coefficients =
    mm256_srlv_epi32(bytes_in_simd_unit,
      mm256_set_epi32((int32_t)5,
        (int32_t)2,
        (int32_t)7,
        (int32_t)4,
        (int32_t)1,
        (int32_t)6,
        (int32_t)3,
        (int32_t)0));
  return
    mm256_and_si256(coefficients,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_DESERIALIZE_TO_UNSIGNED_WHEN_ETA_IS_2_COEFFICIENT_MASK));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        return
          libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_4(serialized);
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return
    libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_2(serialized);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.shift_interval
with const generics
- ETA= 2
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_fd(__m256i coefficients)
{
  __m256i uu____0;
  __m256i quotient = mm256_mullo_epi32(coefficients, mm256_set1_epi32((int32_t)26));
  __m256i quotient0 = mm256_srai_epi32((int32_t)7, quotient, __m256i);
  __m256i quotient1 = mm256_mullo_epi32(quotient0, mm256_set1_epi32((int32_t)5));
  __m256i coefficients_mod_5 = mm256_sub_epi32(coefficients, quotient1);
  uu____0 = mm256_sub_epi32(mm256_set1_epi32((int32_t)(size_t)2U), coefficients_mod_5);
  return uu____0;
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.sample
with const generics
- ETA= 2
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_fd(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
)
{
  __m256i
  potential_coefficients =
    libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned(libcrux_ml_dsa_constants_Eta_Four,
      input);
  int32_t interval_boundary;
  interval_boundary = (int32_t)15;
  __m256i
  compare_with_interval_boundary =
    mm256_cmpgt_epi32(mm256_set1_epi32(interval_boundary),
      potential_coefficients);
  int32_t good = mm256_movemask_ps(mm256_castsi256_ps(compare_with_interval_boundary));
  int32_t good_lower_half = good & (int32_t)15;
  int32_t good_upper_half = good >> 4U;
  __m256i
  shifted =
    libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_fd(potential_coefficients);
  Eurydice_arr_88
  lower_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_lower_half];
  __m128i lower_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&lower_shuffles));
  __m128i lower_coefficients = mm256_castsi256_si128(shifted);
  __m128i lower_coefficients0 = mm_shuffle_epi8(lower_coefficients, lower_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)4U })),
    lower_coefficients0);
  size_t sampled_count = (size_t)core_num__i32__count_ones(good_lower_half);
  Eurydice_arr_88
  upper_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_upper_half];
  __m128i upper_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&upper_shuffles));
  __m128i upper_coefficients = mm256_extracti128_si256((int32_t)1, shifted, __m128i);
  __m128i upper_coefficients0 = mm_shuffle_epi8(upper_coefficients, upper_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = sampled_count,
          .end = sampled_count + (size_t)4U
        }
      )),
    upper_coefficients0);
  size_t uu____0 = sampled_count;
  return uu____0 + (size_t)core_num__i32__count_ones(good_upper_half);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_2_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_fd(randomness, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.shift_interval
with const generics
- ETA= 4
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_ac(__m256i coefficients)
{
  return mm256_sub_epi32(mm256_set1_epi32((int32_t)(size_t)4U), coefficients);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.sample
with const generics
- ETA= 4
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_ac(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
)
{
  __m256i
  potential_coefficients =
    libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned(libcrux_ml_dsa_constants_Eta_Four,
      input);
  int32_t interval_boundary;
  interval_boundary = (int32_t)9;
  __m256i
  compare_with_interval_boundary =
    mm256_cmpgt_epi32(mm256_set1_epi32(interval_boundary),
      potential_coefficients);
  int32_t good = mm256_movemask_ps(mm256_castsi256_ps(compare_with_interval_boundary));
  int32_t good_lower_half = good & (int32_t)15;
  int32_t good_upper_half = good >> 4U;
  __m256i
  shifted =
    libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_ac(potential_coefficients);
  Eurydice_arr_88
  lower_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_lower_half];
  __m128i lower_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&lower_shuffles));
  __m128i lower_coefficients = mm256_castsi256_si128(shifted);
  __m128i lower_coefficients0 = mm_shuffle_epi8(lower_coefficients, lower_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)4U })),
    lower_coefficients0);
  size_t sampled_count = (size_t)core_num__i32__count_ones(good_lower_half);
  Eurydice_arr_88
  upper_shuffles =
    LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE.data[(size_t)good_upper_half];
  __m128i upper_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&upper_shuffles));
  __m128i upper_coefficients = mm256_extracti128_si256((int32_t)1, shifted, __m128i);
  __m128i upper_coefficients0 = mm_shuffle_epi8(upper_coefficients, upper_shuffles0);
  mm_storeu_si128_i32(Eurydice_slice_subslice_mut_46(output,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = sampled_count,
          .end = sampled_count + (size_t)4U
        }
      )),
    upper_coefficients0);
  size_t uu____0 = sampled_count;
  return uu____0 + (size_t)core_num__i32__count_ones(good_upper_half);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_4_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_ac(randomness, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19_aux(
  __m256i simd_unit_shifted
)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit_shifted,
      mm256_set_epi32((int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)12, adjacent_2_combined, __m256i);
  return
    mm256_shuffle_epi8(adjacent_2_combined0,
      mm256_set_epi8((int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)12,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)8,
        (int8_t)4,
        (int8_t)3,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)12,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)8,
        (int8_t)4,
        (int8_t)3,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_60 serialized = { .data = { 0U } };
  __m256i
  simd_unit_shifted =
    mm256_sub_epi32(mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_2_POW_19),
      simd_unit[0U]);
  __m256i
  adjacent_4_combined =
    libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19_aux(simd_unit_shifted);
  __m128i lower_4 = mm256_castsi256_si128(adjacent_4_combined);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_364(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_4);
  __m128i upper_4 = mm256_extracti128_si256((int32_t)1, adjacent_4_combined, __m128i);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_364(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)10U, .end = (size_t)26U })),
    upper_4);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_36(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)20U })),
    uint8_t);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17_aux(
  __m256i simd_unit_shifted
)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit_shifted,
      mm256_set_epi32((int32_t)0,
        (int32_t)14,
        (int32_t)0,
        (int32_t)14,
        (int32_t)0,
        (int32_t)14,
        (int32_t)0,
        (int32_t)14));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)14, adjacent_2_combined, __m256i);
  __m256i every_second_element = mm256_bsrli_epi128((int32_t)8, adjacent_2_combined0, __m256i);
  __m256i
  every_second_element_shifted = mm256_slli_epi64((int32_t)36, every_second_element, __m256i);
  __m256i
  adjacent_4_combined = mm256_add_epi64(adjacent_2_combined0, every_second_element_shifted);
  return
    mm256_srlv_epi64(adjacent_4_combined,
      mm256_set_epi64x((int64_t)28LL, (int64_t)0LL, (int64_t)28LL, (int64_t)0LL));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_60 serialized = { .data = { 0U } };
  __m256i
  simd_unit_shifted =
    mm256_sub_epi32(mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_2_POW_17),
      simd_unit[0U]);
  __m256i
  adjacent_4_combined =
    libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17_aux(simd_unit_shifted);
  __m128i lower_4 = mm256_castsi256_si128(adjacent_4_combined);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_364(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_4);
  __m128i upper_4 = mm256_extracti128_si256((int32_t)1, adjacent_4_combined, __m128i);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_364(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)9U, .end = (size_t)25U })),
    upper_4);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_36(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)18U })),
    uint8_t);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  switch (gamma1_exponent)
  {
    case 17U:
      {
        break;
      }
    case 19U:
      {
        libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19(simd_unit,
          serialized);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17(simd_unit,
    serialized);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_gamma1_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize(simd_unit, serialized, gamma1_exponent);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_17_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  __m128i
  serialized_lower =
    mm_loadu_si128(Eurydice_slice_subslice_shared_7e(serialized,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })));
  __m128i
  serialized_upper =
    mm_loadu_si128(Eurydice_slice_subslice_shared_7e(serialized,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)2U, .end = (size_t)18U })));
  __m256i serialized_vec = mm256_set_m128i(serialized_upper, serialized_lower);
  __m256i
  coefficients =
    mm256_shuffle_epi8(serialized_vec,
      mm256_set_epi8((int8_t)-1,
        (int8_t)15,
        (int8_t)14,
        (int8_t)13,
        (int8_t)-1,
        (int8_t)13,
        (int8_t)12,
        (int8_t)11,
        (int8_t)-1,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)7,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)6,
        (int8_t)5,
        (int8_t)4,
        (int8_t)-1,
        (int8_t)4,
        (int8_t)3,
        (int8_t)2,
        (int8_t)-1,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0));
  __m256i
  coefficients0 =
    mm256_srlv_epi32(coefficients,
      mm256_set_epi32((int32_t)6,
        (int32_t)4,
        (int32_t)2,
        (int32_t)0,
        (int32_t)6,
        (int32_t)4,
        (int32_t)2,
        (int32_t)0));
  __m256i
  coefficients1 =
    mm256_and_si256(coefficients0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_17_TIMES_2_MASK));
  out[0U] = coefficients1;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_19_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  __m128i
  serialized_lower =
    mm_loadu_si128(Eurydice_slice_subslice_shared_7e(serialized,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })));
  __m128i
  serialized_upper =
    mm_loadu_si128(Eurydice_slice_subslice_shared_7e(serialized,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)4U, .end = (size_t)20U })));
  __m256i serialized_vec = mm256_set_m128i(serialized_upper, serialized_lower);
  __m256i
  coefficients =
    mm256_shuffle_epi8(serialized_vec,
      mm256_set_epi8((int8_t)-1,
        (int8_t)15,
        (int8_t)14,
        (int8_t)13,
        (int8_t)-1,
        (int8_t)13,
        (int8_t)12,
        (int8_t)11,
        (int8_t)-1,
        (int8_t)10,
        (int8_t)9,
        (int8_t)8,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)7,
        (int8_t)-1,
        (int8_t)7,
        (int8_t)6,
        (int8_t)5,
        (int8_t)-1,
        (int8_t)4,
        (int8_t)3,
        (int8_t)2,
        (int8_t)-1,
        (int8_t)2,
        (int8_t)1,
        (int8_t)0));
  __m256i
  coefficients0 =
    mm256_srlv_epi32(coefficients,
      mm256_set_epi32((int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0));
  __m256i
  coefficients1 =
    mm256_and_si256(coefficients0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_19_TIMES_2_MASK));
  out[0U] = coefficients1;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out,
  size_t gamma1_exponent
)
{
  switch ((uint8_t)gamma1_exponent)
  {
    case 17U:
      {
        libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_17_unsigned(serialized,
          out);
        break;
      }
    case 19U:
      {
        libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_19_unsigned(serialized,
          out);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  int32_t gamma1;
  switch ((uint8_t)gamma1_exponent)
  {
    case 17U:
      {
        gamma1 = LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_17;
        break;
      }
    case 19U:
      {
        gamma1 = LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_19;
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  out[0U] = mm256_sub_epi32(mm256_set1_epi32(gamma1), out[0U]);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_gamma1_deserialize_a2(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out,
  size_t gamma1_exponent
)
{
  libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize(serialized, out, gamma1_exponent);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m128i
libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_4(const __m256i *simd_unit)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit[0U],
      mm256_set_epi32((int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)28, adjacent_2_combined, __m256i);
  __m256i
  adjacent_4_combined =
    mm256_permutevar8x32_epi32(adjacent_2_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)6,
        (int32_t)2,
        (int32_t)4,
        (int32_t)0));
  __m128i adjacent_4_combined0 = mm256_castsi256_si128(adjacent_4_combined);
  return
    mm_shuffle_epi8(adjacent_4_combined0,
      mm_set_epi8((int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)12,
        (int8_t)4,
        (int8_t)8,
        (int8_t)0));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_6(const __m256i *simd_unit)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit[0U],
      mm256_set_epi32((int32_t)0,
        (int32_t)26,
        (int32_t)0,
        (int32_t)26,
        (int32_t)0,
        (int32_t)26,
        (int32_t)0,
        (int32_t)26));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)26, adjacent_2_combined, __m256i);
  __m256i
  adjacent_3_combined =
    mm256_shuffle_epi8(adjacent_2_combined0,
      mm256_set_epi8((int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)1,
        (int8_t)0,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)1,
        (int8_t)0));
  __m256i
  adjacent_3_combined0 =
    mm256_mullo_epi16(adjacent_3_combined,
      mm256_set_epi16((int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 4U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 0U,
        (int16_t)1 << 4U));
  return
    mm256_srlv_epi32(adjacent_3_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)4));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_91 serialized = { .data = { 0U } };
  switch ((uint8_t)out.meta)
  {
    case 4U:
      {
        mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_367(&serialized,
            (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
          libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_4(simd_unit));
        Eurydice_slice_copy(out,
          Eurydice_array_to_subslice_shared_361(&serialized,
            (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)4U })),
          uint8_t);
        break;
      }
    case 6U:
      {
        __m256i
        adjacent_3_combined = libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_6(simd_unit);
        __m128i lower_3 = mm256_castsi256_si128(adjacent_3_combined);
        __m128i upper_3 = mm256_extracti128_si256((int32_t)1, adjacent_3_combined, __m128i);
        mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_367(&serialized,
            (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
          lower_3);
        mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_367(&serialized,
            (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)3U, .end = (size_t)19U })),
          upper_3);
        Eurydice_slice_copy(out,
          Eurydice_array_to_subslice_shared_361(&serialized,
            (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)6U })),
          uint8_t);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_commitment_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize(simd_unit, serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m128i
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4_aux(__m256i simd_unit_shifted)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit_shifted,
      mm256_set_epi32((int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28,
        (int32_t)0,
        (int32_t)28));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)28, adjacent_2_combined, __m256i);
  __m256i
  adjacent_4_combined =
    mm256_permutevar8x32_epi32(adjacent_2_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)6,
        (int32_t)2,
        (int32_t)4,
        (int32_t)0));
  __m128i adjacent_4_combined0 = mm256_castsi256_si128(adjacent_4_combined);
  return
    mm_shuffle_epi8(adjacent_4_combined0,
      mm_set_epi8((int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)-16,
        (int8_t)12,
        (int8_t)4,
        (int8_t)8,
        (int8_t)0));
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_88 serialized = { .data = { 0U } };
  __m256i
  simd_unit_shifted =
    mm256_sub_epi32(mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_ETA_4),
      simd_unit[0U]);
  __m128i
  adjacent_4_combined =
    libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4_aux(simd_unit_shifted);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_368(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
    adjacent_4_combined);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_362(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)4U })),
    uint8_t);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m128i
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2_aux(__m256i simd_unit_shifted)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit_shifted,
      mm256_set_epi32((int32_t)0,
        (int32_t)29,
        (int32_t)0,
        (int32_t)29,
        (int32_t)0,
        (int32_t)29,
        (int32_t)0,
        (int32_t)29));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)29, adjacent_2_combined, __m256i);
  __m256i
  adjacent_4_combined =
    mm256_shuffle_epi8(adjacent_2_combined0,
      mm256_set_epi8((int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)-1,
        (int8_t)0,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)-1,
        (int8_t)0));
  __m256i
  adjacent_4_combined0 =
    mm256_madd_epi16(adjacent_4_combined,
      mm256_set_epi16((int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)1 << 6U,
        (int16_t)1,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)0,
        (int16_t)1 << 6U,
        (int16_t)1));
  __m256i
  adjacent_6_combined =
    mm256_permutevar8x32_epi32(adjacent_4_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)4,
        (int32_t)0));
  __m128i adjacent_6_combined0 = mm256_castsi256_si128(adjacent_6_combined);
  __m128i
  adjacent_6_combined1 =
    mm_sllv_epi32(adjacent_6_combined0,
      mm_set_epi32((int32_t)0, (int32_t)0, (int32_t)0, (int32_t)20));
  return mm_srli_epi64((int32_t)20, adjacent_6_combined1, __m128i);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_88 serialized = { .data = { 0U } };
  __m256i
  simd_unit_shifted =
    mm256_sub_epi32(mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_ETA_2),
      simd_unit[0U]);
  __m128i
  adjacent_6_combined =
    libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2_aux(simd_unit_shifted);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_368(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
    adjacent_6_combined);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_362(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)3U })),
    uint8_t);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize(
  libcrux_ml_dsa_constants_Eta eta,
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4(simd_unit, serialized);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2(simd_unit, serialized);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_error_serialize_a2(
  libcrux_ml_dsa_constants_Eta eta,
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  libcrux_ml_dsa_simd_avx2_encoding_error_serialize(eta, simd_unit, serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  __m256i
  unsigned0 = libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned(eta, serialized);
  int32_t eta_v;
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        eta_v = (int32_t)2;
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        eta_v = (int32_t)4;
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  out[0U] = mm256_sub_epi32(mm256_set1_epi32(eta_v), unsigned0);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_error_deserialize_a2(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  libcrux_ml_dsa_simd_avx2_encoding_error_deserialize(eta, serialized, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_encoding_t0_change_interval(const __m256i *simd_unit)
{
  __m256i
  interval_end =
    mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T0_POW_2_BITS_IN_LOWER_PART_OF_T_MINUS_ONE);
  return mm256_sub_epi32(interval_end, simd_unit[0U]);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m128i
libcrux_ml_dsa_simd_avx2_encoding_t0_serialize_aux(__m256i simd_unit)
{
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit,
      mm256_set_epi32((int32_t)0,
        (int32_t)19,
        (int32_t)0,
        (int32_t)19,
        (int32_t)0,
        (int32_t)19,
        (int32_t)0,
        (int32_t)19));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)19, adjacent_2_combined, __m256i);
  __m256i
  adjacent_4_combined =
    mm256_permutevar8x32_epi32(adjacent_2_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)0,
        (int32_t)6,
        (int32_t)4,
        (int32_t)2,
        (int32_t)0));
  __m256i
  adjacent_4_combined0 =
    mm256_sllv_epi32(adjacent_4_combined,
      mm256_set_epi32((int32_t)0,
        (int32_t)6,
        (int32_t)0,
        (int32_t)6,
        (int32_t)0,
        (int32_t)6,
        (int32_t)0,
        (int32_t)6));
  __m256i adjacent_4_combined1 = mm256_srli_epi64((int32_t)6, adjacent_4_combined0, __m256i);
  __m256i second_4_combined = mm256_bsrli_epi128((int32_t)8, adjacent_4_combined1, __m256i);
  __m256i least_12_bits_shifted_up = mm256_slli_epi64((int32_t)52, second_4_combined, __m256i);
  __m256i bits_sequential = mm256_add_epi64(adjacent_4_combined1, least_12_bits_shifted_up);
  __m256i
  bits_sequential0 =
    mm256_srlv_epi64(bits_sequential,
      mm256_set_epi64x((int64_t)0LL, (int64_t)0LL, (int64_t)12LL, (int64_t)0LL));
  return mm256_castsi256_si128(bits_sequential0);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_t0_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_88 serialized = { .data = { 0U } };
  __m256i simd_unit_changed = libcrux_ml_dsa_simd_avx2_encoding_t0_change_interval(simd_unit);
  __m128i
  bits_sequential = libcrux_ml_dsa_simd_avx2_encoding_t0_serialize_aux(simd_unit_changed);
  mm_storeu_bytes_si128(Eurydice_array_to_slice_mut_46(&serialized), bits_sequential);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_362(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)13U })),
    uint8_t);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_t0_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_ml_dsa_simd_avx2_encoding_t0_serialize(simd_unit, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  Eurydice_arr_88 serialized_extended = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_368(&serialized_extended,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)13U })),
    serialized,
    uint8_t);
  __m128i serialized0 = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&serialized_extended));
  __m256i serialized1 = mm256_set_m128i(serialized0, serialized0);
  __m256i
  coefficients =
    mm256_shuffle_epi8(serialized1,
      mm256_set_epi8((int8_t)-1,
        (int8_t)-1,
        (int8_t)12,
        (int8_t)11,
        (int8_t)-1,
        (int8_t)11,
        (int8_t)10,
        (int8_t)9,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)6,
        (int8_t)5,
        (int8_t)4,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)4,
        (int8_t)3,
        (int8_t)-1,
        (int8_t)3,
        (int8_t)2,
        (int8_t)1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)1,
        (int8_t)0));
  __m256i
  coefficients0 =
    mm256_srlv_epi32(coefficients,
      mm256_set_epi32((int32_t)3,
        (int32_t)6,
        (int32_t)1,
        (int32_t)4,
        (int32_t)7,
        (int32_t)2,
        (int32_t)5,
        (int32_t)0));
  __m256i
  coefficients1 =
    mm256_and_si256(coefficients0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T0_DESERIALIZE_UNSIGNED_COEFFICIENT_MASK));
  out[0U] = coefficients1;
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
)
{
  libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize_unsigned(serialized, out);
  out[0U] = libcrux_ml_dsa_simd_avx2_encoding_t0_change_interval(out);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_t0_deserialize_a2(Eurydice_borrow_slice_u8 serialized, __m256i *out)
{
  libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize(serialized, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_t1_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  Eurydice_arr_6d serialized = { .data = { 0U } };
  __m256i
  adjacent_2_combined =
    mm256_sllv_epi32(simd_unit[0U],
      mm256_set_epi32((int32_t)0,
        (int32_t)22,
        (int32_t)0,
        (int32_t)22,
        (int32_t)0,
        (int32_t)22,
        (int32_t)0,
        (int32_t)22));
  __m256i adjacent_2_combined0 = mm256_srli_epi64((int32_t)22, adjacent_2_combined, __m256i);
  __m256i
  adjacent_4_combined =
    mm256_permutevar8x32_epi32(adjacent_2_combined0,
      mm256_set_epi32((int32_t)0,
        (int32_t)0,
        (int32_t)6,
        (int32_t)4,
        (int32_t)0,
        (int32_t)0,
        (int32_t)2,
        (int32_t)0));
  __m256i
  adjacent_4_combined0 =
    mm256_sllv_epi32(adjacent_4_combined,
      mm256_set_epi32((int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12,
        (int32_t)0,
        (int32_t)12));
  __m256i adjacent_4_combined1 = mm256_srli_epi64((int32_t)12, adjacent_4_combined0, __m256i);
  __m128i lower_4 = mm256_castsi256_si128(adjacent_4_combined1);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_369(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_4);
  __m128i upper_4 = mm256_extracti128_si256((int32_t)1, adjacent_4_combined1, __m128i);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_369(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)5U, .end = (size_t)21U })),
    upper_4);
  Eurydice_slice_copy(out,
    Eurydice_array_to_subslice_shared_363(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)10U })),
    uint8_t);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_t1_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_ml_dsa_simd_avx2_encoding_t1_serialize(simd_unit, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_encoding_t1_deserialize(Eurydice_borrow_slice_u8 bytes, __m256i *out)
{
  Eurydice_arr_88 bytes_extended = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_368(&bytes_extended,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)10U })),
    bytes,
    uint8_t);
  __m128i bytes_loaded = mm_loadu_si128(Eurydice_array_to_slice_shared_46(&bytes_extended));
  __m256i bytes_loaded0 = mm256_set_m128i(bytes_loaded, bytes_loaded);
  __m256i
  coefficients =
    mm256_shuffle_epi8(bytes_loaded0,
      mm256_set_epi8((int8_t)-1,
        (int8_t)-1,
        (int8_t)9,
        (int8_t)8,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)8,
        (int8_t)7,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)7,
        (int8_t)6,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)6,
        (int8_t)5,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)4,
        (int8_t)3,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)3,
        (int8_t)2,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)2,
        (int8_t)1,
        (int8_t)-1,
        (int8_t)-1,
        (int8_t)1,
        (int8_t)0));
  __m256i
  coefficients0 =
    mm256_srlv_epi32(coefficients,
      mm256_set_epi32((int32_t)6,
        (int32_t)4,
        (int32_t)2,
        (int32_t)0,
        (int32_t)6,
        (int32_t)4,
        (int32_t)2,
        (int32_t)0));
  out[0U] =
    mm256_and_si256(coefficients0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T1_DESERIALIZE_COEFFICIENT_MASK));
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_t1_deserialize_a2(Eurydice_borrow_slice_u8 serialized, __m256i *out)
{
  libcrux_ml_dsa_simd_avx2_encoding_t1_deserialize(serialized, out);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(
  Eurydice_arr_cd0 *re,
  size_t index,
  __m256i zeta,
  size_t step_by,
  __m256i field_modulus,
  __m256i inverse_of_modulus_mod_montgomery_r
)
{
  __m256i t = re->data[index + step_by];
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_aux(field_modulus,
    inverse_of_modulus_mod_montgomery_r,
    &t,
    &zeta);
  re->data[index + step_by] = re->data[index];
  libcrux_ml_dsa_simd_avx2_arithmetic_subtract(&re->data[index + step_by], &t);
  libcrux_ml_dsa_simd_avx2_arithmetic_add(&re->data[index], &t);
}

/**
 This is equivalent to the pqclean 0 and 1

 This does 32 Montgomery multiplications (192 multiplications).
 This is the same as in pqclean. The only difference is locality of registers.
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6(Eurydice_arr_cd0 *re)
{
  __m256i field_modulus = mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  __m256i
  inverse_of_modulus_mod_montgomery_r =
    mm256_set1_epi32((int32_t)LIBCRUX_ML_DSA_SIMD_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R);
  __m256i zeta7 = mm256_set1_epi32((int32_t)25847);
  __m256i zeta60 = mm256_set1_epi32((int32_t)-2608894);
  __m256i zeta61 = mm256_set1_epi32((int32_t)-518909);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)1U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)2U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)3U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)8U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)8U + (size_t)1U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)8U + (size_t)2U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)8U + (size_t)3U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)1U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)2U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)0U + (size_t)3U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)16U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)16U + (size_t)1U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)16U + (size_t)2U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)16U + (size_t)3U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)1U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)2U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)3U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)12U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)12U + (size_t)1U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)12U + (size_t)2U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)12U + (size_t)3U,
    zeta7,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)1U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)2U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)4U + (size_t)3U,
    zeta60,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)20U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)20U + (size_t)1U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)20U + (size_t)2U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(re,
    (size_t)20U + (size_t)3U,
    zeta61,
    LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6,
    field_modulus,
    inverse_of_modulus_mod_montgomery_r);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 32
- STEP_BY= 4
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
)
{
  __m256i rhs = mm256_set1_epi32(zeta);
  size_t
  offset =
    index * (size_t)32U * (size_t)2U / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT;
  for (size_t i = offset; i < offset + (size_t)4U; i++)
  {
    size_t j = i;
    libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&re->data[j + (size_t)4U], &rhs);
    __m256i tmp = mm256_sub_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j + (size_t)4U] = tmp;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 16
- STEP_BY= 2
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
)
{
  __m256i rhs = mm256_set1_epi32(zeta);
  size_t
  offset =
    index * (size_t)16U * (size_t)2U / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT;
  for (size_t i = offset; i < offset + (size_t)2U; i++)
  {
    size_t j = i;
    libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&re->data[j + (size_t)2U], &rhs);
    __m256i tmp = mm256_sub_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] = tmp;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 8
- STEP_BY= 1
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
)
{
  __m256i rhs = mm256_set1_epi32(zeta);
  size_t
  offset = index * (size_t)8U * (size_t)2U / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT;
  for (size_t i = offset; i < offset + (size_t)1U; i++)
  {
    size_t j = i;
    libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&re->data[j + (size_t)1U], &rhs);
    __m256i tmp = mm256_sub_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] = tmp;
  }
}

/**
 Layer 5, 4, 3

 Each layer does 16 Montgomery multiplications -> 3*16 = 48 total
 pqclean does 4 * 4 on each layer -> 48 total | plus 4 * 4 shuffles every time (48)
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(re, (size_t)0U, (int32_t)237124);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(re, (size_t)1U, (int32_t)-777960);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(re, (size_t)2U, (int32_t)-876248);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(re, (size_t)3U, (int32_t)466468);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)0U, (int32_t)1826347);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)1U, (int32_t)2353451);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)2U, (int32_t)-359251);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)3U, (int32_t)-2091905);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)4U, (int32_t)3119733);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)5U, (int32_t)-2884855);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)6U, (int32_t)3111497);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(re, (size_t)7U, (int32_t)2680103);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)0U, (int32_t)2725464);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)1U, (int32_t)1024112);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)2U, (int32_t)-1079900);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)3U, (int32_t)3585928);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)4U, (int32_t)-549488);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)5U, (int32_t)-1119584);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)6U, (int32_t)2619752);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)7U, (int32_t)-2108549);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)8U, (int32_t)-2118186);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)9U, (int32_t)-3859737);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)10U, (int32_t)-1399561);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)11U, (int32_t)-3277672);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)12U, (int32_t)1757237);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)13U, (int32_t)-19422);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)14U, (int32_t)4010497);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(re, (size_t)15U, (int32_t)280005);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta0,
  int32_t zeta1
)
{
  __m256i re0 = re->data[index];
  __m256i re1 = re->data[index + (size_t)1U];
  __m256i summands = mm256_set_m128i(mm256_castsi256_si128(re1), mm256_castsi256_si128(re0));
  __m256i zeta_products = mm256_permute2x128_si256((int32_t)19, re1, re0, __m256i);
  __m256i zetas = mm256_set_epi32(zeta1, zeta1, zeta1, zeta1, zeta0, zeta0, zeta0, zeta0);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&zeta_products, &zetas);
  __m256i sub_terms = mm256_sub_epi32(summands, zeta_products);
  __m256i add_terms = mm256_add_epi32(summands, zeta_products);
  __m256i
  nre0 = mm256_set_m128i(mm256_castsi256_si128(sub_terms), mm256_castsi256_si128(add_terms));
  __m256i nre1 = mm256_permute2x128_si256((int32_t)19, sub_terms, add_terms, __m256i);
  re->data[index] = nre0;
  re->data[index + (size_t)1U] = nre1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_2(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)0U, (int32_t)2706023, (int32_t)95776);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)2U, (int32_t)3077325, (int32_t)3530437);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)4U, (int32_t)-1661693, (int32_t)-3592148);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)6U, (int32_t)-2537516, (int32_t)3915439);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)8U, (int32_t)-3861115, (int32_t)-3043716);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)10U, (int32_t)3574422, (int32_t)-2867647);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)12U, (int32_t)3539968, (int32_t)-300467);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)14U, (int32_t)2348700, (int32_t)-539299);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re,
    (size_t)16U,
    (int32_t)-1699267,
    (int32_t)-1643818);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)18U, (int32_t)3505694, (int32_t)-3821735);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)20U, (int32_t)3507263, (int32_t)-2140649);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)22U, (int32_t)-1600420, (int32_t)3699596);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)24U, (int32_t)811944, (int32_t)531354);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)26U, (int32_t)954230, (int32_t)3881043);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)28U, (int32_t)3900724, (int32_t)-2556880);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(re, (size_t)30U, (int32_t)2071892, (int32_t)-2797779);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_a0,
  int32_t zeta_a1,
  int32_t zeta_b0,
  int32_t zeta_b1
)
{
  __m256i re0 = re->data[index];
  __m256i re1 = re->data[index + (size_t)1U];
  __m256i summands = mm256_unpacklo_epi64(re0, re1);
  __m256i zeta_products = mm256_unpackhi_epi64(re0, re1);
  __m256i
  zetas = mm256_set_epi32(zeta_b1, zeta_b1, zeta_a1, zeta_a1, zeta_b0, zeta_b0, zeta_a0, zeta_a0);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&zeta_products, &zetas);
  __m256i sub_terms = mm256_sub_epi32(summands, zeta_products);
  __m256i add_terms = mm256_add_epi32(summands, zeta_products);
  __m256i nre0 = mm256_unpacklo_epi64(add_terms, sub_terms);
  __m256i nre1 = mm256_unpackhi_epi64(add_terms, sub_terms);
  re->data[index] = nre0;
  re->data[index + (size_t)1U] = nre1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_1(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)0U,
    (int32_t)-3930395,
    (int32_t)-1528703,
    (int32_t)-3677745,
    (int32_t)-3041255);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)2U,
    (int32_t)-1452451,
    (int32_t)3475950,
    (int32_t)2176455,
    (int32_t)-1585221);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)4U,
    (int32_t)-1257611,
    (int32_t)1939314,
    (int32_t)-4083598,
    (int32_t)-1000202);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)6U,
    (int32_t)-3190144,
    (int32_t)-3157330,
    (int32_t)-3632928,
    (int32_t)126922);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)8U,
    (int32_t)3412210,
    (int32_t)-983419,
    (int32_t)2147896,
    (int32_t)2715295);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)10U,
    (int32_t)-2967645,
    (int32_t)-3693493,
    (int32_t)-411027,
    (int32_t)-2477047);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)12U,
    (int32_t)-671102,
    (int32_t)-1228525,
    (int32_t)-22981,
    (int32_t)-1308169);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)14U,
    (int32_t)-381987,
    (int32_t)1349076,
    (int32_t)1852771,
    (int32_t)-1430430);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)16U,
    (int32_t)-3343383,
    (int32_t)264944,
    (int32_t)508951,
    (int32_t)3097992);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)18U,
    (int32_t)44288,
    (int32_t)-1100098,
    (int32_t)904516,
    (int32_t)3958618);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)20U,
    (int32_t)-3724342,
    (int32_t)-8578,
    (int32_t)1653064,
    (int32_t)-3249728);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)22U,
    (int32_t)2389356,
    (int32_t)-210977,
    (int32_t)759969,
    (int32_t)-1316856);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)24U,
    (int32_t)189548,
    (int32_t)-3553272,
    (int32_t)3159746,
    (int32_t)-1851402);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)26U,
    (int32_t)-2409325,
    (int32_t)-177440,
    (int32_t)1315589,
    (int32_t)1341330);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)28U,
    (int32_t)1285669,
    (int32_t)-1584928,
    (int32_t)-812732,
    (int32_t)-1439742);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(re,
    (size_t)30U,
    (int32_t)-3019102,
    (int32_t)-3881060,
    (int32_t)-3628969,
    (int32_t)3839961);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_a0,
  int32_t zeta_a1,
  int32_t zeta_a2,
  int32_t zeta_a3,
  int32_t zeta_b0,
  int32_t zeta_b1,
  int32_t zeta_b2,
  int32_t zeta_b3
)
{
  __m256i re0 = re->data[index];
  __m256i re1 = re->data[index + (size_t)1U];
  __m256i a = mm256_shuffle_epi32((int32_t)216, re0, __m256i);
  __m256i b = mm256_shuffle_epi32((int32_t)216, re1, __m256i);
  __m256i summands = mm256_unpacklo_epi64(a, b);
  __m256i zeta_products = mm256_unpackhi_epi64(a, b);
  __m256i
  zetas = mm256_set_epi32(zeta_b3, zeta_b2, zeta_a3, zeta_a2, zeta_b1, zeta_b0, zeta_a1, zeta_a0);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&zeta_products, &zetas);
  __m256i sub_terms = mm256_sub_epi32(summands, zeta_products);
  __m256i add_terms = mm256_add_epi32(summands, zeta_products);
  __m256i a_terms_shuffled = mm256_unpacklo_epi64(add_terms, sub_terms);
  __m256i b_terms_shuffled = mm256_unpackhi_epi64(add_terms, sub_terms);
  __m256i nre0 = mm256_shuffle_epi32((int32_t)216, a_terms_shuffled, __m256i);
  __m256i nre1 = mm256_shuffle_epi32((int32_t)216, b_terms_shuffled, __m256i);
  re->data[index] = nre0;
  re->data[index + (size_t)1U] = nre1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_0(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)0U,
    (int32_t)2091667,
    (int32_t)3407706,
    (int32_t)2316500,
    (int32_t)3817976,
    (int32_t)-3342478,
    (int32_t)2244091,
    (int32_t)-2446433,
    (int32_t)-3562462);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)2U,
    (int32_t)266997,
    (int32_t)2434439,
    (int32_t)-1235728,
    (int32_t)3513181,
    (int32_t)-3520352,
    (int32_t)-3759364,
    (int32_t)-1197226,
    (int32_t)-3193378);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)4U,
    (int32_t)900702,
    (int32_t)1859098,
    (int32_t)909542,
    (int32_t)819034,
    (int32_t)495491,
    (int32_t)-1613174,
    (int32_t)-43260,
    (int32_t)-522500);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)6U,
    (int32_t)-655327,
    (int32_t)-3122442,
    (int32_t)2031748,
    (int32_t)3207046,
    (int32_t)-3556995,
    (int32_t)-525098,
    (int32_t)-768622,
    (int32_t)-3595838);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)8U,
    (int32_t)342297,
    (int32_t)286988,
    (int32_t)-2437823,
    (int32_t)4108315,
    (int32_t)3437287,
    (int32_t)-3342277,
    (int32_t)1735879,
    (int32_t)203044);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)10U,
    (int32_t)2842341,
    (int32_t)2691481,
    (int32_t)-2590150,
    (int32_t)1265009,
    (int32_t)4055324,
    (int32_t)1247620,
    (int32_t)2486353,
    (int32_t)1595974);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)12U,
    (int32_t)-3767016,
    (int32_t)1250494,
    (int32_t)2635921,
    (int32_t)-3548272,
    (int32_t)-2994039,
    (int32_t)1869119,
    (int32_t)1903435,
    (int32_t)-1050970);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)14U,
    (int32_t)-1333058,
    (int32_t)1237275,
    (int32_t)-3318210,
    (int32_t)-1430225,
    (int32_t)-451100,
    (int32_t)1312455,
    (int32_t)3306115,
    (int32_t)-1962642);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)16U,
    (int32_t)-1279661,
    (int32_t)1917081,
    (int32_t)-2546312,
    (int32_t)-1374803,
    (int32_t)1500165,
    (int32_t)777191,
    (int32_t)2235880,
    (int32_t)3406031);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)18U,
    (int32_t)-542412,
    (int32_t)-2831860,
    (int32_t)-1671176,
    (int32_t)-1846953,
    (int32_t)-2584293,
    (int32_t)-3724270,
    (int32_t)594136,
    (int32_t)-3776993);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)20U,
    (int32_t)-2013608,
    (int32_t)2432395,
    (int32_t)2454455,
    (int32_t)-164721,
    (int32_t)1957272,
    (int32_t)3369112,
    (int32_t)185531,
    (int32_t)-1207385);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)22U,
    (int32_t)-3183426,
    (int32_t)162844,
    (int32_t)1616392,
    (int32_t)3014001,
    (int32_t)810149,
    (int32_t)1652634,
    (int32_t)-3694233,
    (int32_t)-1799107);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)24U,
    (int32_t)-3038916,
    (int32_t)3523897,
    (int32_t)3866901,
    (int32_t)269760,
    (int32_t)2213111,
    (int32_t)-975884,
    (int32_t)1717735,
    (int32_t)472078);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)26U,
    (int32_t)-426683,
    (int32_t)1723600,
    (int32_t)-1803090,
    (int32_t)1910376,
    (int32_t)-1667432,
    (int32_t)-1104333,
    (int32_t)-260646,
    (int32_t)-3833893);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)28U,
    (int32_t)-2939036,
    (int32_t)-2235985,
    (int32_t)-420899,
    (int32_t)-2286327,
    (int32_t)183443,
    (int32_t)-976891,
    (int32_t)1612842,
    (int32_t)-3545687);
  libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(re,
    (size_t)30U,
    (int32_t)-554416,
    (int32_t)3919660,
    (int32_t)-48306,
    (int32_t)-1362209,
    (int32_t)3937738,
    (int32_t)1400424,
    (int32_t)-846154,
    (int32_t)1976782);
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_avx2_ntt(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6(re);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3(re);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_2(re);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_1(re);
  libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_0(re);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_ntt(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_ntt_avx2_ntt(re);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_ntt_a2(Eurydice_arr_cd0 *simd_units)
{
  libcrux_ml_dsa_simd_avx2_ntt_ntt(simd_units);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_0(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta02,
  int32_t zeta03,
  int32_t zeta10,
  int32_t zeta11,
  int32_t zeta12,
  int32_t zeta13
)
{
  __m256i a_shuffled = mm256_shuffle_epi32((int32_t)216, simd_unit0, __m256i);
  __m256i b_shuffled0 = mm256_shuffle_epi32((int32_t)216, simd_unit1, __m256i);
  __m256i lo_values = mm256_unpacklo_epi64(a_shuffled, b_shuffled0);
  __m256i hi_values = mm256_unpackhi_epi64(a_shuffled, b_shuffled0);
  __m256i differences = hi_values;
  libcrux_ml_dsa_simd_avx2_arithmetic_subtract(&differences, &lo_values);
  libcrux_ml_dsa_simd_avx2_arithmetic_add(&lo_values, &hi_values);
  __m256i sums = lo_values;
  __m256i
  zetas = mm256_set_epi32(zeta13, zeta12, zeta03, zeta02, zeta11, zeta10, zeta01, zeta00);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&differences, &zetas);
  __m256i a_shuffled0 = mm256_unpacklo_epi64(sums, differences);
  __m256i b_shuffled = mm256_unpackhi_epi64(sums, differences);
  __m256i a = mm256_shuffle_epi32((int32_t)216, a_shuffled0, __m256i);
  __m256i b = mm256_shuffle_epi32((int32_t)216, b_shuffled, __m256i);
  return (KRML_CLITERAL(libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2){ .fst = a, .snd = b });
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta02,
  int32_t zeta03,
  int32_t zeta10,
  int32_t zeta11,
  int32_t zeta12,
  int32_t zeta13
)
{
  libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
  uu____0 =
    libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_0(re->data[index],
      re->data[index + (size_t)1U],
      zeta00,
      zeta01,
      zeta02,
      zeta03,
      zeta10,
      zeta11,
      zeta12,
      zeta13);
  __m256i uu____1 = uu____0.snd;
  re->data[index] = uu____0.fst;
  re->data[index + (size_t)1U] = uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)0U,
    (int32_t)1976782,
    (int32_t)-846154,
    (int32_t)1400424,
    (int32_t)3937738,
    (int32_t)-1362209,
    (int32_t)-48306,
    (int32_t)3919660,
    (int32_t)-554416);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)2U,
    (int32_t)-3545687,
    (int32_t)1612842,
    (int32_t)-976891,
    (int32_t)183443,
    (int32_t)-2286327,
    (int32_t)-420899,
    (int32_t)-2235985,
    (int32_t)-2939036);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)4U,
    (int32_t)-3833893,
    (int32_t)-260646,
    (int32_t)-1104333,
    (int32_t)-1667432,
    (int32_t)1910376,
    (int32_t)-1803090,
    (int32_t)1723600,
    (int32_t)-426683);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)6U,
    (int32_t)472078,
    (int32_t)1717735,
    (int32_t)-975884,
    (int32_t)2213111,
    (int32_t)269760,
    (int32_t)3866901,
    (int32_t)3523897,
    (int32_t)-3038916);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)8U,
    (int32_t)-1799107,
    (int32_t)-3694233,
    (int32_t)1652634,
    (int32_t)810149,
    (int32_t)3014001,
    (int32_t)1616392,
    (int32_t)162844,
    (int32_t)-3183426);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)10U,
    (int32_t)-1207385,
    (int32_t)185531,
    (int32_t)3369112,
    (int32_t)1957272,
    (int32_t)-164721,
    (int32_t)2454455,
    (int32_t)2432395,
    (int32_t)-2013608);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)12U,
    (int32_t)-3776993,
    (int32_t)594136,
    (int32_t)-3724270,
    (int32_t)-2584293,
    (int32_t)-1846953,
    (int32_t)-1671176,
    (int32_t)-2831860,
    (int32_t)-542412);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)14U,
    (int32_t)3406031,
    (int32_t)2235880,
    (int32_t)777191,
    (int32_t)1500165,
    (int32_t)-1374803,
    (int32_t)-2546312,
    (int32_t)1917081,
    (int32_t)-1279661);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)16U,
    (int32_t)-1962642,
    (int32_t)3306115,
    (int32_t)1312455,
    (int32_t)-451100,
    (int32_t)-1430225,
    (int32_t)-3318210,
    (int32_t)1237275,
    (int32_t)-1333058);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)18U,
    (int32_t)-1050970,
    (int32_t)1903435,
    (int32_t)1869119,
    (int32_t)-2994039,
    (int32_t)-3548272,
    (int32_t)2635921,
    (int32_t)1250494,
    (int32_t)-3767016);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)20U,
    (int32_t)1595974,
    (int32_t)2486353,
    (int32_t)1247620,
    (int32_t)4055324,
    (int32_t)1265009,
    (int32_t)-2590150,
    (int32_t)2691481,
    (int32_t)2842341);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)22U,
    (int32_t)203044,
    (int32_t)1735879,
    (int32_t)-3342277,
    (int32_t)3437287,
    (int32_t)4108315,
    (int32_t)-2437823,
    (int32_t)286988,
    (int32_t)342297);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)24U,
    (int32_t)-3595838,
    (int32_t)-768622,
    (int32_t)-525098,
    (int32_t)-3556995,
    (int32_t)3207046,
    (int32_t)2031748,
    (int32_t)-3122442,
    (int32_t)-655327);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)26U,
    (int32_t)-522500,
    (int32_t)-43260,
    (int32_t)-1613174,
    (int32_t)495491,
    (int32_t)819034,
    (int32_t)909542,
    (int32_t)1859098,
    (int32_t)900702);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)28U,
    (int32_t)-3193378,
    (int32_t)-1197226,
    (int32_t)-3759364,
    (int32_t)-3520352,
    (int32_t)3513181,
    (int32_t)-1235728,
    (int32_t)2434439,
    (int32_t)266997);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(re,
    (size_t)30U,
    (int32_t)-3562462,
    (int32_t)-2446433,
    (int32_t)2244091,
    (int32_t)-3342478,
    (int32_t)3817976,
    (int32_t)2316500,
    (int32_t)3407706,
    (int32_t)2091667);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_1(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta10,
  int32_t zeta11
)
{
  __m256i lo_values = mm256_unpacklo_epi64(simd_unit0, simd_unit1);
  __m256i hi_values = mm256_unpackhi_epi64(simd_unit0, simd_unit1);
  __m256i differences = hi_values;
  libcrux_ml_dsa_simd_avx2_arithmetic_subtract(&differences, &lo_values);
  libcrux_ml_dsa_simd_avx2_arithmetic_add(&lo_values, &hi_values);
  __m256i sums = lo_values;
  __m256i
  zetas = mm256_set_epi32(zeta11, zeta11, zeta01, zeta01, zeta10, zeta10, zeta00, zeta00);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&differences, &zetas);
  __m256i a = mm256_unpacklo_epi64(sums, differences);
  __m256i b = mm256_unpackhi_epi64(sums, differences);
  return (KRML_CLITERAL(libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2){ .fst = a, .snd = b });
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_00,
  int32_t zeta_01,
  int32_t zeta_10,
  int32_t zeta_11
)
{
  libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
  uu____0 =
    libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_1(re->data[index],
      re->data[index + (size_t)1U],
      zeta_00,
      zeta_01,
      zeta_10,
      zeta_11);
  __m256i uu____1 = uu____0.snd;
  re->data[index] = uu____0.fst;
  re->data[index + (size_t)1U] = uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)0U,
    (int32_t)3839961,
    (int32_t)-3628969,
    (int32_t)-3881060,
    (int32_t)-3019102);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)2U,
    (int32_t)-1439742,
    (int32_t)-812732,
    (int32_t)-1584928,
    (int32_t)1285669);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)4U,
    (int32_t)1341330,
    (int32_t)1315589,
    (int32_t)-177440,
    (int32_t)-2409325);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)6U,
    (int32_t)-1851402,
    (int32_t)3159746,
    (int32_t)-3553272,
    (int32_t)189548);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)8U,
    (int32_t)-1316856,
    (int32_t)759969,
    (int32_t)-210977,
    (int32_t)2389356);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)10U,
    (int32_t)-3249728,
    (int32_t)1653064,
    (int32_t)-8578,
    (int32_t)-3724342);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)12U,
    (int32_t)3958618,
    (int32_t)904516,
    (int32_t)-1100098,
    (int32_t)44288);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)14U,
    (int32_t)3097992,
    (int32_t)508951,
    (int32_t)264944,
    (int32_t)-3343383);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)16U,
    (int32_t)-1430430,
    (int32_t)1852771,
    (int32_t)1349076,
    (int32_t)-381987);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)18U,
    (int32_t)-1308169,
    (int32_t)-22981,
    (int32_t)-1228525,
    (int32_t)-671102);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)20U,
    (int32_t)-2477047,
    (int32_t)-411027,
    (int32_t)-3693493,
    (int32_t)-2967645);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)22U,
    (int32_t)2715295,
    (int32_t)2147896,
    (int32_t)-983419,
    (int32_t)3412210);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)24U,
    (int32_t)126922,
    (int32_t)-3632928,
    (int32_t)-3157330,
    (int32_t)-3190144);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)26U,
    (int32_t)-1000202,
    (int32_t)-4083598,
    (int32_t)1939314,
    (int32_t)-1257611);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)28U,
    (int32_t)-1585221,
    (int32_t)2176455,
    (int32_t)3475950,
    (int32_t)-1452451);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(re,
    (size_t)30U,
    (int32_t)-3041255,
    (int32_t)-3677745,
    (int32_t)-1528703,
    (int32_t)-3930395);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_2(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta0,
  int32_t zeta1
)
{
  __m256i lo_values = mm256_permute2x128_si256((int32_t)32, simd_unit0, simd_unit1, __m256i);
  __m256i hi_values = mm256_permute2x128_si256((int32_t)49, simd_unit0, simd_unit1, __m256i);
  __m256i differences = hi_values;
  libcrux_ml_dsa_simd_avx2_arithmetic_subtract(&differences, &lo_values);
  libcrux_ml_dsa_simd_avx2_arithmetic_add(&lo_values, &hi_values);
  __m256i sums = lo_values;
  __m256i zetas = mm256_set_epi32(zeta1, zeta1, zeta1, zeta1, zeta0, zeta0, zeta0, zeta0);
  libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(&differences, &zetas);
  __m256i a = mm256_permute2x128_si256((int32_t)32, sums, differences, __m256i);
  __m256i b = mm256_permute2x128_si256((int32_t)49, sums, differences, __m256i);
  return (KRML_CLITERAL(libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2){ .fst = a, .snd = b });
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta1,
  int32_t zeta2
)
{
  libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
  uu____0 =
    libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_2(re->data[index],
      re->data[index + (size_t)1U],
      zeta1,
      zeta2);
  __m256i uu____1 = uu____0.snd;
  re->data[index] = uu____0.fst;
  re->data[index + (size_t)1U] = uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)0U,
    (int32_t)-2797779,
    (int32_t)2071892);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)2U,
    (int32_t)-2556880,
    (int32_t)3900724);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)4U,
    (int32_t)3881043,
    (int32_t)954230);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)6U,
    (int32_t)531354,
    (int32_t)811944);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)8U,
    (int32_t)3699596,
    (int32_t)-1600420);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)10U,
    (int32_t)-2140649,
    (int32_t)3507263);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)12U,
    (int32_t)-3821735,
    (int32_t)3505694);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)14U,
    (int32_t)-1643818,
    (int32_t)-1699267);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)16U,
    (int32_t)-539299,
    (int32_t)2348700);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)18U,
    (int32_t)-300467,
    (int32_t)3539968);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)20U,
    (int32_t)-2867647,
    (int32_t)3574422);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)22U,
    (int32_t)-3043716,
    (int32_t)-3861115);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)24U,
    (int32_t)3915439,
    (int32_t)-2537516);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)26U,
    (int32_t)-3592148,
    (int32_t)-1661693);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)28U,
    (int32_t)3530437,
    (int32_t)3077325);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(re,
    (size_t)30U,
    (int32_t)95776,
    (int32_t)2706023);
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE __m256i
libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i lhs,
  int32_t constant
)
{
  __m256i rhs = mm256_set1_epi32(constant);
  __m256i field_modulus = mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  __m256i
  inverse_of_modulus_mod_montgomery_r =
    mm256_set1_epi32((int32_t)LIBCRUX_ML_DSA_SIMD_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R);
  __m256i prod02 = mm256_mul_epi32(lhs, rhs);
  __m256i
  prod13 =
    mm256_mul_epi32(mm256_shuffle_epi32((int32_t)245, lhs, __m256i),
      mm256_shuffle_epi32((int32_t)245, rhs, __m256i));
  __m256i k02 = mm256_mul_epi32(prod02, inverse_of_modulus_mod_montgomery_r);
  __m256i k13 = mm256_mul_epi32(prod13, inverse_of_modulus_mod_montgomery_r);
  __m256i c02 = mm256_mul_epi32(k02, field_modulus);
  __m256i c13 = mm256_mul_epi32(k13, field_modulus);
  __m256i res02 = mm256_sub_epi32(prod02, c02);
  __m256i res13 = mm256_sub_epi32(prod13, c13);
  __m256i res02_shifted = mm256_shuffle_epi32((int32_t)245, res02, __m256i);
  return mm256_blend_epi32((int32_t)170, res02_shifted, res13, __m256i);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 1
- ZETA= 280005
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_99(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)280005);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 2
- STEP_BY= 1
- ZETA= 4010497
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1c(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)2U; i < (size_t)2U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)4010497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 1
- ZETA= -19422
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-19422);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 6
- STEP_BY= 1
- ZETA= 1757237
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_44(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)6U; i < (size_t)6U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)1757237);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 1
- ZETA= -3277672
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a8(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-3277672);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 10
- STEP_BY= 1
- ZETA= -1399561
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1f(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)10U; i < (size_t)10U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-1399561);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 1
- ZETA= -3859737
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_95(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-3859737);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 14
- STEP_BY= 1
- ZETA= -2118186
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)14U; i < (size_t)14U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-2118186);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 1
- ZETA= -2108549
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-2108549);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 18
- STEP_BY= 1
- ZETA= 2619752
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_e4(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)18U; i < (size_t)18U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)2619752);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 1
- ZETA= -1119584
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-1119584);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 22
- STEP_BY= 1
- ZETA= -549488
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_05(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)22U; i < (size_t)22U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-549488);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 1
- ZETA= 3585928
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d9(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)3585928);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 26
- STEP_BY= 1
- ZETA= -1079900
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3a(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)26U; i < (size_t)26U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-1079900);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 1
- ZETA= 1024112
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b0(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)1024112);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 30
- STEP_BY= 1
- ZETA= 2725464
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a0(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)30U; i < (size_t)30U + (size_t)1U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)1U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)1U]);
    re->data[j + (size_t)1U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)2725464);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_3(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_99(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1c(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_44(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a8(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1f(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_95(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_e4(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_05(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d9(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3a(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b0(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a0(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 2
- ZETA= 2680103
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_990(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)2680103);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 2
- ZETA= 3111497
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b0(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)3111497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 2
- ZETA= -2884855
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a80(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-2884855);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 2
- ZETA= 3119733
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_950(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)3119733);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 2
- ZETA= -2091905
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a0(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-2091905);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 2
- ZETA= -359251
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de0(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-359251);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 2
- ZETA= 2353451
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d90(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)2353451);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 2
- ZETA= 1826347
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b1(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)2U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)2U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)2U]);
    re->data[j + (size_t)2U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)1826347);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_4(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_990(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b0(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a80(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_950(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a0(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de0(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d90(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b1(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 4
- ZETA= 466468
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_991(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)4U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)4U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j + (size_t)4U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)466468);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 4
- ZETA= -876248
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a81(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)4U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)4U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j + (size_t)4U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-876248);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 4
- ZETA= -777960
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a1(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)4U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)4U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j + (size_t)4U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-777960);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 4
- ZETA= 237124
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d91(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)4U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)4U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)4U]);
    re->data[j + (size_t)4U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)237124);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_5(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_991(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a81(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a1(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d91(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 8
- ZETA= -518909
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_992(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)8U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)8U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)8U]);
    re->data[j + (size_t)8U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-518909);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 8
- ZETA= -2608894
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a2(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)8U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)8U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)8U]);
    re->data[j + (size_t)8U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)-2608894);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_6(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_992(re);
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a2(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 16
- ZETA= 25847
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_993(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)16U; i++)
  {
    size_t j = i;
    __m256i a_minus_b = mm256_sub_epi32(re->data[j + (size_t)16U], re->data[j]);
    re->data[j] = mm256_add_epi32(re->data[j], re->data[j + (size_t)16U]);
    re->data[j + (size_t)16U] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(a_minus_b,
        (int32_t)25847);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_7(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_993(re);
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery_inv_inner(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_3(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_4(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_5(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_6(re);
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_7(re);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    re->data[i0] =
      libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(re->data[i0],
        LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_MONTGOMERY_INV_INNER_FACTOR);
  }
}

KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery_inv_inner(re);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_invert_ntt_montgomery_a2(Eurydice_arr_cd0 *simd_units)
{
  libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery(simd_units);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 0
*/
KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(__m256i *simd_unit)
{
  __m256i shifted = mm256_slli_epi32((int32_t)0, simd_unit[0U], __m256i);
  __m256i quotient = mm256_add_epi32(shifted, mm256_set1_epi32((int32_t)1 << 22U));
  __m256i quotient0 = mm256_srai_epi32((int32_t)23, quotient, __m256i);
  __m256i
  quotient_times_field_modulus =
    mm256_mullo_epi32(quotient0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS));
  simd_unit[0U] = mm256_sub_epi32(shifted, quotient_times_field_modulus);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_reduce_a2(Eurydice_arr_cd0 *simd_units)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(simd_units->data);
  libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(&simd_units->data[8U]);
  libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(&simd_units->data[16U]);
  libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(&simd_units->data[24U]);
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.zero_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2") static Eurydice_arr_cd0 zero_ff_64(void)
{
  Eurydice_arr_cd0 lit;
  __m256i repeat_expression[32U];
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    repeat_expression[i] = libcrux_ml_dsa_simd_avx2_zero_a2();
  }
  memcpy(lit.data, repeat_expression, (size_t)32U * sizeof (__m256i));
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta_equals_4
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
rejection_sample_less_than_eta_equals_4_64(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)4U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)4U,
            .end = _cloop_i * (size_t)4U + (size_t)4U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_4_a2(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta_equals_2
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
rejection_sample_less_than_eta_equals_2_64(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)4U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)4U,
            .end = _cloop_i * (size_t)4U + (size_t)4U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_2_a2(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
rejection_sample_less_than_eta_64(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled,
  Eurydice_arr_13 *out
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        return rejection_sample_less_than_eta_equals_4_64(randomness, sampled, out);
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return rejection_sample_less_than_eta_equals_2_64(randomness, sampled, out);
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.from_i32_array_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static void
from_i32_array_ff_64(Eurydice_dst_ref_shared_fc array, Eurydice_arr_cd0 *result)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_DSA_SIMD_TRAITS_SIMD_UNITS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_from_coefficient_array_a2(Eurydice_slice_subslice_shared_46(array,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_four_error_ring_elements
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_four_error_ring_elements_fc(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 seed,
  uint16_t start_index,
  Eurydice_dst_ref_mut_2a re
)
{
  Eurydice_arr_a2 seed0 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, start_index);
  Eurydice_arr_a2
  seed1 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 1U);
  Eurydice_arr_a2
  seed2 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 2U);
  Eurydice_arr_a2
  seed3 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 3U);
  Eurydice_arr_05
  state =
    libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4_ad(Eurydice_array_to_slice_shared_39(&seed0),
      Eurydice_array_to_slice_shared_39(&seed1),
      Eurydice_array_to_slice_shared_39(&seed2),
      Eurydice_array_to_slice_shared_39(&seed3));
  Eurydice_arr_3d_x4
  randomnesses0 = libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4_ad(&state);
  Eurydice_arr_380
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  size_t sampled0 = (size_t)0U;
  size_t sampled1 = (size_t)0U;
  size_t sampled2 = (size_t)0U;
  size_t sampled3 = (size_t)0U;
  libcrux_ml_dsa_constants_Eta uu____0 = eta;
  bool
  done0 =
    rejection_sample_less_than_eta_64(uu____0,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.fst),
      &sampled0,
      out.data);
  libcrux_ml_dsa_constants_Eta uu____1 = eta;
  bool
  done1 =
    rejection_sample_less_than_eta_64(uu____1,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.snd),
      &sampled1,
      &out.data[1U]);
  libcrux_ml_dsa_constants_Eta uu____2 = eta;
  bool
  done2 =
    rejection_sample_less_than_eta_64(uu____2,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.thd),
      &sampled2,
      &out.data[2U]);
  libcrux_ml_dsa_constants_Eta uu____3 = eta;
  bool
  done3 =
    rejection_sample_less_than_eta_64(uu____3,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.f3),
      &sampled3,
      &out.data[3U]);
  while (true)
  {
    if (done0)
    {
      if (done1)
      {
        if (done2)
        {
          if (done3)
          {
            break;
          }
          else
          {
            Eurydice_arr_3d_x4
            randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(&state);
            if (!done0)
            {
              libcrux_ml_dsa_constants_Eta uu____4 = eta;
              done0 =
                rejection_sample_less_than_eta_64(uu____4,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
                  &sampled0,
                  out.data);
            }
            if (!done1)
            {
              libcrux_ml_dsa_constants_Eta uu____5 = eta;
              done1 =
                rejection_sample_less_than_eta_64(uu____5,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
                  &sampled1,
                  &out.data[1U]);
            }
            if (!done2)
            {
              libcrux_ml_dsa_constants_Eta uu____6 = eta;
              done2 =
                rejection_sample_less_than_eta_64(uu____6,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
                  &sampled2,
                  &out.data[2U]);
            }
            if (!done3)
            {
              libcrux_ml_dsa_constants_Eta uu____7 = eta;
              done3 =
                rejection_sample_less_than_eta_64(uu____7,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
                  &sampled3,
                  &out.data[3U]);
            }
          }
        }
        else
        {
          Eurydice_arr_3d_x4
          randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(&state);
          if (!done0)
          {
            libcrux_ml_dsa_constants_Eta uu____8 = eta;
            done0 =
              rejection_sample_less_than_eta_64(uu____8,
                Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
                &sampled0,
                out.data);
          }
          if (!done1)
          {
            libcrux_ml_dsa_constants_Eta uu____9 = eta;
            done1 =
              rejection_sample_less_than_eta_64(uu____9,
                Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
                &sampled1,
                &out.data[1U]);
          }
          if (!done2)
          {
            libcrux_ml_dsa_constants_Eta uu____10 = eta;
            done2 =
              rejection_sample_less_than_eta_64(uu____10,
                Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
                &sampled2,
                &out.data[2U]);
          }
          if (!done3)
          {
            libcrux_ml_dsa_constants_Eta uu____11 = eta;
            done3 =
              rejection_sample_less_than_eta_64(uu____11,
                Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
                &sampled3,
                &out.data[3U]);
          }
        }
      }
      else
      {
        Eurydice_arr_3d_x4
        randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(&state);
        if (!done0)
        {
          libcrux_ml_dsa_constants_Eta uu____12 = eta;
          done0 =
            rejection_sample_less_than_eta_64(uu____12,
              Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
              &sampled0,
              out.data);
        }
        if (!done1)
        {
          libcrux_ml_dsa_constants_Eta uu____13 = eta;
          done1 =
            rejection_sample_less_than_eta_64(uu____13,
              Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
              &sampled1,
              &out.data[1U]);
        }
        if (!done2)
        {
          libcrux_ml_dsa_constants_Eta uu____14 = eta;
          done2 =
            rejection_sample_less_than_eta_64(uu____14,
              Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
              &sampled2,
              &out.data[2U]);
        }
        if (!done3)
        {
          libcrux_ml_dsa_constants_Eta uu____15 = eta;
          done3 =
            rejection_sample_less_than_eta_64(uu____15,
              Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
              &sampled3,
              &out.data[3U]);
        }
      }
    }
    else
    {
      Eurydice_arr_3d_x4
      randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(&state);
      if (!done0)
      {
        libcrux_ml_dsa_constants_Eta uu____16 = eta;
        done0 =
          rejection_sample_less_than_eta_64(uu____16,
            Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
            &sampled0,
            out.data);
      }
      if (!done1)
      {
        libcrux_ml_dsa_constants_Eta uu____17 = eta;
        done1 =
          rejection_sample_less_than_eta_64(uu____17,
            Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
            &sampled1,
            &out.data[1U]);
      }
      if (!done2)
      {
        libcrux_ml_dsa_constants_Eta uu____18 = eta;
        done2 =
          rejection_sample_less_than_eta_64(uu____18,
            Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
            &sampled2,
            &out.data[2U]);
      }
      if (!done3)
      {
        libcrux_ml_dsa_constants_Eta uu____19 = eta;
        done3 =
          rejection_sample_less_than_eta_64(uu____19,
            Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
            &sampled3,
            &out.data[3U]);
      }
    }
  }
  size_t max0 = (size_t)start_index + (size_t)4U;
  size_t max;
  if (re.meta < max0)
  {
    max = re.meta;
  }
  else
  {
    max = max0;
  }
  for (size_t i = (size_t)start_index; i < max; i++)
  {
    size_t i0 = i;
    from_i32_array_ff_64(Eurydice_array_to_slice_shared_20(&out.data[i0 % (size_t)4U]),
      &re.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.samplex4.sample_s1_and_s2
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_s1_and_s2_fc(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a s1_s2
)
{
  size_t len = s1_s2.meta;
  for (size_t i = (size_t)0U; i < len / (size_t)4U; i++)
  {
    size_t i0 = i;
    sample_four_error_ring_elements_fc(eta, seed, 4U * (uint32_t)(uint16_t)i0, s1_s2);
  }
  size_t remainder = len % (size_t)4U;
  if (remainder != (size_t)0U)
  {
    sample_four_error_ring_elements_fc(eta, seed, (uint16_t)(len - remainder), s1_s2);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 8
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_719(Eurydice_arr_53 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $16size_t
*/
typedef struct arr_30_s { Eurydice_arr_cd0 data[16U]; } arr_30;

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_field_modulus
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
rejection_sample_less_than_field_modulus_64(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)24U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)24U,
            .end = _cloop_i * (size_t)24U + (size_t)24U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_a2(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
 Sample and write out up to four ring elements.

 If i <= `elements_requested`, a field element with domain separated
 seed according to the provided index is generated in
 `tmp_stack[i]`. After successful rejection sampling in
 `tmp_stack[i]`, the ring element is written to `matrix` at the
 provided index in `indices[i]`.
 `rand_stack` is a working buffer that holds initial Shake output.
*/
/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_up_to_four_ring_elements_flat
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake128x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_up_to_four_ring_elements_flat_0a(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a matrix,
  Eurydice_arr_12 *rand_stack0,
  Eurydice_arr_12 *rand_stack1,
  Eurydice_arr_12 *rand_stack2,
  Eurydice_arr_12 *rand_stack3,
  Eurydice_dst_ref_mut_4c tmp_stack,
  size_t start_index,
  size_t elements_requested
)
{
  Eurydice_arr_48
  seed0 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index, columns));
  Eurydice_arr_48
  seed1 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)1U,
        columns));
  Eurydice_arr_48
  seed2 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)2U,
        columns));
  Eurydice_arr_48
  seed3 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)3U,
        columns));
  Eurydice_arr_05
  state =
    libcrux_ml_dsa_hash_functions_simd256_init_absorb_3b(Eurydice_array_to_slice_shared_8d(&seed0),
      Eurydice_array_to_slice_shared_8d(&seed1),
      Eurydice_array_to_slice_shared_8d(&seed2),
      Eurydice_array_to_slice_shared_8d(&seed3));
  libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks_3b(&state,
    rand_stack0,
    rand_stack1,
    rand_stack2,
    rand_stack3);
  size_t sampled0 = (size_t)0U;
  size_t sampled1 = (size_t)0U;
  size_t sampled2 = (size_t)0U;
  size_t sampled3 = (size_t)0U;
  bool
  done0 =
    rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_a8(rand_stack0),
      &sampled0,
      tmp_stack.ptr);
  bool
  done1 =
    rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_a8(rand_stack1),
      &sampled1,
      &tmp_stack.ptr[1U]);
  bool
  done2 =
    rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_a8(rand_stack2),
      &sampled2,
      &tmp_stack.ptr[2U]);
  bool
  done3 =
    rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_a8(rand_stack3),
      &sampled3,
      &tmp_stack.ptr[3U]);
  while (true)
  {
    if (done0)
    {
      if (done1)
      {
        if (done2)
        {
          if (done3)
          {
            break;
          }
          else
          {
            Eurydice_arr_27_x4
            randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(&state);
            if (!done0)
            {
              done0 =
                rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
                  &sampled0,
                  tmp_stack.ptr);
            }
            if (!done1)
            {
              done1 =
                rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
                  &sampled1,
                  &tmp_stack.ptr[1U]);
            }
            if (!done2)
            {
              done2 =
                rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
                  &sampled2,
                  &tmp_stack.ptr[2U]);
            }
            if (!done3)
            {
              done3 =
                rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
                  &sampled3,
                  &tmp_stack.ptr[3U]);
            }
          }
        }
        else
        {
          Eurydice_arr_27_x4
          randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(&state);
          if (!done0)
          {
            done0 =
              rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
                &sampled0,
                tmp_stack.ptr);
          }
          if (!done1)
          {
            done1 =
              rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
                &sampled1,
                &tmp_stack.ptr[1U]);
          }
          if (!done2)
          {
            done2 =
              rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
                &sampled2,
                &tmp_stack.ptr[2U]);
          }
          if (!done3)
          {
            done3 =
              rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
                &sampled3,
                &tmp_stack.ptr[3U]);
          }
        }
      }
      else
      {
        Eurydice_arr_27_x4
        randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(&state);
        if (!done0)
        {
          done0 =
            rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
              &sampled0,
              tmp_stack.ptr);
        }
        if (!done1)
        {
          done1 =
            rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
              &sampled1,
              &tmp_stack.ptr[1U]);
        }
        if (!done2)
        {
          done2 =
            rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
              &sampled2,
              &tmp_stack.ptr[2U]);
        }
        if (!done3)
        {
          done3 =
            rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
              &sampled3,
              &tmp_stack.ptr[3U]);
        }
      }
    }
    else
    {
      Eurydice_arr_27_x4
      randomnesses = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(&state);
      if (!done0)
      {
        done0 =
          rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
            &sampled0,
            tmp_stack.ptr);
      }
      if (!done1)
      {
        done1 =
          rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
            &sampled1,
            &tmp_stack.ptr[1U]);
      }
      if (!done2)
      {
        done2 =
          rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
            &sampled2,
            &tmp_stack.ptr[2U]);
      }
      if (!done3)
      {
        done3 =
          rejection_sample_less_than_field_modulus_64(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
            &sampled3,
            &tmp_stack.ptr[3U]);
      }
    }
  }
  for (size_t i = (size_t)0U; i < elements_requested; i++)
  {
    size_t k = i;
    from_i32_array_ff_64(Eurydice_array_to_slice_shared_20(&tmp_stack.ptr[k]),
      &matrix.ptr[start_index + k]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.samplex4.matrix_flat
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake128x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
matrix_flat_0a(size_t columns, Eurydice_borrow_slice_u8 seed, Eurydice_dst_ref_mut_2a matrix)
{
  Eurydice_arr_12 rand_stack0 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack1 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack2 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack3 = { .data = { 0U } };
  Eurydice_arr_380
  tmp_stack =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  for (size_t i = (size_t)0U; i < matrix.meta / (size_t)4U + (size_t)1U; i++)
  {
    size_t start_index = i;
    size_t start_index0 = start_index * (size_t)4U;
    if (start_index0 >= matrix.meta)
    {
      break;
    }
    size_t elements_requested;
    if (start_index0 + (size_t)4U <= matrix.meta)
    {
      elements_requested = (size_t)4U;
    }
    else
    {
      elements_requested = matrix.meta - start_index0;
    }
    sample_up_to_four_ring_elements_flat_0a(columns,
      seed,
      matrix,
      &rand_stack0,
      &rand_stack1,
      &rand_stack2,
      &rand_stack3,
      Eurydice_array_to_slice_mut_f6(&tmp_stack),
      start_index0,
      elements_requested);
  }
}

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::avx2::AVX2Sampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.avx2.matrix_flat.inner_e8
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_samplex4_avx2_matrix_flat_inner_e8_64(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a matrix
)
{
  matrix_flat_0a(columns, seed, matrix);
}

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::avx2::AVX2Sampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.avx2.matrix_flat_e8
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a matrix
)
{
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_inner_e8_64(columns, seed, matrix);
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 16
*/
KRML_ATTRIBUTE_TARGET("avx2") static Eurydice_dst_ref_mut_2a array_to_slice_mut_7110(arr_30 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 4
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_7111(Eurydice_arr_15 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 8
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_subslice_shared_c32(const Eurydice_arr_53 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_2a){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.ntt
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2") static KRML_MUSTINLINE void ntt_64(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_ntt_a2(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.ntt_multiply_montgomery
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
ntt_multiply_montgomery_64(Eurydice_arr_cd0 *lhs, const Eurydice_arr_cd0 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_montgomery_multiply_a2(&lhs->data[i0], &rhs->data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.add_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
add_ff_64(Eurydice_arr_cd0 *self, const Eurydice_arr_cd0 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_add_a2(&self->data[i0], &rhs->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.reduce
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2") static KRML_MUSTINLINE void reduce_64(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_reduce_a2(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.invert_ntt_montgomery
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
invert_ntt_montgomery_64(Eurydice_arr_cd0 *re)
{
  libcrux_ml_dsa_simd_avx2_invert_ntt_montgomery_a2(re);
}

/**
 Compute InvertNTT(Â ◦ ŝ₁) + s₂
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_as1_plus_s2
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
compute_as1_plus_s2_64(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_mut_2a a_as_ntt,
  Eurydice_dst_ref_shared_2a s1_ntt,
  Eurydice_dst_ref_shared_2a s1_s2,
  Eurydice_dst_ref_mut_2a result
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      ntt_multiply_montgomery_64(&a_as_ntt.ptr[i1 * columns_in_a + j], &s1_ntt.ptr[j]);
      add_ff_64(&result.ptr[i1], &a_as_ntt.ptr[i1 * columns_in_a + j]);
    }
  }
  for (size_t i = (size_t)0U; i < result.meta; i++)
  {
    size_t i0 = i;
    reduce_64(&result.ptr[i0]);
    invert_ntt_montgomery_64(&result.ptr[i0]);
    add_ff_64(&result.ptr[i0], &s1_s2.ptr[columns_in_a + i0]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 4
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_719(const Eurydice_arr_15 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 8
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7110(const Eurydice_arr_53 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.power2round_vector
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
power2round_vector_64(Eurydice_dst_ref_mut_2a t, Eurydice_dst_ref_mut_2a t1)
{
  for (size_t i0 = (size_t)0U; i0 < t.meta; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      libcrux_ml_dsa_simd_avx2_power2round_a2(&t.ptr[i1].data[j], &t1.ptr[i1].data[j]);
    }
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t1.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_64(const Eurydice_arr_cd0 *re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const __m256i *simd_unit = &re->data[i0];
    libcrux_ml_dsa_simd_avx2_t1_serialize_a2(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T1_SERIALIZE_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) *
              LIBCRUX_ML_DSA_ENCODING_T1_SERIALIZE_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.generate_serialized
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
generate_serialized_64(
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_shared_2a t1,
  Eurydice_mut_borrow_slice_u8 verification_key_serialized
)
{
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(verification_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE
        }
      )),
    seed,
    uint8_t);
  for (size_t i = (size_t)0U; i < t1.meta; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_cd0 *ring_element = &t1.ptr[i0];
    size_t
    offset =
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE +
        i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE;
    serialize_64(ring_element,
      Eurydice_slice_subslice_mut_7e(verification_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 64
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_d8(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 64
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
)
{
  libcrux_ml_dsa_hash_functions_simd256_shake256_24(input, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_640(
  libcrux_ml_dsa_constants_Eta eta,
  const Eurydice_arr_cd0 *re,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  size_t output_bytes_per_simd_unit = libcrux_ml_dsa_encoding_error_chunk_size(eta);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const __m256i *simd_unit = &re->data[i0];
    libcrux_ml_dsa_simd_avx2_error_serialize_a2(eta,
      simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * output_bytes_per_simd_unit,
            .end = (i0 + (size_t)1U) * output_bytes_per_simd_unit
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_641(const Eurydice_arr_cd0 *re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const __m256i *simd_unit = &re->data[i0];
    libcrux_ml_dsa_simd_avx2_t0_serialize_a2(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signing_key.generate_serialized
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
generate_serialized_18(
  libcrux_ml_dsa_constants_Eta eta,
  size_t error_ring_element_size,
  Eurydice_borrow_slice_u8 seed_matrix,
  Eurydice_borrow_slice_u8 seed_signing,
  Eurydice_borrow_slice_u8 verification_key,
  Eurydice_dst_ref_shared_2a s1_2,
  Eurydice_dst_ref_shared_2a t0,
  Eurydice_mut_borrow_slice_u8 signing_key_serialized
)
{
  size_t offset = (size_t)0U;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE
        }
      )),
    seed_matrix,
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE
        }
      )),
    seed_signing,
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE;
  Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
  libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(verification_key, &verification_key_hash);
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH
        }
      )),
    Eurydice_array_to_slice_shared_d8(&verification_key_hash),
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH;
  for (size_t i = (size_t)0U; i < s1_2.meta; i++)
  {
    size_t i0 = i;
    serialize_640(eta,
      &s1_2.ptr[i0],
      Eurydice_slice_subslice_mut_7e(signing_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + error_ring_element_size
          }
        )));
    offset = offset + error_ring_element_size;
  }
  for (size_t i = (size_t)0U; i < t0.meta; i++)
  {
    size_t _cloop_j = i;
    const Eurydice_arr_cd0 *ring_element = &t0.ptr[_cloop_j];
    serialize_641(ring_element,
      Eurydice_slice_subslice_mut_7e(signing_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE
          }
        )));
    offset = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.generate_key_pair
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
generate_key_pair_07(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  Eurydice_arr_53 s1_s2;
  Eurydice_arr_cd0 repeat_expression0[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)8U * sizeof (Eurydice_arr_cd0));
  sample_s1_and_s2_fc(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    seed_for_error_vectors,
    array_to_slice_mut_719(&s1_s2));
  Eurydice_arr_15 t0;
  Eurydice_arr_cd0 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(t0.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_cd0));
  arr_30 a_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression2[i] = zero_ff_64(););
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)16U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7110(&a_as_ntt));
  Eurydice_arr_15 s1_ntt;
  Eurydice_arr_cd0 repeat_expression3[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression3[i] = zero_ff_64(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)4U * sizeof (Eurydice_arr_cd0));
  Eurydice_slice_copy(array_to_slice_mut_7111(&s1_ntt),
    array_to_subslice_shared_c32(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_cd0);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    ntt_64(&s1_ntt.data[i0]););
  compute_as1_plus_s2_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    array_to_slice_mut_7110(&a_as_ntt),
    array_to_slice_shared_719(&s1_ntt),
    array_to_slice_shared_7110(&s1_s2),
    array_to_slice_mut_7111(&t0));
  Eurydice_arr_15 t1;
  Eurydice_arr_cd0 repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_cd0));
  power2round_vector_64(array_to_slice_mut_7111(&t0), array_to_slice_mut_7111(&t1));
  generate_serialized_64(seed_for_a, array_to_slice_shared_719(&t1), verification_key);
  generate_serialized_18(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    array_to_slice_shared_7110(&s1_s2),
    array_to_slice_shared_719(&t0),
    signing_key);
}

/**
 Key Generation.
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  generate_key_pair_07(randomness, signing_key, verification_key);
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair__inner(randomness,
    signing_key,
    verification_key);
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_64(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_cd0 *result
)
{
  size_t chunk_size = libcrux_ml_dsa_encoding_error_chunk_size(eta);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_error_deserialize_a2(eta,
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * chunk_size,
            .end = (i0 + (size_t)1U) * chunk_size
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_to_vector_then_ntt_64(
  libcrux_ml_dsa_constants_Eta eta,
  size_t ring_element_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_2a ring_elements
)
{
  for (size_t i = (size_t)0U; i < serialized.meta / ring_element_size; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * ring_element_size,
            .end = i0 * ring_element_size + ring_element_size
          }
        ));
    deserialize_64(eta, bytes, &ring_elements.ptr[i0]);
    ntt_64(&ring_elements.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_640(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_cd0 *result)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_t0_deserialize_a2(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_to_vector_then_ntt_640(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_2a ring_elements
)
{
  for
  (size_t
    i = (size_t)0U;
    i < serialized.meta / LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE,
            .end = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE +
              LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE
          }
        ));
    deserialize_640(bytes, &ring_elements.ptr[i0]);
    ntt_64(&ring_elements.ptr[i0]);
  }
}

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_15

*/
typedef struct Option_9d_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_15 f0;
}
Option_9d;

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4
with const generics
- OUT_LEN= 576
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
)
{
  libcrux_sha3_avx2_x4_shake256(input0,
    input1,
    input2,
    input3,
    Eurydice_array_to_slice_mut_fa(out0),
    Eurydice_array_to_slice_mut_fa(out1),
    Eurydice_array_to_slice_mut_fa(out2),
    Eurydice_array_to_slice_mut_fa(out3));
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4_ad
with const generics
- OUT_LEN= 576
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
)
{
  libcrux_ml_dsa_hash_functions_simd256_shake256_x4_1b(input0,
    input1,
    input2,
    input3,
    out0,
    out1,
    out2,
    out3);
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.gamma1.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_641(
  size_t gamma1_exponent,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_cd0 *result
)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_gamma1_deserialize_a2(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (gamma1_exponent + (size_t)1U),
            .end = (i0 + (size_t)1U) * (gamma1_exponent + (size_t)1U)
          }
        )),
      &result->data[i0],
      gamma1_exponent);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4
with const generics
- OUT_LEN= 640
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
)
{
  libcrux_sha3_avx2_x4_shake256(input0,
    input1,
    input2,
    input3,
    Eurydice_array_to_slice_mut_7d(out0),
    Eurydice_array_to_slice_mut_7d(out1),
    Eurydice_array_to_slice_mut_7d(out2),
    Eurydice_array_to_slice_mut_7d(out3));
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4_ad
with const generics
- OUT_LEN= 640
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
)
{
  libcrux_ml_dsa_hash_functions_simd256_shake256_x4_c8(input0,
    input1,
    input2,
    input3,
    out0,
    out1,
    out2,
    out3);
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 640
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_7d(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 640
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
)
{
  libcrux_ml_dsa_hash_functions_simd256_shake256_c8(input, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 576
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_fa(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 576
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
)
{
  libcrux_ml_dsa_hash_functions_simd256_shake256_1b(input, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_mask_ring_element
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_mask_ring_element_18(
  const Eurydice_arr_a2 *seed,
  Eurydice_arr_cd0 *result,
  size_t gamma1_exponent
)
{
  switch (gamma1_exponent)
  {
    case 17U:
      {
        break;
      }
    case 19U:
      {
        Eurydice_arr_c30 out = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_simd256_shake256_8c_c8(Eurydice_array_to_slice_shared_39(seed),
          &out);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_7d0(&out), result);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  Eurydice_arr_5f0 out = { .data = { 0U } };
  libcrux_ml_dsa_hash_functions_simd256_shake256_8c_1b(Eurydice_array_to_slice_shared_39(seed),
    &out);
  deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_fa(&out), result);
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_mask_vector
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_mask_vector_f4(
  size_t dimension,
  size_t gamma1_exponent,
  const Eurydice_arr_060 *seed,
  uint16_t *domain_separator,
  Eurydice_dst_ref_mut_2a mask
)
{
  Eurydice_arr_a2
  seed0 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      domain_separator[0U]);
  Eurydice_arr_a2
  seed1 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 1U);
  Eurydice_arr_a2
  seed2 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 2U);
  Eurydice_arr_a2
  seed3 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 3U);
  domain_separator[0U] = (uint32_t)domain_separator[0U] + 4U;
  switch (gamma1_exponent)
  {
    case 17U:
      {
        Eurydice_arr_5f0 out0 = { .data = { 0U } };
        Eurydice_arr_5f0 out1 = { .data = { 0U } };
        Eurydice_arr_5f0 out2 = { .data = { 0U } };
        Eurydice_arr_5f0 out3 = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_1b(Eurydice_array_to_slice_shared_39(&seed0),
          Eurydice_array_to_slice_shared_39(&seed1),
          Eurydice_array_to_slice_shared_39(&seed2),
          Eurydice_array_to_slice_shared_39(&seed3),
          &out0,
          &out1,
          &out2,
          &out3);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_fa(&out0), mask.ptr);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_fa(&out1), &mask.ptr[1U]);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_fa(&out2), &mask.ptr[2U]);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_fa(&out3), &mask.ptr[3U]);
        break;
      }
    case 19U:
      {
        Eurydice_arr_c30 out0 = { .data = { 0U } };
        Eurydice_arr_c30 out1 = { .data = { 0U } };
        Eurydice_arr_c30 out2 = { .data = { 0U } };
        Eurydice_arr_c30 out3 = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_c8(Eurydice_array_to_slice_shared_39(&seed0),
          Eurydice_array_to_slice_shared_39(&seed1),
          Eurydice_array_to_slice_shared_39(&seed2),
          Eurydice_array_to_slice_shared_39(&seed3),
          &out0,
          &out1,
          &out2,
          &out3);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_7d0(&out0), mask.ptr);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_7d0(&out1), &mask.ptr[1U]);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_7d0(&out2), &mask.ptr[2U]);
        deserialize_641(gamma1_exponent, Eurydice_array_to_slice_shared_7d0(&out3), &mask.ptr[3U]);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  for (size_t i = (size_t)4U; i < dimension; i++)
  {
    size_t i0 = i;
    Eurydice_arr_a2
    seed4 =
      libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
        domain_separator[0U]);
    domain_separator[0U] = (uint32_t)domain_separator[0U] + 1U;
    sample_mask_ring_element_18(&seed4, &mask.ptr[i0], gamma1_exponent);
  }
}

/**
 Compute InvertNTT(Â ◦ ŷ)
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_matrix_x_mask
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
compute_matrix_x_mask_64(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_2a matrix,
  Eurydice_dst_ref_shared_2a mask,
  Eurydice_dst_ref_mut_2a result
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      Eurydice_arr_cd0 product = mask.ptr[j];
      ntt_multiply_montgomery_64(&product, &matrix.ptr[i1 * columns_in_a + j]);
      add_ff_64(&result.ptr[i1], &product);
    }
    reduce_64(&result.ptr[i1]);
    invert_ntt_montgomery_64(&result.ptr[i1]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 16
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7111(const arr_30 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.decompose_vector
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
decompose_vector_64(
  size_t dimension,
  int32_t gamma2,
  Eurydice_dst_ref_shared_2a t,
  Eurydice_dst_ref_mut_2a low,
  Eurydice_dst_ref_mut_2a high
)
{
  for (size_t i0 = (size_t)0U; i0 < dimension; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      libcrux_ml_dsa_simd_avx2_decompose_a2(gamma2,
        &t.ptr[i1].data[j],
        &low.ptr[i1].data[j],
        &high.ptr[i1].data[j]);
    }
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.commitment.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_642(const Eurydice_arr_cd0 *re, Eurydice_mut_borrow_slice_u8 serialized)
{
  size_t output_bytes_per_simd_unit = serialized.meta / ((size_t)8U * (size_t)4U);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const __m256i *simd_unit = &re->data[i0];
    libcrux_ml_dsa_simd_avx2_commitment_serialize_a2(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * output_bytes_per_simd_unit,
            .end = (i0 + (size_t)1U) * output_bytes_per_simd_unit
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.commitment.serialize_vector
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_vector_64(
  size_t ring_element_size,
  Eurydice_dst_ref_shared_2a vector,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  size_t offset = (size_t)0U;
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t _cloop_j = i;
    const Eurydice_arr_cd0 *ring_element = &vector.ptr[_cloop_j];
    serialize_642(ring_element,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + ring_element_size
          }
        )));
    offset = offset + ring_element_size;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_challenge_ring_element
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_hash_functions_simd256_Shake256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
sample_challenge_ring_element_18(
  Eurydice_borrow_slice_u8 seed,
  size_t number_of_ones,
  Eurydice_arr_cd0 *re
)
{
  Eurydice_arr_26 state = libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_8c(seed);
  Eurydice_arr_3d
  randomness0 = libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_8c(&state);
  Eurydice_array_u8x8 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_360(&randomness0,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })).ptr,
    (size_t)8U * sizeof (uint8_t));
  uint64_t
  signs =
    core_num__u64__from_le_bytes(core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        )));
  Eurydice_arr_c3 result = { .data = { 0U } };
  size_t out_index = (size_t)256U - number_of_ones;
  bool
  done =
    libcrux_ml_dsa_sample_inside_out_shuffle(Eurydice_array_to_subslice_from_shared_8c(&randomness0,
        (size_t)8U),
      &out_index,
      &signs,
      &result);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_3d
      randomness = libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_8c(&state);
      done =
        libcrux_ml_dsa_sample_inside_out_shuffle(Eurydice_array_to_slice_shared_d4(&randomness),
          &out_index,
          &signs,
          &result);
    }
  }
  from_i32_array_ff_64(Eurydice_array_to_slice_shared_200(&result), re);
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.vector_times_ring_element
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
vector_times_ring_element_64(
  Eurydice_dst_ref_mut_2a vector,
  const Eurydice_arr_cd0 *ring_element
)
{
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t i0 = i;
    ntt_multiply_montgomery_64(&vector.ptr[i0], ring_element);
    invert_ntt_montgomery_64(&vector.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.add_vectors
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
add_vectors_64(size_t dimension, Eurydice_dst_ref_mut_2a lhs, Eurydice_dst_ref_shared_2a rhs)
{
  for (size_t i = (size_t)0U; i < dimension; i++)
  {
    size_t i0 = i;
    add_ff_64(&lhs.ptr[i0], &rhs.ptr[i0]);
  }
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.subtract_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
subtract_ff_64(Eurydice_arr_cd0 *self, const Eurydice_arr_cd0 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_subtract_a2(&self->data[i0], &rhs->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.subtract_vectors
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
subtract_vectors_64(
  size_t dimension,
  Eurydice_dst_ref_mut_2a lhs,
  Eurydice_dst_ref_shared_2a rhs
)
{
  for (size_t i = (size_t)0U; i < dimension; i++)
  {
    size_t i0 = i;
    subtract_ff_64(&lhs.ptr[i0], &rhs.ptr[i0]);
  }
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.infinity_norm_exceeds_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
infinity_norm_exceeds_ff_64(const Eurydice_arr_cd0 *self, int32_t bound)
{
  bool result = false;
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    bool uu____0;
    if (result)
    {
      uu____0 = true;
    }
    else
    {
      uu____0 = libcrux_ml_dsa_simd_avx2_infinity_norm_exceeds_a2(&self->data[i0], bound);
    }
    result = uu____0;
  }
  return result;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.vector_infinity_norm_exceeds
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE bool
vector_infinity_norm_exceeds_64(Eurydice_dst_ref_shared_2a vector, int32_t bound)
{
  bool result = false;
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t i0 = i;
    bool uu____0;
    if (result)
    {
      uu____0 = true;
    }
    else
    {
      uu____0 = infinity_norm_exceeds_ff_64(&vector.ptr[i0], bound);
    }
    result = uu____0;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.to_i32_array_ff
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_arr_c3
to_i32_array_ff_64(const Eurydice_arr_cd0 *self)
{
  Eurydice_arr_c3 result = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_to_coefficient_array_a2(&self->data[i0],
      Eurydice_array_to_subslice_mut_7f(&result,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT
          }
        )));
  }
  return result;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.make_hint
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE size_t
make_hint_64(
  Eurydice_dst_ref_shared_2a low,
  Eurydice_dst_ref_shared_2a high,
  int32_t gamma2,
  Eurydice_dst_ref_mut_22 hint
)
{
  size_t true_hints = (size_t)0U;
  Eurydice_arr_cd0 hint_simd = zero_ff_64();
  for (size_t i0 = (size_t)0U; i0 < low.meta; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      size_t
      one_hints_count =
        libcrux_ml_dsa_simd_avx2_compute_hint_a2(&low.ptr[i1].data[j],
          &high.ptr[i1].data[j],
          gamma2,
          &hint_simd.data[j]);
      true_hints = true_hints + one_hints_count;
    }
    Eurydice_arr_c3 uu____0 = to_i32_array_ff_64(&hint_simd);
    hint.ptr[i1] = uu____0;
  }
  return true_hints;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.gamma1.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_643(
  const Eurydice_arr_cd0 *re,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const __m256i *simd_unit = &re->data[i0];
    libcrux_ml_dsa_simd_avx2_gamma1_serialize_a2(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (gamma1_exponent + (size_t)1U),
            .end = (i0 + (size_t)1U) * (gamma1_exponent + (size_t)1U)
          }
        )),
      gamma1_exponent);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.serialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
serialize_644(
  Eurydice_borrow_slice_u8 commitment_hash,
  Eurydice_dst_ref_shared_2a signer_response,
  Eurydice_dst_ref_shared_22 hint,
  size_t commitment_hash_size,
  size_t columns_in_a,
  size_t rows_in_a,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  Eurydice_mut_borrow_slice_u8 signature
)
{
  size_t offset = (size_t)0U;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signature,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + commitment_hash_size
        }
      )),
    commitment_hash,
    uint8_t);
  offset = offset + commitment_hash_size;
  for (size_t i = (size_t)0U; i < columns_in_a; i++)
  {
    size_t i0 = i;
    serialize_643(&signer_response.ptr[i0],
      Eurydice_slice_subslice_mut_7e(signature,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + gamma1_ring_element_size
          }
        )),
      gamma1_exponent);
    offset = offset + gamma1_ring_element_size;
  }
  size_t true_hints_seen = (size_t)0U;
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)256U; i++)
    {
      size_t j = i;
      if (hint.ptr[i1].data[j] == (int32_t)1)
      {
        signature.ptr[offset + true_hints_seen] = (uint8_t)j;
        true_hints_seen++;
      }
    }
    signature.ptr[offset + max_ones_in_hint + i1] = (uint8_t)true_hints_seen;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_internal_07(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_15 s1_as_ntt;
  Eurydice_arr_cd0 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_15 s2_as_ntt;
  Eurydice_arr_cd0 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_15 t0_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression2[i] = zero_ff_64(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)4U * sizeof (Eurydice_arr_cd0));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    array_to_slice_mut_7111(&s1_as_ntt));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    array_to_slice_mut_7111(&s2_as_ntt));
  deserialize_to_vector_then_ntt_640(t0_serialized, array_to_slice_mut_7111(&t0_as_ntt));
  arr_30 matrix;
  Eurydice_arr_cd0 repeat_expression3[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression3[i] = zero_ff_64(););
  memcpy(matrix.data, repeat_expression3, (size_t)16U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7110(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_90 commitment_hash0 = { .tag = core_option_None };
  Option_9d signer_response0 = { .tag = core_option_None };
  core_option_Option_cf hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_15 mask;
    Eurydice_arr_cd0 repeat_expression4[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression4[i] = zero_ff_64(););
    memcpy(mask.data, repeat_expression4, (size_t)4U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_15 w0;
    Eurydice_arr_cd0 repeat_expression5[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression5[i] = zero_ff_64(););
    memcpy(w0.data, repeat_expression5, (size_t)4U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_15 commitment;
    Eurydice_arr_cd0 repeat_expression6[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression6[i] = zero_ff_64(););
    memcpy(commitment.data, repeat_expression6, (size_t)4U * sizeof (Eurydice_arr_cd0));
    sample_mask_vector_f4(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      array_to_slice_mut_7111(&mask));
    Eurydice_arr_15 a_x_mask;
    Eurydice_arr_cd0 repeat_expression[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_15
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &mask,
        Eurydice_arr_cd0,
        Eurydice_arr_15);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t i0 = i;
      ntt_64(&mask_ntt.data[i0]););
    compute_matrix_x_mask_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      array_to_slice_shared_7111(&matrix),
      array_to_slice_shared_719(&mask_ntt),
      array_to_slice_mut_7111(&a_x_mask));
    decompose_vector_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
      array_to_slice_shared_719(&a_x_mask),
      array_to_slice_mut_7111(&w0),
      array_to_slice_mut_7111(&commitment));
    Eurydice_arr_60 commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
    serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_COMMITMENT_RING_ELEMENT_SIZE,
      array_to_slice_shared_719(&commitment),
      Eurydice_array_to_slice_mut_ee(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_ee(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_6e(&commitment_hash_candidate));
    Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
    sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_6e(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    ntt_64(&verifier_challenge);
    Eurydice_arr_15
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &s1_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_15);
    Eurydice_arr_15
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &s2_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_15);
    vector_times_ring_element_64(array_to_slice_mut_7111(&challenge_times_s1),
      &verifier_challenge);
    vector_times_ring_element_64(array_to_slice_mut_7111(&challenge_times_s2),
      &verifier_challenge);
    add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      array_to_slice_mut_7111(&mask),
      array_to_slice_shared_719(&challenge_times_s1));
    subtract_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      array_to_slice_mut_7111(&w0),
      array_to_slice_shared_719(&challenge_times_s2));
    if
    (
      !vector_infinity_norm_exceeds_64(array_to_slice_shared_719(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
    )
    {
      if
      (
        !vector_infinity_norm_exceeds_64(array_to_slice_shared_719(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
      )
      {
        Eurydice_arr_15
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
            &t0_as_ntt,
            Eurydice_arr_cd0,
            Eurydice_arr_15);
        vector_times_ring_element_64(array_to_slice_mut_7111(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !vector_infinity_norm_exceeds_64(array_to_slice_shared_719(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2)
        )
        {
          add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
            array_to_slice_mut_7111(&w0),
            array_to_slice_shared_719(&challenge_times_t0));
          Eurydice_arr_83
          hint_candidate =
            {
              .data = {
                { .data = { 0U } },
                { .data = { 0U } },
                { .data = { 0U } },
                { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            make_hint_64(array_to_slice_shared_719(&w0),
              array_to_slice_shared_719(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
              Eurydice_array_to_slice_mut_6d(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_90){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 = (KRML_CLITERAL(Option_9d){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_cf){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_60 commitment_hash = commitment_hash0.f0;
    Eurydice_arr_60 commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_15 signer_response = signer_response0.f0;
      Eurydice_arr_15 signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_83 hint = hint0.f0;
        Eurydice_arr_83 hint1 = hint;
        serialize_644(Eurydice_array_to_slice_shared_6e(&commitment_hash1),
          array_to_slice_shared_719(&signer_response1),
          Eurydice_array_to_slice_shared_6d(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_180(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_mut_07(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_07(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_48
sign_07(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_400 signature = libcrux_ml_dsa_types_zero_c5_1a();
  core_result_Result_53
  uu____0 = sign_mut_07(signing_key, message, context, randomness, &signature);
  core_result_Result_48 uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_48){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_48){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_07(Eurydice_array_to_slice_shared_59(signing_key), message, context, randomness);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign__inner(signing_key,
      message,
      context,
      randomness);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  return
    sign_mut_07(Eurydice_array_to_slice_shared_59(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut__inner(signing_key,
      message,
      context,
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_37(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_07(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_48
sign_pre_hashed_37(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_400 signature = libcrux_ml_dsa_types_zero_c5_1a();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_37(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_48 uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_48){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_48){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_37(Eurydice_array_to_slice_shared_59(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 Sign (pre-hashed).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128__inner(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t1.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static void
deserialize_642(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_cd0 *result)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_t1_deserialize_a2(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T1_DESERIALIZE_WINDOW,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T1_DESERIALIZE_WINDOW
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
deserialize_643(
  size_t rows_in_a,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_2a t1
)
{
  for (size_t i = (size_t)0U; i < rows_in_a; i++)
  {
    size_t i0 = i;
    deserialize_642(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE
          }
        )),
      &t1.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.deserialize
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
deserialize_644(
  size_t columns_in_a,
  size_t rows_in_a,
  size_t commitment_hash_size,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_mut_borrow_slice_u8 out_commitment_hash,
  Eurydice_dst_ref_mut_2a out_signer_response,
  Eurydice_dst_ref_mut_22 out_hint
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(serialized,
      commitment_hash_size,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 commitment_hash = uu____0.fst;
  Eurydice_borrow_slice_u8 rest_of_serialized = uu____0.snd;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out_commitment_hash,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = commitment_hash_size })),
    commitment_hash,
    uint8_t);
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(rest_of_serialized,
      gamma1_ring_element_size * columns_in_a,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 signer_response_serialized = uu____1.fst;
  Eurydice_borrow_slice_u8 hint_serialized = uu____1.snd;
  for (size_t i = (size_t)0U; i < columns_in_a; i++)
  {
    size_t i0 = i;
    deserialize_641(gamma1_exponent,
      Eurydice_slice_subslice_shared_7e(signer_response_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * gamma1_ring_element_size,
            .end = (i0 + (size_t)1U) * gamma1_ring_element_size
          }
        )),
      &out_signer_response.ptr[i0]);
  }
  size_t previous_true_hints_seen = (size_t)0U;
  bool malformed_hint = false;
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    size_t current_true_hints_seen = (size_t)hint_serialized.ptr[max_ones_in_hint + i1];
    if (current_true_hints_seen < previous_true_hints_seen)
    {
      malformed_hint = true;
      break;
    }
    if (current_true_hints_seen > max_ones_in_hint)
    {
      malformed_hint = true;
      break;
    }
    for (size_t i = previous_true_hints_seen; i < current_true_hints_seen; i++)
    {
      size_t j = i;
      if (j > previous_true_hints_seen)
      {
        if (hint_serialized.ptr[j] <= hint_serialized.ptr[j - (size_t)1U])
        {
          malformed_hint = true;
          break;
        }
      }
      libcrux_ml_dsa_encoding_signature_set_hint(out_hint, i1, (size_t)hint_serialized.ptr[j]);
    }
    if (malformed_hint)
    {
      break;
    }
    previous_true_hints_seen = current_true_hints_seen;
  }
  for (size_t i = previous_true_hints_seen; i < max_ones_in_hint; i++)
  {
    size_t j = i;
    if (hint_serialized.ptr[j] != 0U)
    {
      malformed_hint = true;
      break;
    }
  }
  core_result_Result_41 uu____2;
  if (malformed_hint)
  {
    uu____2 =
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_MalformedHintError
        }
      );
  }
  else
  {
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 13
*/
KRML_ATTRIBUTE_TARGET("avx2")
inline void
libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_84(__m256i *simd_unit)
{
  __m256i shifted = mm256_slli_epi32((int32_t)13, simd_unit[0U], __m256i);
  __m256i quotient = mm256_add_epi32(shifted, mm256_set1_epi32((int32_t)1 << 22U));
  __m256i quotient0 = mm256_srai_epi32((int32_t)23, quotient, __m256i);
  __m256i
  quotient_times_field_modulus =
    mm256_mullo_epi32(quotient0,
      mm256_set1_epi32(LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS));
  simd_unit[0U] = mm256_sub_epi32(shifted, quotient_times_field_modulus);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.shift_left_then_reduce_a2
with const generics
- SHIFT_BY= 13
*/
KRML_ATTRIBUTE_TARGET("avx2")
KRML_MUSTINLINE void
libcrux_ml_dsa_simd_avx2_shift_left_then_reduce_a2_84(__m256i *simd_unit)
{
  libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_84(simd_unit);
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.shift_left_then_reduce
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- SHIFT_BY= 13
*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
shift_left_then_reduce_3a(Eurydice_arr_cd0 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_simd_avx2_shift_left_then_reduce_a2_84(&re->data[i0]);
  }
}

/**
 Compute InvertNTT(Â ◦ ẑ - ĉ ◦ NTT(t₁2ᵈ))
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_w_approx
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
compute_w_approx_64(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_2a matrix,
  Eurydice_dst_ref_shared_2a signer_response,
  const Eurydice_arr_cd0 *verifier_challenge_as_ntt,
  Eurydice_dst_ref_mut_2a t1
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    Eurydice_arr_cd0 inner_result = zero_ff_64();
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      Eurydice_arr_cd0 product = matrix.ptr[i1 * columns_in_a + j];
      ntt_multiply_montgomery_64(&product, &signer_response.ptr[j]);
      add_ff_64(&inner_result, &product);
    }
    shift_left_then_reduce_3a(&t1.ptr[i1]);
    ntt_64(&t1.ptr[i1]);
    ntt_multiply_montgomery_64(&t1.ptr[i1], verifier_challenge_as_ntt);
    subtract_ff_64(&inner_result, &t1.ptr[i1]);
    t1.ptr[i1] = inner_result;
    reduce_64(&t1.ptr[i1]);
    invert_ntt_montgomery_64(&t1.ptr[i1]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.use_hint
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
use_hint_64(int32_t gamma2, Eurydice_dst_ref_shared_22 hint, Eurydice_dst_ref_mut_2a re_vector)
{
  for (size_t i0 = (size_t)0U; i0 < re_vector.meta; i0++)
  {
    size_t i1 = i0;
    Eurydice_arr_cd0 tmp = zero_ff_64();
    from_i32_array_ff_64(Eurydice_array_to_slice_shared_200(&hint.ptr[i1]), &tmp);
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      libcrux_ml_dsa_simd_avx2_use_hint_a2(gamma2, &re_vector.ptr[i1].data[j], &tmp.data[j]);
    }
    re_vector.ptr[i1] = tmp;
  }
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_internal_07(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_400 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_bb(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_15 t1;
  Eurydice_arr_cd0 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_cd0));
  deserialize_643(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
    t1_serialized,
    array_to_slice_mut_7111(&t1));
  Eurydice_arr_60 deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_15 deserialized_signer_response;
  Eurydice_arr_cd0 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)4U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_83
  deserialized_hint =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  core_result_Result_41
  uu____1 =
    deserialize_644(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT,
      Eurydice_array_to_slice_shared_180(signature_serialized),
      Eurydice_array_to_slice_mut_6e(&deserialized_commitment_hash),
      array_to_slice_mut_7111(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      vector_infinity_norm_exceeds_64(array_to_slice_shared_719(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      arr_30 matrix;
      Eurydice_arr_cd0 repeat_expression[16U];
      KRML_MAYBE_FOR16(i,
        (size_t)0U,
        (size_t)16U,
        (size_t)1U,
        repeat_expression[i] = zero_ff_64(););
      memcpy(matrix.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_cd0));
      libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
        seed_for_a,
        array_to_slice_mut_7110(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(Eurydice_array_to_slice_shared_bb(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
      sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_6e(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      ntt_64(&verifier_challenge);
      KRML_MAYBE_FOR4(i,
        (size_t)0U,
        (size_t)4U,
        (size_t)1U,
        size_t i0 = i;
        ntt_64(&deserialized_signer_response.data[i0]););
      compute_w_approx_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
        array_to_slice_shared_7111(&matrix),
        array_to_slice_shared_719(&deserialized_signer_response),
        &verifier_challenge,
        array_to_slice_mut_7111(&t1));
      Eurydice_arr_60 recomputed_commitment_hash = { .data = { 0U } };
      use_hint_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
        Eurydice_array_to_slice_shared_6d(&deserialized_hint),
        array_to_slice_mut_7111(&t1));
      Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
      serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_COMMITMENT_RING_ELEMENT_SIZE,
        array_to_slice_shared_719(&t1),
        Eurydice_array_to_slice_mut_ee(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_ee(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_6e(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)32U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_07(
  const Eurydice_arr_40 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_07(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify__inner(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  return verify_07(verification_key, message, context, signature);
}

/**
 Verify.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify__inner(verification_key,
      message,
      context,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_37(
  const Eurydice_arr_40 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_07(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
)
{
  return verify_pre_hashed_37(verification_key, message, context, pre_hash_buffer, signature);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128__inner(verification_key,
      message,
      context,
      pre_hash_buffer,
      signature);
}

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $11size_t
*/
typedef struct arr_ad_s { Eurydice_arr_cd0 data[11U]; } arr_ad;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 11
*/
KRML_ATTRIBUTE_TARGET("avx2") static Eurydice_dst_ref_mut_2a array_to_slice_mut_7112(arr_ad *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)11U;
  return lit;
}

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $30size_t
*/
typedef struct arr_b7_s { Eurydice_arr_cd0 data[30U]; } arr_b7;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 30
*/
KRML_ATTRIBUTE_TARGET("avx2") static Eurydice_dst_ref_mut_2a array_to_slice_mut_7113(arr_b7 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)30U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 5
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_7114(Eurydice_arr_dd *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)5U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 11
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_subslice_shared_c33(const arr_ad *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_2a){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 5
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7112(const Eurydice_arr_dd *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)5U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 11
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7113(const arr_ad *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)11U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 6
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_7115(Eurydice_arr_b50 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 6
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7114(const Eurydice_arr_b50 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.generate_key_pair
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
generate_key_pair_070(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  arr_ad s1_s2;
  Eurydice_arr_cd0 repeat_expression0[11U];
  KRML_MAYBE_FOR11(i,
    (size_t)0U,
    (size_t)11U,
    (size_t)1U,
    repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)11U * sizeof (Eurydice_arr_cd0));
  sample_s1_and_s2_fc(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    seed_for_error_vectors,
    array_to_slice_mut_7112(&s1_s2));
  Eurydice_arr_b50 t0;
  Eurydice_arr_cd0 repeat_expression1[6U];
  KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(t0.data, repeat_expression1, (size_t)6U * sizeof (Eurydice_arr_cd0));
  arr_b7 a_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[30U];
  for (size_t i = (size_t)0U; i < (size_t)30U; i++)
  {
    repeat_expression2[i] = zero_ff_64();
  }
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)30U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7113(&a_as_ntt));
  Eurydice_arr_dd s1_ntt;
  Eurydice_arr_cd0 repeat_expression3[5U];
  KRML_MAYBE_FOR5(i, (size_t)0U, (size_t)5U, (size_t)1U, repeat_expression3[i] = zero_ff_64(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)5U * sizeof (Eurydice_arr_cd0));
  Eurydice_slice_copy(array_to_slice_mut_7114(&s1_ntt),
    array_to_subslice_shared_c33(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_cd0);
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i0 = i;
    ntt_64(&s1_ntt.data[i0]););
  compute_as1_plus_s2_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    array_to_slice_mut_7113(&a_as_ntt),
    array_to_slice_shared_7112(&s1_ntt),
    array_to_slice_shared_7113(&s1_s2),
    array_to_slice_mut_7115(&t0));
  Eurydice_arr_b50 t1;
  Eurydice_arr_cd0 repeat_expression[6U];
  KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression, (size_t)6U * sizeof (Eurydice_arr_cd0));
  power2round_vector_64(array_to_slice_mut_7115(&t0), array_to_slice_mut_7115(&t1));
  generate_serialized_64(seed_for_a, array_to_slice_shared_7114(&t1), verification_key);
  generate_serialized_18(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    array_to_slice_shared_7113(&s1_s2),
    array_to_slice_shared_7114(&t0),
    signing_key);
}

/**
 Key Generation.
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  generate_key_pair_070(randomness, signing_key, verification_key);
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair__inner(randomness,
    signing_key,
    verification_key);
}

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_dd

*/
typedef struct Option_ec_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_dd f0;
}
Option_ec;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 30
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7115(const arr_b7 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)30U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_internal_070(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_dd s1_as_ntt;
  Eurydice_arr_cd0 repeat_expression0[5U];
  KRML_MAYBE_FOR5(i, (size_t)0U, (size_t)5U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)5U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_b50 s2_as_ntt;
  Eurydice_arr_cd0 repeat_expression1[6U];
  KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)6U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_b50 t0_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[6U];
  KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression2[i] = zero_ff_64(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)6U * sizeof (Eurydice_arr_cd0));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    array_to_slice_mut_7114(&s1_as_ntt));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    array_to_slice_mut_7115(&s2_as_ntt));
  deserialize_to_vector_then_ntt_640(t0_serialized, array_to_slice_mut_7115(&t0_as_ntt));
  arr_b7 matrix;
  Eurydice_arr_cd0 repeat_expression3[30U];
  for (size_t i = (size_t)0U; i < (size_t)30U; i++)
  {
    repeat_expression3[i] = zero_ff_64();
  }
  memcpy(matrix.data, repeat_expression3, (size_t)30U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7113(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_a6 commitment_hash0 = { .tag = core_option_None };
  Option_ec signer_response0 = { .tag = core_option_None };
  core_option_Option_cb hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_dd mask;
    Eurydice_arr_cd0 repeat_expression4[5U];
    KRML_MAYBE_FOR5(i, (size_t)0U, (size_t)5U, (size_t)1U, repeat_expression4[i] = zero_ff_64(););
    memcpy(mask.data, repeat_expression4, (size_t)5U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_b50 w0;
    Eurydice_arr_cd0 repeat_expression5[6U];
    KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression5[i] = zero_ff_64(););
    memcpy(w0.data, repeat_expression5, (size_t)6U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_b50 commitment;
    Eurydice_arr_cd0 repeat_expression6[6U];
    KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression6[i] = zero_ff_64(););
    memcpy(commitment.data, repeat_expression6, (size_t)6U * sizeof (Eurydice_arr_cd0));
    sample_mask_vector_f4(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      array_to_slice_mut_7114(&mask));
    Eurydice_arr_b50 a_x_mask;
    Eurydice_arr_cd0 repeat_expression[6U];
    KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)6U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_dd
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)5U,
        &mask,
        Eurydice_arr_cd0,
        Eurydice_arr_dd);
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t i0 = i;
      ntt_64(&mask_ntt.data[i0]););
    compute_matrix_x_mask_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      array_to_slice_shared_7115(&matrix),
      array_to_slice_shared_7112(&mask_ntt),
      array_to_slice_mut_7115(&a_x_mask));
    decompose_vector_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
      array_to_slice_shared_7114(&a_x_mask),
      array_to_slice_mut_7115(&w0),
      array_to_slice_mut_7115(&commitment));
    Eurydice_arr_5f commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
    serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_COMMITMENT_RING_ELEMENT_SIZE,
      array_to_slice_shared_7114(&commitment),
      Eurydice_array_to_slice_mut_ee(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_ee(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_95(&commitment_hash_candidate));
    Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
    sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_95(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    ntt_64(&verifier_challenge);
    Eurydice_arr_dd
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)5U,
        &s1_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_dd);
    Eurydice_arr_b50
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)6U,
        &s2_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_b50);
    vector_times_ring_element_64(array_to_slice_mut_7114(&challenge_times_s1),
      &verifier_challenge);
    vector_times_ring_element_64(array_to_slice_mut_7115(&challenge_times_s2),
      &verifier_challenge);
    add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      array_to_slice_mut_7114(&mask),
      array_to_slice_shared_7112(&challenge_times_s1));
    subtract_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      array_to_slice_mut_7115(&w0),
      array_to_slice_shared_7114(&challenge_times_s2));
    if
    (
      !vector_infinity_norm_exceeds_64(array_to_slice_shared_7112(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
    )
    {
      if
      (
        !vector_infinity_norm_exceeds_64(array_to_slice_shared_7114(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
      )
      {
        Eurydice_arr_b50
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)6U,
            &t0_as_ntt,
            Eurydice_arr_cd0,
            Eurydice_arr_b50);
        vector_times_ring_element_64(array_to_slice_mut_7115(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !vector_infinity_norm_exceeds_64(array_to_slice_shared_7114(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2)
        )
        {
          add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
            array_to_slice_mut_7115(&w0),
            array_to_slice_shared_7114(&challenge_times_t0));
          Eurydice_arr_b5
          hint_candidate =
            {
              .data = {
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
                { .data = { 0U } }, { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            make_hint_64(array_to_slice_shared_7114(&w0),
              array_to_slice_shared_7114(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
              Eurydice_array_to_slice_mut_6d0(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_a6){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 = (KRML_CLITERAL(Option_ec){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_cb){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_5f commitment_hash = commitment_hash0.f0;
    Eurydice_arr_5f commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_dd signer_response = signer_response0.f0;
      Eurydice_arr_dd signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_b5 hint = hint0.f0;
        Eurydice_arr_b5 hint1 = hint;
        serialize_644(Eurydice_array_to_slice_shared_95(&commitment_hash1),
          array_to_slice_shared_7112(&signer_response1),
          Eurydice_array_to_slice_shared_6d0(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_ee0(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_mut_070(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_070(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_8c
sign_070(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_96 signature = libcrux_ml_dsa_types_zero_c5_fa();
  core_result_Result_53
  uu____0 = sign_mut_070(signing_key, message, context, randomness, &signature);
  core_result_Result_8c uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8c){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8c){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_070(Eurydice_array_to_slice_shared_ef(signing_key), message, context, randomness);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign__inner(signing_key,
      message,
      context,
      randomness);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  return
    sign_mut_070(Eurydice_array_to_slice_shared_ef(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut__inner(signing_key,
      message,
      context,
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_370(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_070(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_8c
sign_pre_hashed_370(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_96 signature = libcrux_ml_dsa_types_zero_c5_fa();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_370(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_8c uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8c){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8c){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_370(Eurydice_array_to_slice_shared_ef(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 Sign (pre-hashed).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128__inner(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_internal_070(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_96 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_5b(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_b50 t1;
  Eurydice_arr_cd0 repeat_expression0[6U];
  KRML_MAYBE_FOR6(i, (size_t)0U, (size_t)6U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression0, (size_t)6U * sizeof (Eurydice_arr_cd0));
  deserialize_643(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
    t1_serialized,
    array_to_slice_mut_7115(&t1));
  Eurydice_arr_5f deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_dd deserialized_signer_response;
  Eurydice_arr_cd0 repeat_expression1[5U];
  KRML_MAYBE_FOR5(i, (size_t)0U, (size_t)5U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)5U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_b5
  deserialized_hint =
    {
      .data = {
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
        { .data = { 0U } }, { .data = { 0U } }
      }
    };
  core_result_Result_41
  uu____1 =
    deserialize_644(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT,
      Eurydice_array_to_slice_shared_ee0(signature_serialized),
      Eurydice_array_to_slice_mut_95(&deserialized_commitment_hash),
      array_to_slice_mut_7114(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d0(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      vector_infinity_norm_exceeds_64(array_to_slice_shared_7112(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      arr_b7 matrix;
      Eurydice_arr_cd0 repeat_expression[30U];
      for (size_t i = (size_t)0U; i < (size_t)30U; i++)
      {
        repeat_expression[i] = zero_ff_64();
      }
      memcpy(matrix.data, repeat_expression, (size_t)30U * sizeof (Eurydice_arr_cd0));
      libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
        seed_for_a,
        array_to_slice_mut_7113(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(Eurydice_array_to_slice_shared_5b(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
      sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_95(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      ntt_64(&verifier_challenge);
      KRML_MAYBE_FOR5(i,
        (size_t)0U,
        (size_t)5U,
        (size_t)1U,
        size_t i0 = i;
        ntt_64(&deserialized_signer_response.data[i0]););
      compute_w_approx_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
        array_to_slice_shared_7115(&matrix),
        array_to_slice_shared_7112(&deserialized_signer_response),
        &verifier_challenge,
        array_to_slice_mut_7115(&t1));
      Eurydice_arr_5f recomputed_commitment_hash = { .data = { 0U } };
      use_hint_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
        Eurydice_array_to_slice_shared_6d0(&deserialized_hint),
        array_to_slice_mut_7115(&t1));
      Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
      serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_COMMITMENT_RING_ELEMENT_SIZE,
        array_to_slice_shared_7114(&t1),
        Eurydice_array_to_slice_mut_ee(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_ee(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_95(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)48U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_070(
  const Eurydice_arr_4a *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_070(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify__inner(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  return verify_070(verification_key, message, context, signature);
}

/**
 Verify.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify__inner(verification_key,
      message,
      context,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_370(
  const Eurydice_arr_4a *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_070(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
)
{
  return verify_pre_hashed_370(verification_key, message, context, pre_hash_buffer, signature);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128__inner(verification_key,
      message,
      context,
      pre_hash_buffer,
      signature);
}

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $15size_t
*/
typedef struct arr_34_s { Eurydice_arr_cd0 data[15U]; } arr_34;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 15
*/
KRML_ATTRIBUTE_TARGET("avx2") static Eurydice_dst_ref_mut_2a array_to_slice_mut_7116(arr_34 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)15U;
  return lit;
}

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b
with const generics
- $56size_t
*/
typedef struct arr_ad0_s { Eurydice_arr_cd0 data[56U]; } arr_ad0;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 56
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_7117(arr_ad0 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)56U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 7
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_mut_2a
array_to_slice_mut_7118(Eurydice_arr_39 *a)
{
  Eurydice_dst_ref_mut_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)7U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 15
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_subslice_shared_c34(const arr_34 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_2a){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 7
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7116(const Eurydice_arr_39 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)7U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 15
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7117(const arr_34 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)15U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.generate_key_pair
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE void
generate_key_pair_071(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  arr_34 s1_s2;
  Eurydice_arr_cd0 repeat_expression0[15U];
  KRML_MAYBE_FOR15(i,
    (size_t)0U,
    (size_t)15U,
    (size_t)1U,
    repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)15U * sizeof (Eurydice_arr_cd0));
  sample_s1_and_s2_fc(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    seed_for_error_vectors,
    array_to_slice_mut_7116(&s1_s2));
  Eurydice_arr_53 t0;
  Eurydice_arr_cd0 repeat_expression1[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(t0.data, repeat_expression1, (size_t)8U * sizeof (Eurydice_arr_cd0));
  arr_ad0 a_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[56U];
  for (size_t i = (size_t)0U; i < (size_t)56U; i++)
  {
    repeat_expression2[i] = zero_ff_64();
  }
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)56U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7117(&a_as_ntt));
  Eurydice_arr_39 s1_ntt;
  Eurydice_arr_cd0 repeat_expression3[7U];
  KRML_MAYBE_FOR7(i, (size_t)0U, (size_t)7U, (size_t)1U, repeat_expression3[i] = zero_ff_64(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)7U * sizeof (Eurydice_arr_cd0));
  Eurydice_slice_copy(array_to_slice_mut_7118(&s1_ntt),
    array_to_subslice_shared_c34(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_cd0);
  KRML_MAYBE_FOR7(i,
    (size_t)0U,
    (size_t)7U,
    (size_t)1U,
    size_t i0 = i;
    ntt_64(&s1_ntt.data[i0]););
  compute_as1_plus_s2_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    array_to_slice_mut_7117(&a_as_ntt),
    array_to_slice_shared_7116(&s1_ntt),
    array_to_slice_shared_7117(&s1_s2),
    array_to_slice_mut_719(&t0));
  Eurydice_arr_53 t1;
  Eurydice_arr_cd0 repeat_expression[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression, (size_t)8U * sizeof (Eurydice_arr_cd0));
  power2round_vector_64(array_to_slice_mut_719(&t0), array_to_slice_mut_719(&t1));
  generate_serialized_64(seed_for_a, array_to_slice_shared_7110(&t1), verification_key);
  generate_serialized_18(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    array_to_slice_shared_7117(&s1_s2),
    array_to_slice_shared_7110(&t0),
    signing_key);
}

/**
 Key Generation.
*/
KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  generate_key_pair_071(randomness, signing_key, verification_key);
}

KRML_ATTRIBUTE_TARGET("avx2")
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair__inner(randomness,
    signing_key,
    verification_key);
}

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_39

*/
typedef struct Option_c4_s
{
  core_option_Option_08_tags tag;
  Eurydice_arr_39 f0;
}
Option_c4;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- N= 56
*/
KRML_ATTRIBUTE_TARGET("avx2")
static Eurydice_dst_ref_shared_2a
array_to_slice_shared_7118(const arr_ad0 *a)
{
  Eurydice_dst_ref_shared_2a lit;
  lit.ptr = a->data;
  lit.meta = (size_t)56U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_internal_071(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_39 s1_as_ntt;
  Eurydice_arr_cd0 repeat_expression0[7U];
  KRML_MAYBE_FOR7(i, (size_t)0U, (size_t)7U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)7U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_53 s2_as_ntt;
  Eurydice_arr_cd0 repeat_expression1[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)8U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_53 t0_as_ntt;
  Eurydice_arr_cd0 repeat_expression2[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression2[i] = zero_ff_64(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)8U * sizeof (Eurydice_arr_cd0));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    array_to_slice_mut_7118(&s1_as_ntt));
  deserialize_to_vector_then_ntt_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    array_to_slice_mut_719(&s2_as_ntt));
  deserialize_to_vector_then_ntt_640(t0_serialized, array_to_slice_mut_719(&t0_as_ntt));
  arr_ad0 matrix;
  Eurydice_arr_cd0 repeat_expression3[56U];
  for (size_t i = (size_t)0U; i < (size_t)56U; i++)
  {
    repeat_expression3[i] = zero_ff_64();
  }
  memcpy(matrix.data, repeat_expression3, (size_t)56U * sizeof (Eurydice_arr_cd0));
  libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    seed_for_a,
    array_to_slice_mut_7117(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_d9 commitment_hash0 = { .tag = core_option_None };
  Option_c4 signer_response0 = { .tag = core_option_None };
  core_option_Option_b9 hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_39 mask;
    Eurydice_arr_cd0 repeat_expression4[7U];
    KRML_MAYBE_FOR7(i, (size_t)0U, (size_t)7U, (size_t)1U, repeat_expression4[i] = zero_ff_64(););
    memcpy(mask.data, repeat_expression4, (size_t)7U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_53 w0;
    Eurydice_arr_cd0 repeat_expression5[8U];
    KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression5[i] = zero_ff_64(););
    memcpy(w0.data, repeat_expression5, (size_t)8U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_53 commitment;
    Eurydice_arr_cd0 repeat_expression6[8U];
    KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression6[i] = zero_ff_64(););
    memcpy(commitment.data, repeat_expression6, (size_t)8U * sizeof (Eurydice_arr_cd0));
    sample_mask_vector_f4(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      array_to_slice_mut_7118(&mask));
    Eurydice_arr_53 a_x_mask;
    Eurydice_arr_cd0 repeat_expression[8U];
    KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression[i] = zero_ff_64(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)8U * sizeof (Eurydice_arr_cd0));
    Eurydice_arr_39
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)7U,
        &mask,
        Eurydice_arr_cd0,
        Eurydice_arr_39);
    KRML_MAYBE_FOR7(i,
      (size_t)0U,
      (size_t)7U,
      (size_t)1U,
      size_t i0 = i;
      ntt_64(&mask_ntt.data[i0]););
    compute_matrix_x_mask_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      array_to_slice_shared_7118(&matrix),
      array_to_slice_shared_7116(&mask_ntt),
      array_to_slice_mut_719(&a_x_mask));
    decompose_vector_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
      array_to_slice_shared_7110(&a_x_mask),
      array_to_slice_mut_719(&w0),
      array_to_slice_mut_719(&commitment));
    Eurydice_arr_060 commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_9e commitment_serialized = { .data = { 0U } };
    serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_COMMITMENT_RING_ELEMENT_SIZE,
      array_to_slice_shared_7110(&commitment),
      Eurydice_array_to_slice_mut_fd(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_fd(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_d8(&commitment_hash_candidate));
    Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
    sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_d8(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    ntt_64(&verifier_challenge);
    Eurydice_arr_39
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)7U,
        &s1_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_39);
    Eurydice_arr_53
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)8U,
        &s2_as_ntt,
        Eurydice_arr_cd0,
        Eurydice_arr_53);
    vector_times_ring_element_64(array_to_slice_mut_7118(&challenge_times_s1),
      &verifier_challenge);
    vector_times_ring_element_64(array_to_slice_mut_719(&challenge_times_s2), &verifier_challenge);
    add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      array_to_slice_mut_7118(&mask),
      array_to_slice_shared_7116(&challenge_times_s1));
    subtract_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      array_to_slice_mut_719(&w0),
      array_to_slice_shared_7110(&challenge_times_s2));
    if
    (
      !vector_infinity_norm_exceeds_64(array_to_slice_shared_7116(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
    )
    {
      if
      (
        !vector_infinity_norm_exceeds_64(array_to_slice_shared_7110(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
      )
      {
        Eurydice_arr_53
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)8U,
            &t0_as_ntt,
            Eurydice_arr_cd0,
            Eurydice_arr_53);
        vector_times_ring_element_64(array_to_slice_mut_719(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !vector_infinity_norm_exceeds_64(array_to_slice_shared_7110(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2)
        )
        {
          add_vectors_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
            array_to_slice_mut_719(&w0),
            array_to_slice_shared_7110(&challenge_times_t0));
          Eurydice_arr_fb
          hint_candidate =
            {
              .data = {
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            make_hint_64(array_to_slice_shared_7110(&w0),
              array_to_slice_shared_7110(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
              Eurydice_array_to_slice_mut_6d1(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_d9){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 = (KRML_CLITERAL(Option_c4){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_b9){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_060 commitment_hash = commitment_hash0.f0;
    Eurydice_arr_060 commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_39 signer_response = signer_response0.f0;
      Eurydice_arr_39 signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_fb hint = hint0.f0;
        Eurydice_arr_fb hint1 = hint;
        serialize_644(Eurydice_array_to_slice_shared_d8(&commitment_hash1),
          array_to_slice_shared_7116(&signer_response1),
          Eurydice_array_to_slice_shared_6d1(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_24(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_mut_071(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_071(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_8b
sign_071(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_38 signature = libcrux_ml_dsa_types_zero_c5_c2();
  core_result_Result_53
  uu____0 = sign_mut_071(signing_key, message, context, randomness, &signature);
  core_result_Result_8b uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8b){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8b){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_071(Eurydice_array_to_slice_shared_e2(signing_key), message, context, randomness);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign__inner(signing_key,
      message,
      context,
      randomness);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  return
    sign_mut_071(Eurydice_array_to_slice_shared_e2(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
 Sign.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut__inner(signing_key,
      message,
      context,
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_371(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_071(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_simd256_Shake256x4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_8b
sign_pre_hashed_371(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_38 signature = libcrux_ml_dsa_types_zero_c5_c2();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_371(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_8b uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8b){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8b){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_371(Eurydice_array_to_slice_shared_e2(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 Sign (pre-hashed).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128__inner(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify_internal
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_internal_071(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_38 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_f7(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_53 t1;
  Eurydice_arr_cd0 repeat_expression0[8U];
  KRML_MAYBE_FOR8(i, (size_t)0U, (size_t)8U, (size_t)1U, repeat_expression0[i] = zero_ff_64(););
  memcpy(t1.data, repeat_expression0, (size_t)8U * sizeof (Eurydice_arr_cd0));
  deserialize_643(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
    t1_serialized,
    array_to_slice_mut_719(&t1));
  Eurydice_arr_060 deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_39 deserialized_signer_response;
  Eurydice_arr_cd0 repeat_expression1[7U];
  KRML_MAYBE_FOR7(i, (size_t)0U, (size_t)7U, (size_t)1U, repeat_expression1[i] = zero_ff_64(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)7U * sizeof (Eurydice_arr_cd0));
  Eurydice_arr_fb
  deserialized_hint =
    {
      .data = {
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
      }
    };
  core_result_Result_41
  uu____1 =
    deserialize_644(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT,
      Eurydice_array_to_slice_shared_24(signature_serialized),
      Eurydice_array_to_slice_mut_d8(&deserialized_commitment_hash),
      array_to_slice_mut_7118(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d1(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      vector_infinity_norm_exceeds_64(array_to_slice_shared_7116(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      arr_ad0 matrix;
      Eurydice_arr_cd0 repeat_expression[56U];
      for (size_t i = (size_t)0U; i < (size_t)56U; i++)
      {
        repeat_expression[i] = zero_ff_64();
      }
      memcpy(matrix.data, repeat_expression, (size_t)56U * sizeof (Eurydice_arr_cd0));
      libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
        seed_for_a,
        array_to_slice_mut_7117(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(Eurydice_array_to_slice_shared_f7(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_cd0 verifier_challenge = zero_ff_64();
      sample_challenge_ring_element_18(Eurydice_array_to_slice_shared_d8(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      ntt_64(&verifier_challenge);
      KRML_MAYBE_FOR7(i,
        (size_t)0U,
        (size_t)7U,
        (size_t)1U,
        size_t i0 = i;
        ntt_64(&deserialized_signer_response.data[i0]););
      compute_w_approx_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
        array_to_slice_shared_7118(&matrix),
        array_to_slice_shared_7116(&deserialized_signer_response),
        &verifier_challenge,
        array_to_slice_mut_719(&t1));
      Eurydice_arr_060 recomputed_commitment_hash = { .data = { 0U } };
      use_hint_64(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
        Eurydice_array_to_slice_shared_6d1(&deserialized_hint),
        array_to_slice_mut_719(&t1));
      Eurydice_arr_9e commitment_serialized = { .data = { 0U } };
      serialize_vector_64(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_COMMITMENT_RING_ELEMENT_SIZE,
        array_to_slice_shared_7110(&t1),
        Eurydice_array_to_slice_mut_fd(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_fd(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_d8(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)64U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_071(
  const Eurydice_arr_51 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_071(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify__inner(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  return verify_071(verification_key, message, context, signature);
}

/**
 Verify.
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify__inner(verification_key,
      message,
      context,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify_pre_hashed
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256, libcrux_ml_dsa_samplex4_avx2_AVX2Sampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_simd256_Shake128x4, libcrux_ml_dsa_hash_functions_simd256_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
KRML_ATTRIBUTE_TARGET("avx2")
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_371(
  const Eurydice_arr_51 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_071(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
)
{
  return verify_pre_hashed_371(verification_key, message, context, pre_hash_buffer, signature);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
KRML_ATTRIBUTE_TARGET("avx2")
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
)
{
  return
    libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128__inner(verification_key,
      message,
      context,
      pre_hash_buffer,
      signature);
}

KRML_ATTRIBUTE_TARGET("avx2")
bool
libcrux_ml_dsa_simd_avx2_rejection_sample_shuffle_table_is_bit_set(
  size_t number,
  uint8_t bit_position
)
{
  return (number & (size_t)1U << (uint32_t)bit_position) >> (uint32_t)bit_position == (size_t)1U;
}

KRML_ATTRIBUTE_TARGET("avx2")
Eurydice_arr_0e
libcrux_ml_dsa_simd_avx2_rejection_sample_shuffle_table_generate_shuffle_table(void)
{
  Eurydice_arr_0e byte_shuffles;
  Eurydice_arr_88 repeat_expression0[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    Eurydice_arr_88 lit;
    uint8_t repeat_expression[16U];
    memset(repeat_expression, 255U, (size_t)16U * sizeof (uint8_t));
    memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (uint8_t));
    repeat_expression0[i] = lit;);
  memcpy(byte_shuffles.data, repeat_expression0, (size_t)16U * sizeof (Eurydice_arr_88));
  for (size_t i0 = (size_t)0U; i0 < (size_t)1U << 4U; i0++)
  {
    size_t bit_pattern = i0;
    size_t byte_shuffles_index = (size_t)0U;
    for (uint8_t i = 0U; i < 4U; i = (uint32_t)i + 1U)
    {
      uint8_t bit_position = i;
      if
      (
        libcrux_ml_dsa_simd_avx2_rejection_sample_shuffle_table_is_bit_set(bit_pattern,
          bit_position)
      )
      {
        byte_shuffles.data[bit_pattern].data[byte_shuffles_index] = (uint32_t)bit_position * 4U;
        byte_shuffles_index++;
        byte_shuffles.data[bit_pattern].data[byte_shuffles_index] = (uint32_t)bit_position * 4U + 1U;
        byte_shuffles_index++;
        byte_shuffles.data[bit_pattern].data[byte_shuffles_index] = (uint32_t)bit_position * 4U + 2U;
        byte_shuffles_index++;
        byte_shuffles.data[bit_pattern].data[byte_shuffles_index] = (uint32_t)bit_position * 4U + 3U;
        byte_shuffles_index++;
      }
    }
  }
  return byte_shuffles;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
KRML_ATTRIBUTE_TARGET("avx2")
inline __m256i
libcrux_ml_dsa_simd_avx2_vector_type_clone_be(const __m256i *self)
{
  return self[0U];
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa_avx2_H
#define libcrux_mldsa_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_sha3_internal.h"
#include "libcrux_sha3_avx2.h"
#include "libcrux_mldsa_core.h"

typedef libcrux_sha3_avx2_x4_incremental_KeccakState
libcrux_ml_dsa_hash_functions_simd256_Shake128x4;

typedef libcrux_sha3_portable_KeccakState libcrux_ml_dsa_hash_functions_simd256_Shake256;

typedef libcrux_sha3_avx2_x4_incremental_KeccakState
libcrux_ml_dsa_hash_functions_simd256_Shake256x4;

/**
 Init the state and absorb 4 blocks in parallel.
*/
Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

Eurydice_arr_26
libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_shake256(
  Eurydice_borrow_slice_u8 input
);

Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_shake256(Eurydice_arr_26 *state);

Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4(Eurydice_arr_05 *state);

void
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks(
  Eurydice_arr_05 *state,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
);

Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block(Eurydice_arr_05 *state);

Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_shake256(Eurydice_arr_26 *state);

Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4(Eurydice_arr_05 *state);

/**
 Init the state and absorb 4 blocks in parallel.
*/
/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_3b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
void
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_five_blocks_3b(
  Eurydice_arr_05 *self,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake128x4}
*/
Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_3b(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
Eurydice_arr_26
libcrux_ml_dsa_hash_functions_simd256_init_absorb_final_8c(Eurydice_borrow_slice_u8 input);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_8c(Eurydice_arr_26 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_8c(Eurydice_arr_26 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
Eurydice_arr_05
libcrux_ml_dsa_hash_functions_simd256_init_absorb_x4_ad(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_first_block_x4_ad(Eurydice_arr_05 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_simd256_squeeze_next_block_x4_ad(Eurydice_arr_05 *self);

typedef __m256i libcrux_ml_dsa_simd_avx2_vector_type_Vec256;

/**
 Create an all-zero vector coefficient
*/
__m256i libcrux_ml_dsa_simd_avx2_vector_type_zero(void);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
__m256i libcrux_ml_dsa_simd_avx2_zero_a2(void);

/**
 Create a coefficient from an `i32` array
*/
void
libcrux_ml_dsa_simd_avx2_vector_type_from_coefficient_array(
  Eurydice_dst_ref_shared_fc coefficient_array,
  __m256i *out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_from_coefficient_array_a2(
  Eurydice_dst_ref_shared_fc coefficient_array,
  __m256i *out
);

/**
 Write out the coefficient to an `i32` array
*/
void
libcrux_ml_dsa_simd_avx2_vector_type_to_coefficient_array(
  const __m256i *value,
  Eurydice_dst_ref_mut_fc out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_to_coefficient_array_a2(
  const __m256i *value,
  Eurydice_dst_ref_mut_fc out
);

void libcrux_ml_dsa_simd_avx2_arithmetic_add(__m256i *lhs, const __m256i *rhs);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_add_a2(__m256i *lhs, const __m256i *rhs);

void libcrux_ml_dsa_simd_avx2_arithmetic_subtract(__m256i *lhs, const __m256i *rhs);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_subtract_a2(__m256i *lhs, const __m256i *rhs);

bool
libcrux_ml_dsa_simd_avx2_arithmetic_infinity_norm_exceeds(
  const __m256i *simd_unit,
  int32_t bound
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
bool
libcrux_ml_dsa_simd_avx2_infinity_norm_exceeds_a2(const __m256i *simd_unit, int32_t bound);

__m256i libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives_ret(const __m256i *t);

void
libcrux_ml_dsa_simd_avx2_arithmetic_decompose(
  int32_t gamma2,
  const __m256i *r,
  __m256i *r0,
  __m256i *r1
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_decompose_a2(
  int32_t gamma2,
  const __m256i *simd_unit,
  __m256i *low,
  __m256i *high
);

size_t
libcrux_ml_dsa_simd_avx2_arithmetic_compute_hint(
  const __m256i *low,
  const __m256i *high,
  int32_t gamma2,
  __m256i *hint
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
size_t
libcrux_ml_dsa_simd_avx2_compute_hint_a2(
  const __m256i *low,
  const __m256i *high,
  int32_t gamma2,
  __m256i *hint
);

void
libcrux_ml_dsa_simd_avx2_arithmetic_use_hint(int32_t gamma2, const __m256i *r, __m256i *hint);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_use_hint_a2(int32_t gamma2, const __m256i *simd_unit, __m256i *hint);

void
libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_aux(
  __m256i field_modulus,
  __m256i inverse_of_modulus_mod_montgomery_r,
  __m256i *lhs,
  const __m256i *rhs
);

void libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply(__m256i *lhs, const __m256i *rhs);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_montgomery_multiply_a2(__m256i *lhs, const __m256i *rhs);

void libcrux_ml_dsa_simd_avx2_arithmetic_to_unsigned_representatives(__m256i *t);

void libcrux_ml_dsa_simd_avx2_arithmetic_power2round(__m256i *r0, __m256i *r1);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_power2round_a2(__m256i *t0, __m256i *t1);

#define LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_LESS_THAN_FIELD_MODULUS_BYTESTREAM_TO_POTENTIAL_COEFFICIENTS_COEFFICIENT_MASK (((int32_t)1 << 23U) - (int32_t)1)

__m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_bytestream_to_potential_coefficients(
  Eurydice_borrow_slice_u8 serialized
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_REJECTION_SAMPLE_SHUFFLE_TABLE_SHUFFLE_TABLE ((KRML_CLITERAL(Eurydice_arr_0e){ .data = { { .data = { 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U } }, { .data = { 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U } } } }))

size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_sample(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_field_modulus_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_DESERIALIZE_TO_UNSIGNED_WHEN_ETA_IS_4_COEFFICIENT_MASK (((int32_t)1 << 4U) - (int32_t)1)

__m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_4(
  Eurydice_borrow_slice_u8 bytes
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_DESERIALIZE_TO_UNSIGNED_WHEN_ETA_IS_2_COEFFICIENT_MASK (((int32_t)1 << 3U) - (int32_t)1)

__m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned_when_eta_is_2(
  Eurydice_borrow_slice_u8 bytes
);

__m256i
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize_to_unsigned(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.shift_interval
with const generics
- ETA= 2
*/
__m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_fd(__m256i coefficients);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.sample
with const generics
- ETA= 2
*/
size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_fd(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_2_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.shift_interval
with const generics
- ETA= 4
*/
__m256i
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_shift_interval_ac(__m256i coefficients);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.rejection_sample.less_than_eta.sample
with const generics
- ETA= 4
*/
size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_sample_ac(
  Eurydice_borrow_slice_u8 input,
  Eurydice_dst_ref_mut_fc output
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
size_t
libcrux_ml_dsa_simd_avx2_rejection_sample_less_than_eta_equals_4_a2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_2_POW_19 ((int32_t)1 << 19U)

__m256i
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19_aux(
  __m256i simd_unit_shifted
);

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_19(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_2_POW_17 ((int32_t)1 << 17U)

__m256i
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17_aux(
  __m256i simd_unit_shifted
);

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize_when_gamma1_is_2_pow_17(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_gamma1_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_17 ((int32_t)1 << 17U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_17_TIMES_2_MASK ((LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_17 << 1U) - (int32_t)1)

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_17_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_19 ((int32_t)1 << 19U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_19_TIMES_2_MASK ((LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_GAMMA1_GAMMA1_19 << 1U) - (int32_t)1)

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize_when_gamma1_is_2_pow_19_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

void
libcrux_ml_dsa_simd_avx2_encoding_gamma1_deserialize(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out,
  size_t gamma1_exponent
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_gamma1_deserialize_a2(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out,
  size_t gamma1_exponent
);

__m128i libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_4(const __m256i *simd_unit);

__m256i libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize_6(const __m256i *simd_unit);

void
libcrux_ml_dsa_simd_avx2_encoding_commitment_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_commitment_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_ETA_4 ((int32_t)4)

__m128i
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4_aux(__m256i simd_unit_shifted);

void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_4(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_ERROR_ETA_2 ((int32_t)2)

__m128i
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2_aux(__m256i simd_unit_shifted);

void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize_when_eta_is_2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

void
libcrux_ml_dsa_simd_avx2_encoding_error_serialize(
  libcrux_ml_dsa_constants_Eta eta,
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_error_serialize_a2(
  libcrux_ml_dsa_constants_Eta eta,
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
);

void
libcrux_ml_dsa_simd_avx2_encoding_error_deserialize(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_error_deserialize_a2(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T0_POW_2_BITS_IN_LOWER_PART_OF_T_MINUS_ONE ((int32_t)1 << (uint32_t)(LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T - (size_t)1U))

__m256i libcrux_ml_dsa_simd_avx2_encoding_t0_change_interval(const __m256i *simd_unit);

__m128i libcrux_ml_dsa_simd_avx2_encoding_t0_serialize_aux(__m256i simd_unit);

void
libcrux_ml_dsa_simd_avx2_encoding_t0_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_t0_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T0_DESERIALIZE_UNSIGNED_COEFFICIENT_MASK (((int32_t)1 << 13U) - (int32_t)1)

void
libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize_unsigned(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

void
libcrux_ml_dsa_simd_avx2_encoding_t0_deserialize(
  Eurydice_borrow_slice_u8 serialized,
  __m256i *out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_t0_deserialize_a2(Eurydice_borrow_slice_u8 serialized, __m256i *out);

void
libcrux_ml_dsa_simd_avx2_encoding_t1_serialize(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_t1_serialize_a2(
  const __m256i *simd_unit,
  Eurydice_mut_borrow_slice_u8 out
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_ENCODING_T1_DESERIALIZE_COEFFICIENT_MASK (((int32_t)1 << 10U) - (int32_t)1)

void
libcrux_ml_dsa_simd_avx2_encoding_t1_deserialize(Eurydice_borrow_slice_u8 bytes, __m256i *out);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void
libcrux_ml_dsa_simd_avx2_t1_deserialize_a2(Eurydice_borrow_slice_u8 serialized, __m256i *out);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_cd0_s { __m256i data[32U]; } Eurydice_arr_cd0;

void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6_mul(
  Eurydice_arr_cd0 *re,
  size_t index,
  __m256i zeta,
  size_t step_by,
  __m256i field_modulus,
  __m256i inverse_of_modulus_mod_montgomery_r
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_7 ((size_t)16U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_7_AND_6_STEP_BY_6 ((size_t)8U)

/**
 This is equivalent to the pqclean 0 and 1

 This does 32 Montgomery multiplications (192 multiplications).
 This is the same as in pqclean. The only difference is locality of registers.
*/
void libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_7_and_6(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 32
- STEP_BY= 4
*/
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_f6(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 16
- STEP_BY= 2
*/
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_90(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.ntt.ntt_at_layer_5_to_3.round
with const generics
- STEP= 8
- STEP_BY= 1
*/
void
libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3_round_7b(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta
);

/**
 Layer 5, 4, 3

 Each layer does 16 Montgomery multiplications -> 3*16 = 48 total
 pqclean does 4 * 4 on each layer -> 48 total | plus 4 * 4 shuffles every time (48)
*/
void libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_5_to_3(Eurydice_arr_cd0 *re);

void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_8(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta0,
  int32_t zeta1
);

void libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_2(Eurydice_arr_cd0 *re);

void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_4(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_a0,
  int32_t zeta_a1,
  int32_t zeta_b0,
  int32_t zeta_b1
);

void libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_1(Eurydice_arr_cd0 *re);

void
libcrux_ml_dsa_simd_avx2_ntt_butterfly_2(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_a0,
  int32_t zeta_a1,
  int32_t zeta_a2,
  int32_t zeta_a3,
  int32_t zeta_b0,
  int32_t zeta_b1,
  int32_t zeta_b2,
  int32_t zeta_b3
);

void libcrux_ml_dsa_simd_avx2_ntt_ntt_at_layer_0(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_ntt_ntt_avx2_ntt(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_ntt_ntt(Eurydice_arr_cd0 *re);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_ntt_a2(Eurydice_arr_cd0 *simd_units);

typedef struct libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2_s
{
  __m256i fst;
  __m256i snd;
}
libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2;

libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_0(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta02,
  int32_t zeta03,
  int32_t zeta10,
  int32_t zeta11,
  int32_t zeta12,
  int32_t zeta13
);

void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta02,
  int32_t zeta03,
  int32_t zeta10,
  int32_t zeta11,
  int32_t zeta12,
  int32_t zeta13
);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_0(Eurydice_arr_cd0 *re);

libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_1(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta00,
  int32_t zeta01,
  int32_t zeta10,
  int32_t zeta11
);

void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta_00,
  int32_t zeta_01,
  int32_t zeta_10,
  int32_t zeta_11
);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_1(Eurydice_arr_cd0 *re);

libcrux_ml_dsa_simd_avx2_vector_type_Vec256_x2
libcrux_ml_dsa_simd_avx2_invntt_simd_unit_invert_ntt_at_layer_2(
  __m256i simd_unit0,
  __m256i simd_unit1,
  int32_t zeta0,
  int32_t zeta1
);

void
libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2_round(
  Eurydice_arr_cd0 *re,
  size_t index,
  int32_t zeta1,
  int32_t zeta2
);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_2(Eurydice_arr_cd0 *re);

__m256i
libcrux_ml_dsa_simd_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i lhs,
  int32_t constant
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 1
- ZETA= 280005
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_99(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 2
- STEP_BY= 1
- ZETA= 4010497
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1c(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 1
- ZETA= -19422
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 6
- STEP_BY= 1
- ZETA= 1757237
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_44(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 1
- ZETA= -3277672
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a8(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 10
- STEP_BY= 1
- ZETA= -1399561
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_1f(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 1
- ZETA= -3859737
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_95(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 14
- STEP_BY= 1
- ZETA= -2118186
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 1
- ZETA= -2108549
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 18
- STEP_BY= 1
- ZETA= 2619752
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_e4(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 1
- ZETA= -1119584
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 22
- STEP_BY= 1
- ZETA= -549488
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_05(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 1
- ZETA= 3585928
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d9(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 26
- STEP_BY= 1
- ZETA= -1079900
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3a(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 1
- ZETA= 1024112
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b0(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 30
- STEP_BY= 1
- ZETA= 2725464
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a0(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_3(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 2
- ZETA= 2680103
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_990(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 2
- ZETA= 3111497
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_6b0(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 2
- ZETA= -2884855
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a80(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 2
- ZETA= 3119733
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_950(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 2
- ZETA= -2091905
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a0(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 2
- ZETA= -359251
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_de0(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 2
- ZETA= 2353451
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d90(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 2
- ZETA= 1826347
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_3b1(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_4(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 4
- ZETA= 466468
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_991(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 4
- ZETA= -876248
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_a81(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 4
- ZETA= -777960
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a1(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 4
- ZETA= 237124
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_d91(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_5(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 8
- ZETA= -518909
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_992(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 8
- ZETA= -2608894
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_7a2(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_6(Eurydice_arr_cd0 *re);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 16
- ZETA= 25847
*/
void libcrux_ml_dsa_simd_avx2_invntt_outer_3_plus_993(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_at_layer_7(Eurydice_arr_cd0 *re);

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_MONTGOMERY_INV_INNER_FACTOR ((int32_t)41978)

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery_inv_inner(Eurydice_arr_cd0 *re);

void libcrux_ml_dsa_simd_avx2_invntt_invert_ntt_montgomery(Eurydice_arr_cd0 *re);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_invert_ntt_montgomery_a2(Eurydice_arr_cd0 *simd_units);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 0
*/
void libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_c3(__m256i *simd_unit);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
void libcrux_ml_dsa_simd_avx2_reduce_a2(Eurydice_arr_cd0 *simd_units);

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_4b, size_t

*/
typedef struct Eurydice_dst_ref_mut_2a_s
{
  Eurydice_arr_cd0 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_2a;

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::avx2::AVX2Sampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.avx2.matrix_flat.inner_e8
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
void
libcrux_ml_dsa_samplex4_avx2_matrix_flat_inner_e8_64(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a matrix
);

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::avx2::AVX2Sampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.avx2.matrix_flat_e8
with types libcrux_ml_dsa_simd_avx2_vector_type_Vec256
with const generics

*/
void
libcrux_ml_dsa_samplex4_avx2_matrix_flat_e8_64(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_2a matrix
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 64
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 64
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
);

/**
 Key Generation.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4
with const generics
- OUT_LEN= 576
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4_ad
with const generics
- OUT_LEN= 576
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4
with const generics
- OUT_LEN= 640
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::simd256::Shake256x4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_x4_ad
with const generics
- OUT_LEN= 640
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_x4_ad_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 640
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 640
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256
with const generics
- OUTPUT_LENGTH= 576
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::simd256::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.simd256.shake256_8c
with const generics
- OUTPUT_LENGTH= 576
*/
void
libcrux_ml_dsa_hash_functions_simd256_shake256_8c_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
);

core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
);

core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Sign (pre-hashed).
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 13
*/
void libcrux_ml_dsa_simd_avx2_arithmetic_shift_left_then_reduce_84(__m256i *simd_unit);

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.simd.avx2.shift_left_then_reduce_a2
with const generics
- SHIFT_BY= 13
*/
void libcrux_ml_dsa_simd_avx2_shift_left_then_reduce_a2_84(__m256i *simd_unit);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify__inner(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_44_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
);

/**
 Key Generation.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
);

core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Sign (pre-hashed).
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify__inner(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_65_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
);

/**
 Key Generation.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair__inner(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

void
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
);

core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
);

core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128__inner(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Sign (pre-hashed).
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify__inner(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128__inner(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_avx2_ml_dsa_87_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
);

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_3_STEP ((size_t)8U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_3_STEP_BY ((size_t)1U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_4_STEP ((size_t)16U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_4_STEP_BY ((size_t)2U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_5_STEP ((size_t)32U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_5_STEP_BY ((size_t)4U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_6_STEP ((size_t)64U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_6_STEP_BY ((size_t)8U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_7_STEP ((size_t)128U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_INVERT_NTT_AT_LAYER_7_STEP_BY ((size_t)16U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_INVNTT_SIMD_UNIT_INVERT_NTT_AT_LAYER_0_SHUFFLE ((int32_t)216)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_BUTTERFLY_2_SHUFFLE ((int32_t)216)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP ((size_t)1U << 5U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_1 ((size_t)1U << 4U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_2 ((size_t)1U << 3U)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_BY (LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_BY_1 (LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_1 / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT)

#define LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_BY_2 (LIBCRUX_ML_DSA_SIMD_AVX2_NTT_NTT_AT_LAYER_5_TO_3_STEP_2 / LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT)

bool
libcrux_ml_dsa_simd_avx2_rejection_sample_shuffle_table_is_bit_set(
  size_t number,
  uint8_t bit_position
);

Eurydice_arr_0e
libcrux_ml_dsa_simd_avx2_rejection_sample_shuffle_table_generate_shuffle_table(void);

typedef Eurydice_arr_cd0 libcrux_ml_dsa_simd_avx2_vector_type_AVX2RingElement;

/**
This function found in impl {core::clone::Clone for libcrux_ml_dsa::simd::avx2::vector_type::Vec256}
*/
__m256i libcrux_ml_dsa_simd_avx2_vector_type_clone_be(const __m256i *self);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa_avx2_H_DEFINED
#endif /* libcrux_mldsa_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_core.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mldsa_core.h"

extern uint8_t
core_ops_bit__core__ops__bit__BitAnd_u8__u8__for__0__u8___bitand(const uint8_t *x0, uint8_t x1);

extern uint8_t
core_ops_bit__core__ops__bit__Shr_i32__u8__for__0__u8___shr(const uint8_t *x0, int32_t x1);

int32_t
libcrux_ml_dsa_constants_beta(
  size_t ones_in_verifier_challenge,
  libcrux_ml_dsa_constants_Eta eta
)
{
  size_t eta_val;
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        eta_val = (size_t)2U;
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        eta_val = (size_t)4U;
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return (int32_t)(ones_in_verifier_challenge * eta_val);
}

size_t
libcrux_ml_dsa_constants_commitment_ring_element_size(size_t bits_per_commitment_coefficient)
{
  return
    bits_per_commitment_coefficient * LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT /
      (size_t)8U;
}

size_t libcrux_ml_dsa_constants_error_ring_element_size(size_t bits_per_error_coefficient)
{
  return
    bits_per_error_coefficient * LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)8U;
}

size_t libcrux_ml_dsa_constants_gamma1_ring_element_size(size_t bits_per_gamma1_coefficient)
{
  return
    bits_per_gamma1_coefficient * LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT /
      (size_t)8U;
}

size_t
libcrux_ml_dsa_constants_signature_size(
  size_t rows_in_a,
  size_t columns_in_a,
  size_t max_ones_in_hint,
  size_t commitment_hash_size,
  size_t bits_per_gamma1_coefficient
)
{
  return
    commitment_hash_size +
      columns_in_a * libcrux_ml_dsa_constants_gamma1_ring_element_size(bits_per_gamma1_coefficient)
    + max_ones_in_hint
    + rows_in_a;
}

size_t libcrux_ml_dsa_constants_verification_key_size(size_t rows_in_a)
{
  return
    LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE +
      LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * rows_in_a *
        (LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS_MINUS_ONE_BIT_LENGTH -
          LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T)
      / (size_t)8U;
}

size_t libcrux_ml_dsa_encoding_error_chunk_size(libcrux_ml_dsa_constants_Eta eta)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        return (size_t)4U;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return (size_t)3U;
}

void
libcrux_ml_dsa_encoding_signature_set_hint(
  Eurydice_dst_ref_mut_22 out_hint,
  size_t i,
  size_t j
)
{
  out_hint.ptr[i].data[j] = (int32_t)1;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 66
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_36(Eurydice_arr_a2 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

Eurydice_arr_a2
libcrux_ml_dsa_sample_add_error_domain_separator(
  Eurydice_borrow_slice_u8 slice,
  uint16_t domain_separator
)
{
  Eurydice_arr_a2 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_36(&out,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  out.data[64U] = (uint8_t)domain_separator;
  out.data[65U] = (uint8_t)((uint32_t)domain_separator >> 8U);
  return out;
}

uint8_t_x2
libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(size_t index, size_t width)
{
  return
    (KRML_CLITERAL(uint8_t_x2){ .fst = (uint8_t)(index / width), .snd = (uint8_t)(index % width) });
}

static KRML_MUSTINLINE uint16_t generate_domain_separator(uint8_t_x2 _)
{
  uint8_t row = _.fst;
  uint8_t column = _.snd;
  return (uint32_t)(uint16_t)column | (uint32_t)(uint16_t)row << 8U;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 34
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_360(Eurydice_arr_48 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

Eurydice_arr_48
libcrux_ml_dsa_sample_add_domain_separator(Eurydice_borrow_slice_u8 slice, uint8_t_x2 indices)
{
  Eurydice_arr_48 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_360(&out,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  uint16_t domain_separator = generate_domain_separator(indices);
  out.data[32U] = (uint8_t)domain_separator;
  out.data[33U] = (uint8_t)((uint32_t)domain_separator >> 8U);
  return out;
}

/**
 `context` must be at most 255 bytes long.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
core_result_Result_a8
libcrux_ml_dsa_pre_hash_new_88(
  Eurydice_borrow_slice_u8 context,
  core_option_Option_b5 pre_hash_oid
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_a8){
          .tag = core_result_Ok,
          .val = { .case_Ok = { .context = context, .pre_hash_oid = pre_hash_oid } }
        }
      );
  }
  return
    (
      KRML_CLITERAL(core_result_Result_a8){
        .tag = core_result_Err,
        .val = { .case_Err = libcrux_ml_dsa_pre_hash_DomainSeparationError_ContextTooLongError }
      }
    );
}

/**
 Returns the pre-hash OID, if any.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
const
core_option_Option_b5
*libcrux_ml_dsa_pre_hash_pre_hash_oid_88(
  const libcrux_ml_dsa_pre_hash_DomainSeparationContext *self
)
{
  return &self->pre_hash_oid;
}

/**
 Returns the context, guaranteed to be at most 255 bytes long.
*/
/**
This function found in impl {libcrux_ml_dsa::pre_hash::DomainSeparationContext<'a>}
*/
Eurydice_borrow_slice_u8
libcrux_ml_dsa_pre_hash_context_88(const libcrux_ml_dsa_pre_hash_DomainSeparationContext *self)
{
  return self->context;
}

bool
libcrux_ml_dsa_sample_inside_out_shuffle(
  Eurydice_borrow_slice_u8 randomness,
  size_t *out_index,
  uint64_t *signs,
  Eurydice_arr_c3 *result
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta; i++)
  {
    size_t _cloop_j = i;
    const uint8_t *byte = &randomness.ptr[_cloop_j];
    if (!done)
    {
      size_t sample_at = (size_t)byte[0U];
      if (sample_at <= out_index[0U])
      {
        result->data[out_index[0U]] = result->data[sample_at];
        out_index[0U] = out_index[0U] + (size_t)1U;
        result->data[sample_at] = (int32_t)1 - (int32_t)2 * (int32_t)(signs[0U] & 1ULL);
        signs[0U] = signs[0U] >> 1U;
      }
      done = out_index[0U] == (size_t)256U;
    }
  }
  return done;
}

#define SHAKE128_OID ((KRML_CLITERAL(Eurydice_arr_cb){ .data = { 6U, 9U, 96U, 134U, 72U, 1U, 101U, 3U, 4U, 2U, 11U } }))

/**
This function found in impl {libcrux_ml_dsa::pre_hash::PreHash for libcrux_ml_dsa::pre_hash::SHAKE128_PH}
*/
Eurydice_arr_cb libcrux_ml_dsa_pre_hash_oid_30(void)
{
  return SHAKE128_OID;
}

static KRML_MUSTINLINE Eurydice_arr_d4 zero(void)
{
  return (KRML_CLITERAL(Eurydice_arr_d4){ .data = { 0U } });
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static Eurydice_arr_d4 zero_65(void)
{
  return zero();
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int32_t
with const generics
- N= 8
*/
static Eurydice_dst_ref_mut_fc array_to_slice_mut_a7(Eurydice_arr_d4 *a)
{
  Eurydice_dst_ref_mut_fc lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t

*/
Eurydice_dst_ref_shared_fc
Eurydice_slice_subslice_shared_46(Eurydice_dst_ref_shared_fc s, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_dst_ref_shared_fc){ .ptr = s.ptr + r.start, .meta = r.end - r.start });
}

static KRML_MUSTINLINE void
from_coefficient_array(Eurydice_dst_ref_shared_fc array, Eurydice_arr_d4 *out)
{
  Eurydice_slice_copy(array_to_slice_mut_a7(out),
    Eurydice_slice_subslice_shared_46(array,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT
        }
      )),
    int32_t);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void from_coefficient_array_65(Eurydice_dst_ref_shared_fc array, Eurydice_arr_d4 *out)
{
  from_coefficient_array(array, out);
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 8
*/
static Eurydice_dst_ref_shared_fc array_to_slice_shared_a7(const Eurydice_arr_d4 *a)
{
  Eurydice_dst_ref_shared_fc lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

static KRML_MUSTINLINE void
to_coefficient_array(const Eurydice_arr_d4 *value, Eurydice_dst_ref_mut_fc out)
{
  Eurydice_slice_copy(out, array_to_slice_shared_a7(value), int32_t);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void to_coefficient_array_65(const Eurydice_arr_d4 *value, Eurydice_dst_ref_mut_fc out)
{
  to_coefficient_array(value, out);
}

static KRML_MUSTINLINE void add(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs->data[uu____0] = lhs->data[uu____0] + rhs->data[i0];);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void add_65(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  add(lhs, rhs);
}

static KRML_MUSTINLINE void subtract(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs->data[uu____0] = lhs->data[uu____0] - rhs->data[i0];);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void subtract_65(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  subtract(lhs, rhs);
}

static KRML_MUSTINLINE bool
infinity_norm_exceeds(const Eurydice_arr_d4 *simd_unit, int32_t bound)
{
  bool result = false;
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    int32_t coefficient = simd_unit->data[i0];
    int32_t sign = coefficient >> 31U;
    int32_t normalized = coefficient - (sign & (int32_t)2 * coefficient);
    bool uu____0;
    if (result)
    {
      uu____0 = true;
    }
    else
    {
      uu____0 = normalized >= bound;
    }
    result = uu____0;);
  return result;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static bool infinity_norm_exceeds_65(const Eurydice_arr_d4 *simd_unit, int32_t bound)
{
  return infinity_norm_exceeds(simd_unit, bound);
}

typedef struct int32_t_x2_s
{
  int32_t fst;
  int32_t snd;
}
int32_t_x2;

static KRML_MUSTINLINE int32_t_x2 decompose_element(int32_t gamma2, int32_t r)
{
  int32_t r0 = r + (r >> 31U & LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  int32_t ceil_of_r_by_128 = (r0 + (int32_t)127) >> 7U;
  int32_t r1;
  switch (gamma2)
  {
    case 95232:
      {
        int32_t result = (ceil_of_r_by_128 * (int32_t)11275 + ((int32_t)1 << 23U)) >> 24U;
        int32_t result_0 = (result ^ ((int32_t)43 - result) >> 31U) & result;
        r1 = result_0;
        break;
      }
    case 261888:
      {
        int32_t result = (ceil_of_r_by_128 * (int32_t)1025 + ((int32_t)1 << 21U)) >> 22U;
        int32_t result_0 = result & (int32_t)15;
        r1 = result_0;
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  int32_t alpha = gamma2 * (int32_t)2;
  int32_t r00 = r0 - r1 * alpha;
  r00 =
    r00 -
      (((LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS - (int32_t)1) / (int32_t)2 - r00) >> 31U &
        LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  return (KRML_CLITERAL(int32_t_x2){ .fst = r00, .snd = r1 });
}

static KRML_MUSTINLINE void
decompose(
  int32_t gamma2,
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_arr_d4 *low,
  Eurydice_arr_d4 *high
)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    int32_t_x2 uu____0 = decompose_element(gamma2, simd_unit->data[i0]);
    int32_t uu____1 = uu____0.snd;
    low->data[i0] = uu____0.fst;
    high->data[i0] = uu____1;);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
decompose_65(
  int32_t gamma2,
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_arr_d4 *low,
  Eurydice_arr_d4 *high
)
{
  decompose(gamma2, simd_unit, low, high);
}

static KRML_MUSTINLINE int32_t compute_one_hint(int32_t low, int32_t high, int32_t gamma2)
{
  int32_t uu____0;
  if (low > gamma2)
  {
    uu____0 = (int32_t)1;
  }
  else if (low < -gamma2)
  {
    uu____0 = (int32_t)1;
  }
  else if (low == -gamma2)
  {
    if (high != (int32_t)0)
    {
      uu____0 = (int32_t)1;
    }
    else
    {
      uu____0 = (int32_t)0;
    }
  }
  else
  {
    uu____0 = (int32_t)0;
  }
  return uu____0;
}

static KRML_MUSTINLINE size_t
compute_hint(
  const Eurydice_arr_d4 *low,
  const Eurydice_arr_d4 *high,
  int32_t gamma2,
  Eurydice_arr_d4 *hint
)
{
  size_t one_hints_count = (size_t)0U;
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    hint->data[i0] = compute_one_hint(low->data[i0], high->data[i0], gamma2);
    one_hints_count = one_hints_count + (size_t)hint->data[i0];);
  return one_hints_count;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static size_t
compute_hint_65(
  const Eurydice_arr_d4 *low,
  const Eurydice_arr_d4 *high,
  int32_t gamma2,
  Eurydice_arr_d4 *hint
)
{
  return compute_hint(low, high, gamma2, hint);
}

static KRML_MUSTINLINE int32_t use_one_hint(int32_t gamma2, int32_t r, int32_t hint)
{
  int32_t_x2 uu____0 = decompose_element(gamma2, r);
  int32_t r0 = uu____0.fst;
  int32_t r1 = uu____0.snd;
  int32_t uu____1;
  if (!(hint == (int32_t)0))
  {
    switch (gamma2)
    {
      case 95232:
        {
          if (r0 > (int32_t)0)
          {
            if (r1 == (int32_t)43)
            {
              uu____1 = (int32_t)0;
            }
            else
            {
              uu____1 = r1 + hint;
            }
          }
          else if (r1 == (int32_t)0)
          {
            uu____1 = (int32_t)43;
          }
          else
          {
            uu____1 = r1 - hint;
          }
          break;
        }
      case 261888:
        {
          if (r0 > (int32_t)0)
          {
            uu____1 = (r1 + hint) & (int32_t)15;
          }
          else
          {
            uu____1 = (r1 - hint) & (int32_t)15;
          }
          break;
        }
      default:
        {
          KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
          KRML_HOST_EXIT(255U);
        }
    }
    return uu____1;
  }
  return r1;
}

static KRML_MUSTINLINE void
use_hint(int32_t gamma2, const Eurydice_arr_d4 *simd_unit, Eurydice_arr_d4 *hint)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    int32_t uu____0 = use_one_hint(gamma2, simd_unit->data[i0], hint->data[i0]);
    hint->data[i0] = uu____0;);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
use_hint_65(int32_t gamma2, const Eurydice_arr_d4 *simd_unit, Eurydice_arr_d4 *hint)
{
  use_hint(gamma2, simd_unit, hint);
}

static KRML_MUSTINLINE uint64_t get_n_least_significant_bits(uint8_t n, uint64_t value)
{
  return value & ((1ULL << (uint32_t)n) - 1ULL);
}

#define MONTGOMERY_SHIFT (32U)

static KRML_MUSTINLINE int32_t montgomery_reduce_element(int64_t value)
{
  uint64_t
  t =
    get_n_least_significant_bits(MONTGOMERY_SHIFT, (uint64_t)value) *
      LIBCRUX_ML_DSA_SIMD_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R;
  int32_t k = (int32_t)get_n_least_significant_bits(MONTGOMERY_SHIFT, t);
  int64_t k_times_modulus = (int64_t)k * (int64_t)LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS;
  int32_t c = (int32_t)(k_times_modulus >> (uint32_t)MONTGOMERY_SHIFT);
  int32_t value_high = (int32_t)(value >> (uint32_t)MONTGOMERY_SHIFT);
  return value_high - c;
}

static KRML_MUSTINLINE void
montgomery_multiply(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    lhs->data[i0] = montgomery_reduce_element((int64_t)lhs->data[i0] * (int64_t)rhs->data[i0]););
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void montgomery_multiply_65(Eurydice_arr_d4 *lhs, const Eurydice_arr_d4 *rhs)
{
  montgomery_multiply(lhs, rhs);
}

static KRML_MUSTINLINE int32_t reduce_element(int32_t fe)
{
  int32_t quotient = (fe + ((int32_t)1 << 22U)) >> 23U;
  return fe - quotient * LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS;
}

static KRML_MUSTINLINE int32_t_x2 power2round_element(int32_t t)
{
  int32_t t2 = t + (t >> 31U & LIBCRUX_ML_DSA_SIMD_TRAITS_FIELD_MODULUS);
  int32_t
  t1 =
    (t2 - (int32_t)1 +
      ((int32_t)1 << (uint32_t)(LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T - (size_t)1U)))
    >> (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T;
  int32_t t0 = t2 - (t1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T);
  return (KRML_CLITERAL(int32_t_x2){ .fst = t0, .snd = t1 });
}

static KRML_MUSTINLINE void power2round(Eurydice_arr_d4 *t0, Eurydice_arr_d4 *t1)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    int32_t_x2 uu____0 = power2round_element(t0->data[i0]);
    int32_t uu____1 = uu____0.snd;
    t0->data[i0] = uu____0.fst;
    t1->data[i0] = uu____1;);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void power2round_65(Eurydice_arr_d4 *t0, Eurydice_arr_d4 *t1)
{
  power2round(t0, t1);
}

static KRML_MUSTINLINE size_t
rejection_sample_less_than_field_modulus(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  size_t sampled = (size_t)0U;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)3U; i++)
  {
    size_t i0 = i;
    int32_t b0 = (int32_t)randomness.ptr[i0 * (size_t)3U];
    int32_t b1 = (int32_t)randomness.ptr[i0 * (size_t)3U + (size_t)1U];
    int32_t b2 = (int32_t)randomness.ptr[i0 * (size_t)3U + (size_t)2U];
    int32_t coefficient = ((b2 << 16U | b1 << 8U) | b0) & (int32_t)8388607;
    if (coefficient < LIBCRUX_ML_DSA_CONSTANTS_FIELD_MODULUS)
    {
      out.ptr[sampled] = coefficient;
      sampled++;
    }
  }
  return sampled;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static size_t
rejection_sample_less_than_field_modulus_65(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return rejection_sample_less_than_field_modulus(randomness, out);
}

static KRML_MUSTINLINE size_t
rejection_sample_less_than_eta_equals_2(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  size_t sampled = (size_t)0U;
  for (size_t i = (size_t)0U; i < randomness.meta; i++)
  {
    size_t i0 = i;
    uint8_t byte = randomness.ptr[i0];
    uint8_t try_0 = (uint32_t)byte & 15U;
    uint8_t try_1 = (uint32_t)byte >> 4U;
    if (try_0 < 15U)
    {
      int32_t try_00 = (int32_t)try_0;
      int32_t try_0_mod_5 = try_00 - (try_00 * (int32_t)26 >> 7U) * (int32_t)5;
      out.ptr[sampled] = (int32_t)2 - try_0_mod_5;
      sampled++;
    }
    if (try_1 < 15U)
    {
      int32_t try_10 = (int32_t)try_1;
      int32_t try_1_mod_5 = try_10 - (try_10 * (int32_t)26 >> 7U) * (int32_t)5;
      out.ptr[sampled] = (int32_t)2 - try_1_mod_5;
      sampled++;
    }
  }
  return sampled;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static size_t
rejection_sample_less_than_eta_equals_2_65(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return rejection_sample_less_than_eta_equals_2(randomness, out);
}

static KRML_MUSTINLINE size_t
rejection_sample_less_than_eta_equals_4(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  size_t sampled = (size_t)0U;
  for (size_t i = (size_t)0U; i < randomness.meta; i++)
  {
    size_t i0 = i;
    uint8_t byte = randomness.ptr[i0];
    uint8_t try_0 = (uint32_t)byte & 15U;
    uint8_t try_1 = (uint32_t)byte >> 4U;
    if (try_0 < 9U)
    {
      out.ptr[sampled] = (int32_t)4 - (int32_t)try_0;
      sampled++;
    }
    if (try_1 < 9U)
    {
      out.ptr[sampled] = (int32_t)4 - (int32_t)try_1;
      sampled++;
    }
  }
  return sampled;
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static size_t
rejection_sample_less_than_eta_equals_4_65(
  Eurydice_borrow_slice_u8 randomness,
  Eurydice_dst_ref_mut_fc out
)
{
  return rejection_sample_less_than_eta_equals_4(randomness, out);
}

#define GAMMA1 ((int32_t)1 << 19U)

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t
with const generics
- N= 8
*/
static Eurydice_dst_ref_shared_fc
array_to_subslice_shared_7f(const Eurydice_arr_d4 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_fc){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

static KRML_MUSTINLINE void
serialize_when_gamma1_is_2_pow_19(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  for (size_t i = (size_t)0U; i < (size_t)8U / (size_t)2U; i++)
  {
    size_t i0 = i;
    Eurydice_dst_ref_shared_fc
    coefficients =
      array_to_subslice_shared_7f(simd_unit,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)2U,
            .end = i0 * (size_t)2U + (size_t)2U
          }
        ));
    int32_t coefficient0 = GAMMA1 - coefficients.ptr[0U];
    int32_t coefficient1 = GAMMA1 - coefficients.ptr[1U];
    serialized.ptr[(size_t)5U * i0] = (uint8_t)coefficient0;
    serialized.ptr[(size_t)5U * i0 + (size_t)1U] = (uint8_t)(coefficient0 >> 8U);
    serialized.ptr[(size_t)5U * i0 + (size_t)2U] = (uint8_t)(coefficient0 >> 16U);
    size_t uu____0 = (size_t)5U * i0 + (size_t)2U;
    serialized.ptr[uu____0] =
      (uint32_t)serialized.ptr[uu____0] | (uint32_t)(uint8_t)(coefficient1 << 4U);
    serialized.ptr[(size_t)5U * i0 + (size_t)3U] = (uint8_t)(coefficient1 >> 4U);
    serialized.ptr[(size_t)5U * i0 + (size_t)4U] = (uint8_t)(coefficient1 >> 12U);
  }
}

#define GAMMA10 ((int32_t)1 << 17U)

static KRML_MUSTINLINE void
serialize_when_gamma1_is_2_pow_17(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  for (size_t i = (size_t)0U; i < (size_t)8U / (size_t)4U; i++)
  {
    size_t i0 = i;
    Eurydice_dst_ref_shared_fc
    coefficients =
      array_to_subslice_shared_7f(simd_unit,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)4U,
            .end = i0 * (size_t)4U + (size_t)4U
          }
        ));
    int32_t coefficient0 = GAMMA10 - coefficients.ptr[0U];
    int32_t coefficient1 = GAMMA10 - coefficients.ptr[1U];
    int32_t coefficient2 = GAMMA10 - coefficients.ptr[2U];
    int32_t coefficient3 = GAMMA10 - coefficients.ptr[3U];
    serialized.ptr[(size_t)9U * i0] = (uint8_t)coefficient0;
    serialized.ptr[(size_t)9U * i0 + (size_t)1U] = (uint8_t)(coefficient0 >> 8U);
    serialized.ptr[(size_t)9U * i0 + (size_t)2U] = (uint8_t)(coefficient0 >> 16U);
    size_t uu____0 = (size_t)9U * i0 + (size_t)2U;
    serialized.ptr[uu____0] =
      (uint32_t)serialized.ptr[uu____0] | (uint32_t)(uint8_t)(coefficient1 << 2U);
    serialized.ptr[(size_t)9U * i0 + (size_t)3U] = (uint8_t)(coefficient1 >> 6U);
    serialized.ptr[(size_t)9U * i0 + (size_t)4U] = (uint8_t)(coefficient1 >> 14U);
    size_t uu____1 = (size_t)9U * i0 + (size_t)4U;
    serialized.ptr[uu____1] =
      (uint32_t)serialized.ptr[uu____1] | (uint32_t)(uint8_t)(coefficient2 << 4U);
    serialized.ptr[(size_t)9U * i0 + (size_t)5U] = (uint8_t)(coefficient2 >> 4U);
    serialized.ptr[(size_t)9U * i0 + (size_t)6U] = (uint8_t)(coefficient2 >> 12U);
    size_t uu____2 = (size_t)9U * i0 + (size_t)6U;
    serialized.ptr[uu____2] =
      (uint32_t)serialized.ptr[uu____2] | (uint32_t)(uint8_t)(coefficient3 << 6U);
    serialized.ptr[(size_t)9U * i0 + (size_t)7U] = (uint8_t)(coefficient3 >> 2U);
    serialized.ptr[(size_t)9U * i0 + (size_t)8U] = (uint8_t)(coefficient3 >> 10U);
  }
}

static KRML_MUSTINLINE void
serialize(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  switch (gamma1_exponent)
  {
    case 17U:
      {
        break;
      }
    case 19U:
      {
        serialize_when_gamma1_is_2_pow_19(simd_unit, serialized);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  serialize_when_gamma1_is_2_pow_17(simd_unit, serialized);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
gamma1_serialize_65(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  serialize(simd_unit, serialized, gamma1_exponent);
}

#define GAMMA11 ((int32_t)1 << 19U)

#define GAMMA1_TIMES_2_BITMASK ((GAMMA11 << 1U) - (int32_t)1)

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_shared_7e(Eurydice_borrow_slice_u8 s, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start });
}

static KRML_MUSTINLINE void
deserialize_when_gamma1_is_2_pow_19(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_d4 *simd_unit
)
{
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)5U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)5U,
            .end = i0 * (size_t)5U + (size_t)5U
          }
        ));
    int32_t coefficient0 = (int32_t)bytes.ptr[0U];
    coefficient0 = coefficient0 | (int32_t)bytes.ptr[1U] << 8U;
    coefficient0 = coefficient0 | (int32_t)bytes.ptr[2U] << 16U;
    coefficient0 = coefficient0 & GAMMA1_TIMES_2_BITMASK;
    int32_t coefficient1 = (int32_t)bytes.ptr[2U] >> 4U;
    coefficient1 = coefficient1 | (int32_t)bytes.ptr[3U] << 4U;
    coefficient1 = coefficient1 | (int32_t)bytes.ptr[4U] << 12U;
    simd_unit->data[(size_t)2U * i0] = GAMMA11 - coefficient0;
    simd_unit->data[(size_t)2U * i0 + (size_t)1U] = GAMMA11 - coefficient1;
  }
}

#define GAMMA12 ((int32_t)1 << 17U)

#define GAMMA1_TIMES_2_BITMASK0 ((GAMMA12 << 1U) - (int32_t)1)

static KRML_MUSTINLINE void
deserialize_when_gamma1_is_2_pow_17(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_d4 *simd_unit
)
{
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)9U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)9U,
            .end = i0 * (size_t)9U + (size_t)9U
          }
        ));
    int32_t coefficient0 = (int32_t)bytes.ptr[0U];
    coefficient0 = coefficient0 | (int32_t)bytes.ptr[1U] << 8U;
    coefficient0 = coefficient0 | (int32_t)bytes.ptr[2U] << 16U;
    coefficient0 = coefficient0 & GAMMA1_TIMES_2_BITMASK0;
    int32_t coefficient1 = (int32_t)bytes.ptr[2U] >> 2U;
    coefficient1 = coefficient1 | (int32_t)bytes.ptr[3U] << 6U;
    coefficient1 = coefficient1 | (int32_t)bytes.ptr[4U] << 14U;
    coefficient1 = coefficient1 & GAMMA1_TIMES_2_BITMASK0;
    int32_t coefficient2 = (int32_t)bytes.ptr[4U] >> 4U;
    coefficient2 = coefficient2 | (int32_t)bytes.ptr[5U] << 4U;
    coefficient2 = coefficient2 | (int32_t)bytes.ptr[6U] << 12U;
    coefficient2 = coefficient2 & GAMMA1_TIMES_2_BITMASK0;
    int32_t coefficient3 = (int32_t)bytes.ptr[6U] >> 6U;
    coefficient3 = coefficient3 | (int32_t)bytes.ptr[7U] << 2U;
    coefficient3 = coefficient3 | (int32_t)bytes.ptr[8U] << 10U;
    coefficient3 = coefficient3 & GAMMA1_TIMES_2_BITMASK0;
    simd_unit->data[(size_t)4U * i0] = GAMMA12 - coefficient0;
    simd_unit->data[(size_t)4U * i0 + (size_t)1U] = GAMMA12 - coefficient1;
    simd_unit->data[(size_t)4U * i0 + (size_t)2U] = GAMMA12 - coefficient2;
    simd_unit->data[(size_t)4U * i0 + (size_t)3U] = GAMMA12 - coefficient3;
  }
}

static KRML_MUSTINLINE void
deserialize(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *out, size_t gamma1_exponent)
{
  switch (gamma1_exponent)
  {
    case 17U:
      {
        break;
      }
    case 19U:
      {
        deserialize_when_gamma1_is_2_pow_19(serialized, out);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  deserialize_when_gamma1_is_2_pow_17(serialized, out);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
gamma1_deserialize_65(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_d4 *out,
  size_t gamma1_exponent
)
{
  deserialize(serialized, out, gamma1_exponent);
}

static KRML_MUSTINLINE void
serialize_4(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 serialized)
{
  uint8_t coefficient0 = (uint8_t)simd_unit->data[0U];
  uint8_t coefficient1 = (uint8_t)simd_unit->data[1U];
  uint8_t coefficient2 = (uint8_t)simd_unit->data[2U];
  uint8_t coefficient3 = (uint8_t)simd_unit->data[3U];
  uint8_t coefficient4 = (uint8_t)simd_unit->data[4U];
  uint8_t coefficient5 = (uint8_t)simd_unit->data[5U];
  uint8_t coefficient6 = (uint8_t)simd_unit->data[6U];
  uint8_t coefficient7 = (uint8_t)simd_unit->data[7U];
  uint8_t byte0 = (uint32_t)coefficient1 << 4U | (uint32_t)coefficient0;
  uint8_t byte1 = (uint32_t)coefficient3 << 4U | (uint32_t)coefficient2;
  uint8_t byte2 = (uint32_t)coefficient5 << 4U | (uint32_t)coefficient4;
  uint8_t byte3 = (uint32_t)coefficient7 << 4U | (uint32_t)coefficient6;
  serialized.ptr[0U] = byte0;
  serialized.ptr[1U] = byte1;
  serialized.ptr[2U] = byte2;
  serialized.ptr[3U] = byte3;
}

static KRML_MUSTINLINE void
serialize_6(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 serialized)
{
  uint8_t coefficient0 = (uint8_t)simd_unit->data[0U];
  uint8_t coefficient1 = (uint8_t)simd_unit->data[1U];
  uint8_t coefficient2 = (uint8_t)simd_unit->data[2U];
  uint8_t coefficient3 = (uint8_t)simd_unit->data[3U];
  uint8_t coefficient4 = (uint8_t)simd_unit->data[4U];
  uint8_t coefficient5 = (uint8_t)simd_unit->data[5U];
  uint8_t coefficient6 = (uint8_t)simd_unit->data[6U];
  uint8_t coefficient7 = (uint8_t)simd_unit->data[7U];
  uint8_t byte0 = (uint32_t)coefficient1 << 6U | (uint32_t)coefficient0;
  uint8_t byte1 = (uint32_t)coefficient2 << 4U | (uint32_t)coefficient1 >> 2U;
  uint8_t byte2 = (uint32_t)coefficient3 << 2U | (uint32_t)coefficient2 >> 4U;
  uint8_t byte3 = (uint32_t)coefficient5 << 6U | (uint32_t)coefficient4;
  uint8_t byte4 = (uint32_t)coefficient6 << 4U | (uint32_t)coefficient5 >> 2U;
  uint8_t byte5 = (uint32_t)coefficient7 << 2U | (uint32_t)coefficient6 >> 4U;
  serialized.ptr[0U] = byte0;
  serialized.ptr[1U] = byte1;
  serialized.ptr[2U] = byte2;
  serialized.ptr[3U] = byte3;
  serialized.ptr[4U] = byte4;
  serialized.ptr[5U] = byte5;
}

static KRML_MUSTINLINE void
serialize0(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 serialized)
{
  switch ((uint8_t)serialized.meta)
  {
    case 4U:
      {
        serialize_4(simd_unit, serialized);
        break;
      }
    case 6U:
      {
        serialize_6(simd_unit, serialized);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
commitment_serialize_65(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  serialize0(simd_unit, serialized);
}

#define ETA ((int32_t)4)

static KRML_MUSTINLINE void
serialize_when_eta_is_4(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  for (size_t i = (size_t)0U; i < (size_t)8U / (size_t)2U; i++)
  {
    size_t i0 = i;
    Eurydice_dst_ref_shared_fc
    coefficients =
      array_to_subslice_shared_7f(simd_unit,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)2U,
            .end = i0 * (size_t)2U + (size_t)2U
          }
        ));
    uint8_t coefficient0 = (uint8_t)(ETA - coefficients.ptr[0U]);
    uint8_t coefficient1 = (uint8_t)(ETA - coefficients.ptr[1U]);
    serialized.ptr[i0] = (uint32_t)coefficient1 << 4U | (uint32_t)coefficient0;
  }
}

#define ETA0 ((int32_t)2)

static KRML_MUSTINLINE void
serialize_when_eta_is_2(
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  uint8_t coefficient0 = (uint8_t)(ETA0 - simd_unit->data[0U]);
  uint8_t coefficient1 = (uint8_t)(ETA0 - simd_unit->data[1U]);
  uint8_t coefficient2 = (uint8_t)(ETA0 - simd_unit->data[2U]);
  uint8_t coefficient3 = (uint8_t)(ETA0 - simd_unit->data[3U]);
  uint8_t coefficient4 = (uint8_t)(ETA0 - simd_unit->data[4U]);
  uint8_t coefficient5 = (uint8_t)(ETA0 - simd_unit->data[5U]);
  uint8_t coefficient6 = (uint8_t)(ETA0 - simd_unit->data[6U]);
  uint8_t coefficient7 = (uint8_t)(ETA0 - simd_unit->data[7U]);
  serialized.ptr[0U] =
    ((uint32_t)coefficient2 << 6U | (uint32_t)coefficient1 << 3U) | (uint32_t)coefficient0;
  serialized.ptr[1U] =
    (((uint32_t)coefficient5 << 7U | (uint32_t)coefficient4 << 4U) | (uint32_t)coefficient3 << 1U)
    | (uint32_t)coefficient2 >> 2U;
  serialized.ptr[2U] =
    ((uint32_t)coefficient7 << 5U | (uint32_t)coefficient6 << 2U) | (uint32_t)coefficient5 >> 1U;
}

static KRML_MUSTINLINE void
serialize1(
  libcrux_ml_dsa_constants_Eta eta,
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        serialize_when_eta_is_4(simd_unit, serialized);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  serialize_when_eta_is_2(simd_unit, serialized);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
error_serialize_65(
  libcrux_ml_dsa_constants_Eta eta,
  const Eurydice_arr_d4 *simd_unit,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  serialize1(eta, simd_unit, serialized);
}

#define ETA1 ((int32_t)4)

static KRML_MUSTINLINE void
deserialize_when_eta_is_4(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *simd_units)
{
  for (size_t i = (size_t)0U; i < serialized.meta; i++)
  {
    size_t i0 = i;
    const uint8_t *byte = &serialized.ptr[i0];
    uint8_t uu____0 = core_ops_bit__core__ops__bit__BitAnd_u8__u8__for__0__u8___bitand(byte, 15U);
    simd_units->data[(size_t)2U * i0] = ETA1 - (int32_t)uu____0;
    uint8_t
    uu____1 = core_ops_bit__core__ops__bit__Shr_i32__u8__for__0__u8___shr(byte, (int32_t)4);
    simd_units->data[(size_t)2U * i0 + (size_t)1U] = ETA1 - (int32_t)uu____1;
  }
}

#define ETA2 ((int32_t)2)

static KRML_MUSTINLINE void
deserialize_when_eta_is_2(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *simd_unit)
{
  int32_t byte0 = (int32_t)serialized.ptr[0U];
  int32_t byte1 = (int32_t)serialized.ptr[1U];
  int32_t byte2 = (int32_t)serialized.ptr[2U];
  simd_unit->data[0U] = ETA2 - (byte0 & (int32_t)7);
  simd_unit->data[1U] = ETA2 - (byte0 >> 3U & (int32_t)7);
  simd_unit->data[2U] = ETA2 - ((byte0 >> 6U | byte1 << 2U) & (int32_t)7);
  simd_unit->data[3U] = ETA2 - (byte1 >> 1U & (int32_t)7);
  simd_unit->data[4U] = ETA2 - (byte1 >> 4U & (int32_t)7);
  simd_unit->data[5U] = ETA2 - ((byte1 >> 7U | byte2 << 1U) & (int32_t)7);
  simd_unit->data[6U] = ETA2 - (byte2 >> 2U & (int32_t)7);
  simd_unit->data[7U] = ETA2 - (byte2 >> 5U & (int32_t)7);
}

static KRML_MUSTINLINE void
deserialize0(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_d4 *out
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        deserialize_when_eta_is_4(serialized, out);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  deserialize_when_eta_is_2(serialized, out);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void
error_deserialize_65(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_d4 *out
)
{
  deserialize0(eta, serialized, out);
}

static KRML_MUSTINLINE int32_t change_t0_interval(int32_t t0)
{
  return
    ((int32_t)1 << (uint32_t)(LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T - (size_t)1U)) - t0;
}

static KRML_MUSTINLINE void
serialize2(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 serialized)
{
  int32_t coefficient0 = change_t0_interval(simd_unit->data[0U]);
  int32_t coefficient1 = change_t0_interval(simd_unit->data[1U]);
  int32_t coefficient2 = change_t0_interval(simd_unit->data[2U]);
  int32_t coefficient3 = change_t0_interval(simd_unit->data[3U]);
  int32_t coefficient4 = change_t0_interval(simd_unit->data[4U]);
  int32_t coefficient5 = change_t0_interval(simd_unit->data[5U]);
  int32_t coefficient6 = change_t0_interval(simd_unit->data[6U]);
  int32_t coefficient7 = change_t0_interval(simd_unit->data[7U]);
  serialized.ptr[0U] = (uint8_t)coefficient0;
  serialized.ptr[1U] =
    (uint32_t)(uint8_t)(coefficient0 >> 8U) | (uint32_t)(uint8_t)(coefficient1 << 5U);
  serialized.ptr[2U] = (uint8_t)(coefficient1 >> 3U);
  serialized.ptr[3U] =
    (uint32_t)(uint8_t)(coefficient1 >> 11U) | (uint32_t)(uint8_t)(coefficient2 << 2U);
  serialized.ptr[4U] =
    (uint32_t)(uint8_t)(coefficient2 >> 6U) | (uint32_t)(uint8_t)(coefficient3 << 7U);
  serialized.ptr[5U] = (uint8_t)(coefficient3 >> 1U);
  serialized.ptr[6U] =
    (uint32_t)(uint8_t)(coefficient3 >> 9U) | (uint32_t)(uint8_t)(coefficient4 << 4U);
  serialized.ptr[7U] = (uint8_t)(coefficient4 >> 4U);
  serialized.ptr[8U] =
    (uint32_t)(uint8_t)(coefficient4 >> 12U) | (uint32_t)(uint8_t)(coefficient5 << 1U);
  serialized.ptr[9U] =
    (uint32_t)(uint8_t)(coefficient5 >> 7U) | (uint32_t)(uint8_t)(coefficient6 << 6U);
  serialized.ptr[10U] = (uint8_t)(coefficient6 >> 2U);
  serialized.ptr[11U] =
    (uint32_t)(uint8_t)(coefficient6 >> 10U) | (uint32_t)(uint8_t)(coefficient7 << 3U);
  serialized.ptr[12U] = (uint8_t)(coefficient7 >> 5U);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void t0_serialize_65(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 out)
{
  serialize2(simd_unit, out);
}

#define BITS_IN_LOWER_PART_OF_T_MASK (((int32_t)1 << (uint32_t)(int32_t)LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T) - (int32_t)1)

static KRML_MUSTINLINE void
deserialize1(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *simd_unit)
{
  int32_t byte0 = (int32_t)serialized.ptr[0U];
  int32_t byte1 = (int32_t)serialized.ptr[1U];
  int32_t byte2 = (int32_t)serialized.ptr[2U];
  int32_t byte3 = (int32_t)serialized.ptr[3U];
  int32_t byte4 = (int32_t)serialized.ptr[4U];
  int32_t byte5 = (int32_t)serialized.ptr[5U];
  int32_t byte6 = (int32_t)serialized.ptr[6U];
  int32_t byte7 = (int32_t)serialized.ptr[7U];
  int32_t byte8 = (int32_t)serialized.ptr[8U];
  int32_t byte9 = (int32_t)serialized.ptr[9U];
  int32_t byte10 = (int32_t)serialized.ptr[10U];
  int32_t byte11 = (int32_t)serialized.ptr[11U];
  int32_t byte12 = (int32_t)serialized.ptr[12U];
  int32_t coefficient0 = byte0;
  coefficient0 = coefficient0 | byte1 << 8U;
  coefficient0 = coefficient0 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient1 = byte1 >> 5U;
  coefficient1 = coefficient1 | byte2 << 3U;
  coefficient1 = coefficient1 | byte3 << 11U;
  coefficient1 = coefficient1 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient2 = byte3 >> 2U;
  coefficient2 = coefficient2 | byte4 << 6U;
  coefficient2 = coefficient2 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient3 = byte4 >> 7U;
  coefficient3 = coefficient3 | byte5 << 1U;
  coefficient3 = coefficient3 | byte6 << 9U;
  coefficient3 = coefficient3 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient4 = byte6 >> 4U;
  coefficient4 = coefficient4 | byte7 << 4U;
  coefficient4 = coefficient4 | byte8 << 12U;
  coefficient4 = coefficient4 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient5 = byte8 >> 1U;
  coefficient5 = coefficient5 | byte9 << 7U;
  coefficient5 = coefficient5 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient6 = byte9 >> 6U;
  coefficient6 = coefficient6 | byte10 << 2U;
  coefficient6 = coefficient6 | byte11 << 10U;
  coefficient6 = coefficient6 & BITS_IN_LOWER_PART_OF_T_MASK;
  int32_t coefficient7 = byte11 >> 3U;
  coefficient7 = coefficient7 | byte12 << 5U;
  coefficient7 = coefficient7 & BITS_IN_LOWER_PART_OF_T_MASK;
  simd_unit->data[0U] = change_t0_interval(coefficient0);
  simd_unit->data[1U] = change_t0_interval(coefficient1);
  simd_unit->data[2U] = change_t0_interval(coefficient2);
  simd_unit->data[3U] = change_t0_interval(coefficient3);
  simd_unit->data[4U] = change_t0_interval(coefficient4);
  simd_unit->data[5U] = change_t0_interval(coefficient5);
  simd_unit->data[6U] = change_t0_interval(coefficient6);
  simd_unit->data[7U] = change_t0_interval(coefficient7);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void t0_deserialize_65(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *out)
{
  deserialize1(serialized, out);
}

static KRML_MUSTINLINE void
serialize3(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < (size_t)8U / (size_t)4U; i++)
  {
    size_t i0 = i;
    Eurydice_dst_ref_shared_fc
    coefficients =
      array_to_subslice_shared_7f(simd_unit,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)4U,
            .end = i0 * (size_t)4U + (size_t)4U
          }
        ));
    serialized.ptr[(size_t)5U * i0] = (uint8_t)(coefficients.ptr[0U] & (int32_t)255);
    serialized.ptr[(size_t)5U * i0 + (size_t)1U] =
      (uint32_t)(uint8_t)(coefficients.ptr[1U] & (int32_t)63) << 2U |
        (uint32_t)(uint8_t)(coefficients.ptr[0U] >> 8U & (int32_t)3);
    serialized.ptr[(size_t)5U * i0 + (size_t)2U] =
      (uint32_t)(uint8_t)(coefficients.ptr[2U] & (int32_t)15) << 4U |
        (uint32_t)(uint8_t)(coefficients.ptr[1U] >> 6U & (int32_t)15);
    serialized.ptr[(size_t)5U * i0 + (size_t)3U] =
      (uint32_t)(uint8_t)(coefficients.ptr[3U] & (int32_t)3) << 6U |
        (uint32_t)(uint8_t)(coefficients.ptr[2U] >> 4U & (int32_t)63);
    serialized.ptr[(size_t)5U * i0 + (size_t)4U] =
      (uint8_t)(coefficients.ptr[3U] >> 2U & (int32_t)255);
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void t1_serialize_65(const Eurydice_arr_d4 *simd_unit, Eurydice_mut_borrow_slice_u8 out)
{
  serialize3(simd_unit, out);
}

static KRML_MUSTINLINE void
deserialize2(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *simd_unit)
{
  int32_t
  mask = ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_UPPER_PART_OF_T) - (int32_t)1;
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)5U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (size_t)5U,
            .end = i0 * (size_t)5U + (size_t)5U
          }
        ));
    int32_t byte0 = (int32_t)bytes.ptr[0U];
    int32_t byte1 = (int32_t)bytes.ptr[1U];
    int32_t byte2 = (int32_t)bytes.ptr[2U];
    int32_t byte3 = (int32_t)bytes.ptr[3U];
    int32_t byte4 = (int32_t)bytes.ptr[4U];
    simd_unit->data[(size_t)4U * i0] = (byte0 | byte1 << 8U) & mask;
    simd_unit->data[(size_t)4U * i0 + (size_t)1U] = (byte1 >> 2U | byte2 << 6U) & mask;
    simd_unit->data[(size_t)4U * i0 + (size_t)2U] = (byte2 >> 4U | byte3 << 4U) & mask;
    simd_unit->data[(size_t)4U * i0 + (size_t)3U] = (byte3 >> 6U | byte4 << 2U) & mask;
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void t1_deserialize_65(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_d4 *out)
{
  deserialize2(serialized, out);
}

static KRML_MUSTINLINE void
montgomery_multiply_by_constant(Eurydice_arr_d4 *simd_unit, int32_t c)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    simd_unit->data[i0] = montgomery_reduce_element((int64_t)simd_unit->data[i0] * (int64_t)c););
}

static KRML_MUSTINLINE void
round(Eurydice_arr_a4 *re, size_t index, size_t step_by, int32_t zeta)
{
  Eurydice_arr_d4 tmp = re->data[index + step_by];
  montgomery_multiply_by_constant(&tmp, zeta);
  re->data[index + step_by] = re->data[index];
  subtract(&re->data[index + step_by], &tmp);
  add(&re->data[index], &tmp);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 16
- ZETA= 25847
*/
static KRML_MUSTINLINE void outer_3_plus_99(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)16U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)16U, (int32_t)25847);
  }
}

static KRML_MUSTINLINE void ntt_at_layer_7(Eurydice_arr_a4 *re)
{
  outer_3_plus_99(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 8
- ZETA= -2608894
*/
static KRML_MUSTINLINE void outer_3_plus_990(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)8U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)8U, (int32_t)-2608894);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 8
- ZETA= -518909
*/
static KRML_MUSTINLINE void outer_3_plus_7a(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)8U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)8U, (int32_t)-518909);
  }
}

static KRML_MUSTINLINE void ntt_at_layer_6(Eurydice_arr_a4 *re)
{
  outer_3_plus_990(re);
  outer_3_plus_7a(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 4
- ZETA= 237124
*/
static KRML_MUSTINLINE void outer_3_plus_991(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)4U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)4U, (int32_t)237124);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 4
- ZETA= -777960
*/
static KRML_MUSTINLINE void outer_3_plus_a8(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)4U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)4U, (int32_t)-777960);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 4
- ZETA= -876248
*/
static KRML_MUSTINLINE void outer_3_plus_7a0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)4U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)4U, (int32_t)-876248);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 4
- ZETA= 466468
*/
static KRML_MUSTINLINE void outer_3_plus_d9(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)4U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)4U, (int32_t)466468);
  }
}

static KRML_MUSTINLINE void ntt_at_layer_5(Eurydice_arr_a4 *re)
{
  outer_3_plus_991(re);
  outer_3_plus_a8(re);
  outer_3_plus_7a0(re);
  outer_3_plus_d9(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 2
- ZETA= 1826347
*/
static KRML_MUSTINLINE void outer_3_plus_992(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)1826347);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 2
- ZETA= 2353451
*/
static KRML_MUSTINLINE void outer_3_plus_6b(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)2353451);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 2
- ZETA= -359251
*/
static KRML_MUSTINLINE void outer_3_plus_a80(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)-359251);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 2
- ZETA= -2091905
*/
static KRML_MUSTINLINE void outer_3_plus_95(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)-2091905);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 2
- ZETA= 3119733
*/
static KRML_MUSTINLINE void outer_3_plus_7a1(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)3119733);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 2
- ZETA= -2884855
*/
static KRML_MUSTINLINE void outer_3_plus_de(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)-2884855);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 2
- ZETA= 3111497
*/
static KRML_MUSTINLINE void outer_3_plus_d90(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)3111497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 2
- ZETA= 2680103
*/
static KRML_MUSTINLINE void outer_3_plus_3b(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)2U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)2U, (int32_t)2680103);
  }
}

static KRML_MUSTINLINE void ntt_at_layer_4(Eurydice_arr_a4 *re)
{
  outer_3_plus_992(re);
  outer_3_plus_6b(re);
  outer_3_plus_a80(re);
  outer_3_plus_95(re);
  outer_3_plus_7a1(re);
  outer_3_plus_de(re);
  outer_3_plus_d90(re);
  outer_3_plus_3b(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 1
- ZETA= 2725464
*/
static KRML_MUSTINLINE void outer_3_plus_993(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)2725464);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 2
- STEP_BY= 1
- ZETA= 1024112
*/
static KRML_MUSTINLINE void outer_3_plus_1c(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)2U; i < (size_t)2U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)1024112);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 1
- ZETA= -1079900
*/
static KRML_MUSTINLINE void outer_3_plus_6b0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-1079900);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 6
- STEP_BY= 1
- ZETA= 3585928
*/
static KRML_MUSTINLINE void outer_3_plus_44(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)6U; i < (size_t)6U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)3585928);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 1
- ZETA= -549488
*/
static KRML_MUSTINLINE void outer_3_plus_a81(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-549488);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 10
- STEP_BY= 1
- ZETA= -1119584
*/
static KRML_MUSTINLINE void outer_3_plus_1f(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)10U; i < (size_t)10U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-1119584);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 1
- ZETA= 2619752
*/
static KRML_MUSTINLINE void outer_3_plus_950(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)2619752);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 14
- STEP_BY= 1
- ZETA= -2108549
*/
static KRML_MUSTINLINE void outer_3_plus_3b0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)14U; i < (size_t)14U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-2108549);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 1
- ZETA= -2118186
*/
static KRML_MUSTINLINE void outer_3_plus_7a2(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-2118186);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 18
- STEP_BY= 1
- ZETA= -3859737
*/
static KRML_MUSTINLINE void outer_3_plus_e4(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)18U; i < (size_t)18U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-3859737);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 1
- ZETA= -1399561
*/
static KRML_MUSTINLINE void outer_3_plus_de0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-1399561);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 22
- STEP_BY= 1
- ZETA= -3277672
*/
static KRML_MUSTINLINE void outer_3_plus_05(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)22U; i < (size_t)22U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-3277672);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 1
- ZETA= 1757237
*/
static KRML_MUSTINLINE void outer_3_plus_d91(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)1757237);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 26
- STEP_BY= 1
- ZETA= -19422
*/
static KRML_MUSTINLINE void outer_3_plus_3a(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)26U; i < (size_t)26U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)-19422);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 1
- ZETA= 4010497
*/
static KRML_MUSTINLINE void outer_3_plus_3b1(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)4010497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.ntt.outer_3_plus
with const generics
- OFFSET= 30
- STEP_BY= 1
- ZETA= 280005
*/
static KRML_MUSTINLINE void outer_3_plus_a0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)30U; i < (size_t)30U + (size_t)1U; i++)
  {
    size_t j = i;
    round(re, j, (size_t)1U, (int32_t)280005);
  }
}

static KRML_MUSTINLINE void ntt_at_layer_3(Eurydice_arr_a4 *re)
{
  outer_3_plus_993(re);
  outer_3_plus_1c(re);
  outer_3_plus_6b0(re);
  outer_3_plus_44(re);
  outer_3_plus_a81(re);
  outer_3_plus_1f(re);
  outer_3_plus_950(re);
  outer_3_plus_3b0(re);
  outer_3_plus_7a2(re);
  outer_3_plus_e4(re);
  outer_3_plus_de0(re);
  outer_3_plus_05(re);
  outer_3_plus_d91(re);
  outer_3_plus_3a(re);
  outer_3_plus_3b1(re);
  outer_3_plus_a0(re);
}

static KRML_MUSTINLINE int32_t montgomery_multiply_fe_by_fer(int32_t fe, int32_t fer)
{
  return montgomery_reduce_element((int64_t)fe * (int64_t)fer);
}

static KRML_MUSTINLINE void
simd_unit_ntt_step(Eurydice_arr_d4 *simd_unit, int32_t zeta, size_t index, size_t step)
{
  int32_t t = montgomery_multiply_fe_by_fer(simd_unit->data[index + step], zeta);
  simd_unit->data[index + step] = simd_unit->data[index] - t;
  simd_unit->data[index] = simd_unit->data[index] + t;
}

static KRML_MUSTINLINE void simd_unit_ntt_at_layer_2(Eurydice_arr_d4 *simd_unit, int32_t zeta)
{
  simd_unit_ntt_step(simd_unit, zeta, (size_t)0U, (size_t)4U);
  simd_unit_ntt_step(simd_unit, zeta, (size_t)1U, (size_t)4U);
  simd_unit_ntt_step(simd_unit, zeta, (size_t)2U, (size_t)4U);
  simd_unit_ntt_step(simd_unit, zeta, (size_t)3U, (size_t)4U);
}

static KRML_MUSTINLINE void round0(Eurydice_arr_a4 *re, size_t index, int32_t zeta)
{
  simd_unit_ntt_at_layer_2(&re->data[index], zeta);
}

static KRML_MUSTINLINE void ntt_at_layer_2(Eurydice_arr_a4 *re)
{
  round0(re, (size_t)0U, (int32_t)2706023);
  round0(re, (size_t)1U, (int32_t)95776);
  round0(re, (size_t)2U, (int32_t)3077325);
  round0(re, (size_t)3U, (int32_t)3530437);
  round0(re, (size_t)4U, (int32_t)-1661693);
  round0(re, (size_t)5U, (int32_t)-3592148);
  round0(re, (size_t)6U, (int32_t)-2537516);
  round0(re, (size_t)7U, (int32_t)3915439);
  round0(re, (size_t)8U, (int32_t)-3861115);
  round0(re, (size_t)9U, (int32_t)-3043716);
  round0(re, (size_t)10U, (int32_t)3574422);
  round0(re, (size_t)11U, (int32_t)-2867647);
  round0(re, (size_t)12U, (int32_t)3539968);
  round0(re, (size_t)13U, (int32_t)-300467);
  round0(re, (size_t)14U, (int32_t)2348700);
  round0(re, (size_t)15U, (int32_t)-539299);
  round0(re, (size_t)16U, (int32_t)-1699267);
  round0(re, (size_t)17U, (int32_t)-1643818);
  round0(re, (size_t)18U, (int32_t)3505694);
  round0(re, (size_t)19U, (int32_t)-3821735);
  round0(re, (size_t)20U, (int32_t)3507263);
  round0(re, (size_t)21U, (int32_t)-2140649);
  round0(re, (size_t)22U, (int32_t)-1600420);
  round0(re, (size_t)23U, (int32_t)3699596);
  round0(re, (size_t)24U, (int32_t)811944);
  round0(re, (size_t)25U, (int32_t)531354);
  round0(re, (size_t)26U, (int32_t)954230);
  round0(re, (size_t)27U, (int32_t)3881043);
  round0(re, (size_t)28U, (int32_t)3900724);
  round0(re, (size_t)29U, (int32_t)-2556880);
  round0(re, (size_t)30U, (int32_t)2071892);
  round0(re, (size_t)31U, (int32_t)-2797779);
}

static KRML_MUSTINLINE void
simd_unit_ntt_at_layer_1(Eurydice_arr_d4 *simd_unit, int32_t zeta1, int32_t zeta2)
{
  simd_unit_ntt_step(simd_unit, zeta1, (size_t)0U, (size_t)2U);
  simd_unit_ntt_step(simd_unit, zeta1, (size_t)1U, (size_t)2U);
  simd_unit_ntt_step(simd_unit, zeta2, (size_t)4U, (size_t)2U);
  simd_unit_ntt_step(simd_unit, zeta2, (size_t)5U, (size_t)2U);
}

static KRML_MUSTINLINE void
round1(Eurydice_arr_a4 *re, size_t index, int32_t zeta_0, int32_t zeta_1)
{
  simd_unit_ntt_at_layer_1(&re->data[index], zeta_0, zeta_1);
}

static KRML_MUSTINLINE void ntt_at_layer_1(Eurydice_arr_a4 *re)
{
  round1(re, (size_t)0U, (int32_t)-3930395, (int32_t)-1528703);
  round1(re, (size_t)1U, (int32_t)-3677745, (int32_t)-3041255);
  round1(re, (size_t)2U, (int32_t)-1452451, (int32_t)3475950);
  round1(re, (size_t)3U, (int32_t)2176455, (int32_t)-1585221);
  round1(re, (size_t)4U, (int32_t)-1257611, (int32_t)1939314);
  round1(re, (size_t)5U, (int32_t)-4083598, (int32_t)-1000202);
  round1(re, (size_t)6U, (int32_t)-3190144, (int32_t)-3157330);
  round1(re, (size_t)7U, (int32_t)-3632928, (int32_t)126922);
  round1(re, (size_t)8U, (int32_t)3412210, (int32_t)-983419);
  round1(re, (size_t)9U, (int32_t)2147896, (int32_t)2715295);
  round1(re, (size_t)10U, (int32_t)-2967645, (int32_t)-3693493);
  round1(re, (size_t)11U, (int32_t)-411027, (int32_t)-2477047);
  round1(re, (size_t)12U, (int32_t)-671102, (int32_t)-1228525);
  round1(re, (size_t)13U, (int32_t)-22981, (int32_t)-1308169);
  round1(re, (size_t)14U, (int32_t)-381987, (int32_t)1349076);
  round1(re, (size_t)15U, (int32_t)1852771, (int32_t)-1430430);
  round1(re, (size_t)16U, (int32_t)-3343383, (int32_t)264944);
  round1(re, (size_t)17U, (int32_t)508951, (int32_t)3097992);
  round1(re, (size_t)18U, (int32_t)44288, (int32_t)-1100098);
  round1(re, (size_t)19U, (int32_t)904516, (int32_t)3958618);
  round1(re, (size_t)20U, (int32_t)-3724342, (int32_t)-8578);
  round1(re, (size_t)21U, (int32_t)1653064, (int32_t)-3249728);
  round1(re, (size_t)22U, (int32_t)2389356, (int32_t)-210977);
  round1(re, (size_t)23U, (int32_t)759969, (int32_t)-1316856);
  round1(re, (size_t)24U, (int32_t)189548, (int32_t)-3553272);
  round1(re, (size_t)25U, (int32_t)3159746, (int32_t)-1851402);
  round1(re, (size_t)26U, (int32_t)-2409325, (int32_t)-177440);
  round1(re, (size_t)27U, (int32_t)1315589, (int32_t)1341330);
  round1(re, (size_t)28U, (int32_t)1285669, (int32_t)-1584928);
  round1(re, (size_t)29U, (int32_t)-812732, (int32_t)-1439742);
  round1(re, (size_t)30U, (int32_t)-3019102, (int32_t)-3881060);
  round1(re, (size_t)31U, (int32_t)-3628969, (int32_t)3839961);
}

static KRML_MUSTINLINE void
simd_unit_ntt_at_layer_0(
  Eurydice_arr_d4 *simd_unit,
  int32_t zeta0,
  int32_t zeta1,
  int32_t zeta2,
  int32_t zeta3
)
{
  simd_unit_ntt_step(simd_unit, zeta0, (size_t)0U, (size_t)1U);
  simd_unit_ntt_step(simd_unit, zeta1, (size_t)2U, (size_t)1U);
  simd_unit_ntt_step(simd_unit, zeta2, (size_t)4U, (size_t)1U);
  simd_unit_ntt_step(simd_unit, zeta3, (size_t)6U, (size_t)1U);
}

static KRML_MUSTINLINE void
round2(
  Eurydice_arr_a4 *re,
  size_t index,
  int32_t zeta_0,
  int32_t zeta_1,
  int32_t zeta_2,
  int32_t zeta_3
)
{
  simd_unit_ntt_at_layer_0(&re->data[index], zeta_0, zeta_1, zeta_2, zeta_3);
}

static KRML_MUSTINLINE void ntt_at_layer_0(Eurydice_arr_a4 *re)
{
  round2(re, (size_t)0U, (int32_t)2091667, (int32_t)3407706, (int32_t)2316500, (int32_t)3817976);
  round2(re,
    (size_t)1U,
    (int32_t)-3342478,
    (int32_t)2244091,
    (int32_t)-2446433,
    (int32_t)-3562462);
  round2(re, (size_t)2U, (int32_t)266997, (int32_t)2434439, (int32_t)-1235728, (int32_t)3513181);
  round2(re,
    (size_t)3U,
    (int32_t)-3520352,
    (int32_t)-3759364,
    (int32_t)-1197226,
    (int32_t)-3193378);
  round2(re, (size_t)4U, (int32_t)900702, (int32_t)1859098, (int32_t)909542, (int32_t)819034);
  round2(re, (size_t)5U, (int32_t)495491, (int32_t)-1613174, (int32_t)-43260, (int32_t)-522500);
  round2(re,
    (size_t)6U,
    (int32_t)-655327,
    (int32_t)-3122442,
    (int32_t)2031748,
    (int32_t)3207046);
  round2(re,
    (size_t)7U,
    (int32_t)-3556995,
    (int32_t)-525098,
    (int32_t)-768622,
    (int32_t)-3595838);
  round2(re, (size_t)8U, (int32_t)342297, (int32_t)286988, (int32_t)-2437823, (int32_t)4108315);
  round2(re, (size_t)9U, (int32_t)3437287, (int32_t)-3342277, (int32_t)1735879, (int32_t)203044);
  round2(re,
    (size_t)10U,
    (int32_t)2842341,
    (int32_t)2691481,
    (int32_t)-2590150,
    (int32_t)1265009);
  round2(re,
    (size_t)11U,
    (int32_t)4055324,
    (int32_t)1247620,
    (int32_t)2486353,
    (int32_t)1595974);
  round2(re,
    (size_t)12U,
    (int32_t)-3767016,
    (int32_t)1250494,
    (int32_t)2635921,
    (int32_t)-3548272);
  round2(re,
    (size_t)13U,
    (int32_t)-2994039,
    (int32_t)1869119,
    (int32_t)1903435,
    (int32_t)-1050970);
  round2(re,
    (size_t)14U,
    (int32_t)-1333058,
    (int32_t)1237275,
    (int32_t)-3318210,
    (int32_t)-1430225);
  round2(re,
    (size_t)15U,
    (int32_t)-451100,
    (int32_t)1312455,
    (int32_t)3306115,
    (int32_t)-1962642);
  round2(re,
    (size_t)16U,
    (int32_t)-1279661,
    (int32_t)1917081,
    (int32_t)-2546312,
    (int32_t)-1374803);
  round2(re, (size_t)17U, (int32_t)1500165, (int32_t)777191, (int32_t)2235880, (int32_t)3406031);
  round2(re,
    (size_t)18U,
    (int32_t)-542412,
    (int32_t)-2831860,
    (int32_t)-1671176,
    (int32_t)-1846953);
  round2(re,
    (size_t)19U,
    (int32_t)-2584293,
    (int32_t)-3724270,
    (int32_t)594136,
    (int32_t)-3776993);
  round2(re,
    (size_t)20U,
    (int32_t)-2013608,
    (int32_t)2432395,
    (int32_t)2454455,
    (int32_t)-164721);
  round2(re,
    (size_t)21U,
    (int32_t)1957272,
    (int32_t)3369112,
    (int32_t)185531,
    (int32_t)-1207385);
  round2(re,
    (size_t)22U,
    (int32_t)-3183426,
    (int32_t)162844,
    (int32_t)1616392,
    (int32_t)3014001);
  round2(re,
    (size_t)23U,
    (int32_t)810149,
    (int32_t)1652634,
    (int32_t)-3694233,
    (int32_t)-1799107);
  round2(re,
    (size_t)24U,
    (int32_t)-3038916,
    (int32_t)3523897,
    (int32_t)3866901,
    (int32_t)269760);
  round2(re, (size_t)25U, (int32_t)2213111, (int32_t)-975884, (int32_t)1717735, (int32_t)472078);
  round2(re,
    (size_t)26U,
    (int32_t)-426683,
    (int32_t)1723600,
    (int32_t)-1803090,
    (int32_t)1910376);
  round2(re,
    (size_t)27U,
    (int32_t)-1667432,
    (int32_t)-1104333,
    (int32_t)-260646,
    (int32_t)-3833893);
  round2(re,
    (size_t)28U,
    (int32_t)-2939036,
    (int32_t)-2235985,
    (int32_t)-420899,
    (int32_t)-2286327);
  round2(re,
    (size_t)29U,
    (int32_t)183443,
    (int32_t)-976891,
    (int32_t)1612842,
    (int32_t)-3545687);
  round2(re,
    (size_t)30U,
    (int32_t)-554416,
    (int32_t)3919660,
    (int32_t)-48306,
    (int32_t)-1362209);
  round2(re,
    (size_t)31U,
    (int32_t)3937738,
    (int32_t)1400424,
    (int32_t)-846154,
    (int32_t)1976782);
}

static KRML_MUSTINLINE void ntt(Eurydice_arr_a4 *re)
{
  ntt_at_layer_7(re);
  ntt_at_layer_6(re);
  ntt_at_layer_5(re);
  ntt_at_layer_4(re);
  ntt_at_layer_3(re);
  ntt_at_layer_2(re);
  ntt_at_layer_1(re);
  ntt_at_layer_0(re);
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void ntt_65(Eurydice_arr_a4 *simd_units)
{
  ntt(simd_units);
}

static KRML_MUSTINLINE void
simd_unit_inv_ntt_step(Eurydice_arr_d4 *simd_unit, int32_t zeta, size_t index, size_t step)
{
  int32_t a_minus_b = simd_unit->data[index + step] - simd_unit->data[index];
  simd_unit->data[index] = simd_unit->data[index] + simd_unit->data[index + step];
  simd_unit->data[index + step] = montgomery_multiply_fe_by_fer(a_minus_b, zeta);
}

static KRML_MUSTINLINE void
simd_unit_invert_ntt_at_layer_0(
  Eurydice_arr_d4 *simd_unit,
  int32_t zeta0,
  int32_t zeta1,
  int32_t zeta2,
  int32_t zeta3
)
{
  simd_unit_inv_ntt_step(simd_unit, zeta0, (size_t)0U, (size_t)1U);
  simd_unit_inv_ntt_step(simd_unit, zeta1, (size_t)2U, (size_t)1U);
  simd_unit_inv_ntt_step(simd_unit, zeta2, (size_t)4U, (size_t)1U);
  simd_unit_inv_ntt_step(simd_unit, zeta3, (size_t)6U, (size_t)1U);
}

static KRML_MUSTINLINE void
round3(
  Eurydice_arr_a4 *re,
  size_t index,
  int32_t zeta0,
  int32_t zeta1,
  int32_t zeta2,
  int32_t zeta3
)
{
  simd_unit_invert_ntt_at_layer_0(&re->data[index], zeta0, zeta1, zeta2, zeta3);
}

static KRML_MUSTINLINE void invert_ntt_at_layer_0(Eurydice_arr_a4 *re)
{
  round3(re, (size_t)0U, (int32_t)1976782, (int32_t)-846154, (int32_t)1400424, (int32_t)3937738);
  round3(re, (size_t)1U, (int32_t)-1362209, (int32_t)-48306, (int32_t)3919660, (int32_t)-554416);
  round3(re, (size_t)2U, (int32_t)-3545687, (int32_t)1612842, (int32_t)-976891, (int32_t)183443);
  round3(re,
    (size_t)3U,
    (int32_t)-2286327,
    (int32_t)-420899,
    (int32_t)-2235985,
    (int32_t)-2939036);
  round3(re,
    (size_t)4U,
    (int32_t)-3833893,
    (int32_t)-260646,
    (int32_t)-1104333,
    (int32_t)-1667432);
  round3(re,
    (size_t)5U,
    (int32_t)1910376,
    (int32_t)-1803090,
    (int32_t)1723600,
    (int32_t)-426683);
  round3(re, (size_t)6U, (int32_t)472078, (int32_t)1717735, (int32_t)-975884, (int32_t)2213111);
  round3(re, (size_t)7U, (int32_t)269760, (int32_t)3866901, (int32_t)3523897, (int32_t)-3038916);
  round3(re,
    (size_t)8U,
    (int32_t)-1799107,
    (int32_t)-3694233,
    (int32_t)1652634,
    (int32_t)810149);
  round3(re, (size_t)9U, (int32_t)3014001, (int32_t)1616392, (int32_t)162844, (int32_t)-3183426);
  round3(re,
    (size_t)10U,
    (int32_t)-1207385,
    (int32_t)185531,
    (int32_t)3369112,
    (int32_t)1957272);
  round3(re,
    (size_t)11U,
    (int32_t)-164721,
    (int32_t)2454455,
    (int32_t)2432395,
    (int32_t)-2013608);
  round3(re,
    (size_t)12U,
    (int32_t)-3776993,
    (int32_t)594136,
    (int32_t)-3724270,
    (int32_t)-2584293);
  round3(re,
    (size_t)13U,
    (int32_t)-1846953,
    (int32_t)-1671176,
    (int32_t)-2831860,
    (int32_t)-542412);
  round3(re, (size_t)14U, (int32_t)3406031, (int32_t)2235880, (int32_t)777191, (int32_t)1500165);
  round3(re,
    (size_t)15U,
    (int32_t)-1374803,
    (int32_t)-2546312,
    (int32_t)1917081,
    (int32_t)-1279661);
  round3(re,
    (size_t)16U,
    (int32_t)-1962642,
    (int32_t)3306115,
    (int32_t)1312455,
    (int32_t)-451100);
  round3(re,
    (size_t)17U,
    (int32_t)-1430225,
    (int32_t)-3318210,
    (int32_t)1237275,
    (int32_t)-1333058);
  round3(re,
    (size_t)18U,
    (int32_t)-1050970,
    (int32_t)1903435,
    (int32_t)1869119,
    (int32_t)-2994039);
  round3(re,
    (size_t)19U,
    (int32_t)-3548272,
    (int32_t)2635921,
    (int32_t)1250494,
    (int32_t)-3767016);
  round3(re,
    (size_t)20U,
    (int32_t)1595974,
    (int32_t)2486353,
    (int32_t)1247620,
    (int32_t)4055324);
  round3(re,
    (size_t)21U,
    (int32_t)1265009,
    (int32_t)-2590150,
    (int32_t)2691481,
    (int32_t)2842341);
  round3(re,
    (size_t)22U,
    (int32_t)203044,
    (int32_t)1735879,
    (int32_t)-3342277,
    (int32_t)3437287);
  round3(re, (size_t)23U, (int32_t)4108315, (int32_t)-2437823, (int32_t)286988, (int32_t)342297);
  round3(re,
    (size_t)24U,
    (int32_t)-3595838,
    (int32_t)-768622,
    (int32_t)-525098,
    (int32_t)-3556995);
  round3(re,
    (size_t)25U,
    (int32_t)3207046,
    (int32_t)2031748,
    (int32_t)-3122442,
    (int32_t)-655327);
  round3(re, (size_t)26U, (int32_t)-522500, (int32_t)-43260, (int32_t)-1613174, (int32_t)495491);
  round3(re, (size_t)27U, (int32_t)819034, (int32_t)909542, (int32_t)1859098, (int32_t)900702);
  round3(re,
    (size_t)28U,
    (int32_t)-3193378,
    (int32_t)-1197226,
    (int32_t)-3759364,
    (int32_t)-3520352);
  round3(re,
    (size_t)29U,
    (int32_t)3513181,
    (int32_t)-1235728,
    (int32_t)2434439,
    (int32_t)266997);
  round3(re,
    (size_t)30U,
    (int32_t)-3562462,
    (int32_t)-2446433,
    (int32_t)2244091,
    (int32_t)-3342478);
  round3(re,
    (size_t)31U,
    (int32_t)3817976,
    (int32_t)2316500,
    (int32_t)3407706,
    (int32_t)2091667);
}

static KRML_MUSTINLINE void
simd_unit_invert_ntt_at_layer_1(Eurydice_arr_d4 *simd_unit, int32_t zeta0, int32_t zeta1)
{
  simd_unit_inv_ntt_step(simd_unit, zeta0, (size_t)0U, (size_t)2U);
  simd_unit_inv_ntt_step(simd_unit, zeta0, (size_t)1U, (size_t)2U);
  simd_unit_inv_ntt_step(simd_unit, zeta1, (size_t)4U, (size_t)2U);
  simd_unit_inv_ntt_step(simd_unit, zeta1, (size_t)5U, (size_t)2U);
}

static KRML_MUSTINLINE void
round4(Eurydice_arr_a4 *re, size_t index, int32_t zeta_00, int32_t zeta_01)
{
  simd_unit_invert_ntt_at_layer_1(&re->data[index], zeta_00, zeta_01);
}

static KRML_MUSTINLINE void invert_ntt_at_layer_1(Eurydice_arr_a4 *re)
{
  round4(re, (size_t)0U, (int32_t)3839961, (int32_t)-3628969);
  round4(re, (size_t)1U, (int32_t)-3881060, (int32_t)-3019102);
  round4(re, (size_t)2U, (int32_t)-1439742, (int32_t)-812732);
  round4(re, (size_t)3U, (int32_t)-1584928, (int32_t)1285669);
  round4(re, (size_t)4U, (int32_t)1341330, (int32_t)1315589);
  round4(re, (size_t)5U, (int32_t)-177440, (int32_t)-2409325);
  round4(re, (size_t)6U, (int32_t)-1851402, (int32_t)3159746);
  round4(re, (size_t)7U, (int32_t)-3553272, (int32_t)189548);
  round4(re, (size_t)8U, (int32_t)-1316856, (int32_t)759969);
  round4(re, (size_t)9U, (int32_t)-210977, (int32_t)2389356);
  round4(re, (size_t)10U, (int32_t)-3249728, (int32_t)1653064);
  round4(re, (size_t)11U, (int32_t)-8578, (int32_t)-3724342);
  round4(re, (size_t)12U, (int32_t)3958618, (int32_t)904516);
  round4(re, (size_t)13U, (int32_t)-1100098, (int32_t)44288);
  round4(re, (size_t)14U, (int32_t)3097992, (int32_t)508951);
  round4(re, (size_t)15U, (int32_t)264944, (int32_t)-3343383);
  round4(re, (size_t)16U, (int32_t)-1430430, (int32_t)1852771);
  round4(re, (size_t)17U, (int32_t)1349076, (int32_t)-381987);
  round4(re, (size_t)18U, (int32_t)-1308169, (int32_t)-22981);
  round4(re, (size_t)19U, (int32_t)-1228525, (int32_t)-671102);
  round4(re, (size_t)20U, (int32_t)-2477047, (int32_t)-411027);
  round4(re, (size_t)21U, (int32_t)-3693493, (int32_t)-2967645);
  round4(re, (size_t)22U, (int32_t)2715295, (int32_t)2147896);
  round4(re, (size_t)23U, (int32_t)-983419, (int32_t)3412210);
  round4(re, (size_t)24U, (int32_t)126922, (int32_t)-3632928);
  round4(re, (size_t)25U, (int32_t)-3157330, (int32_t)-3190144);
  round4(re, (size_t)26U, (int32_t)-1000202, (int32_t)-4083598);
  round4(re, (size_t)27U, (int32_t)1939314, (int32_t)-1257611);
  round4(re, (size_t)28U, (int32_t)-1585221, (int32_t)2176455);
  round4(re, (size_t)29U, (int32_t)3475950, (int32_t)-1452451);
  round4(re, (size_t)30U, (int32_t)-3041255, (int32_t)-3677745);
  round4(re, (size_t)31U, (int32_t)-1528703, (int32_t)-3930395);
}

static KRML_MUSTINLINE void
simd_unit_invert_ntt_at_layer_2(Eurydice_arr_d4 *simd_unit, int32_t zeta)
{
  simd_unit_inv_ntt_step(simd_unit, zeta, (size_t)0U, (size_t)4U);
  simd_unit_inv_ntt_step(simd_unit, zeta, (size_t)1U, (size_t)4U);
  simd_unit_inv_ntt_step(simd_unit, zeta, (size_t)2U, (size_t)4U);
  simd_unit_inv_ntt_step(simd_unit, zeta, (size_t)3U, (size_t)4U);
}

static KRML_MUSTINLINE void round5(Eurydice_arr_a4 *re, size_t index, int32_t zeta1)
{
  simd_unit_invert_ntt_at_layer_2(&re->data[index], zeta1);
}

static KRML_MUSTINLINE void invert_ntt_at_layer_2(Eurydice_arr_a4 *re)
{
  round5(re, (size_t)0U, (int32_t)-2797779);
  round5(re, (size_t)1U, (int32_t)2071892);
  round5(re, (size_t)2U, (int32_t)-2556880);
  round5(re, (size_t)3U, (int32_t)3900724);
  round5(re, (size_t)4U, (int32_t)3881043);
  round5(re, (size_t)5U, (int32_t)954230);
  round5(re, (size_t)6U, (int32_t)531354);
  round5(re, (size_t)7U, (int32_t)811944);
  round5(re, (size_t)8U, (int32_t)3699596);
  round5(re, (size_t)9U, (int32_t)-1600420);
  round5(re, (size_t)10U, (int32_t)-2140649);
  round5(re, (size_t)11U, (int32_t)3507263);
  round5(re, (size_t)12U, (int32_t)-3821735);
  round5(re, (size_t)13U, (int32_t)3505694);
  round5(re, (size_t)14U, (int32_t)-1643818);
  round5(re, (size_t)15U, (int32_t)-1699267);
  round5(re, (size_t)16U, (int32_t)-539299);
  round5(re, (size_t)17U, (int32_t)2348700);
  round5(re, (size_t)18U, (int32_t)-300467);
  round5(re, (size_t)19U, (int32_t)3539968);
  round5(re, (size_t)20U, (int32_t)-2867647);
  round5(re, (size_t)21U, (int32_t)3574422);
  round5(re, (size_t)22U, (int32_t)-3043716);
  round5(re, (size_t)23U, (int32_t)-3861115);
  round5(re, (size_t)24U, (int32_t)3915439);
  round5(re, (size_t)25U, (int32_t)-2537516);
  round5(re, (size_t)26U, (int32_t)-3592148);
  round5(re, (size_t)27U, (int32_t)-1661693);
  round5(re, (size_t)28U, (int32_t)3530437);
  round5(re, (size_t)29U, (int32_t)3077325);
  round5(re, (size_t)30U, (int32_t)95776);
  round5(re, (size_t)31U, (int32_t)2706023);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 1
- ZETA= 280005
*/
static KRML_MUSTINLINE void outer_3_plus_994(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)280005);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 2
- STEP_BY= 1
- ZETA= 4010497
*/
static KRML_MUSTINLINE void outer_3_plus_1c0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)2U; i < (size_t)2U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)4010497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 1
- ZETA= -19422
*/
static KRML_MUSTINLINE void outer_3_plus_6b1(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-19422);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 6
- STEP_BY= 1
- ZETA= 1757237
*/
static KRML_MUSTINLINE void outer_3_plus_440(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)6U; i < (size_t)6U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)1757237);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 1
- ZETA= -3277672
*/
static KRML_MUSTINLINE void outer_3_plus_a82(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-3277672);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 10
- STEP_BY= 1
- ZETA= -1399561
*/
static KRML_MUSTINLINE void outer_3_plus_1f0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)10U; i < (size_t)10U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-1399561);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 1
- ZETA= -3859737
*/
static KRML_MUSTINLINE void outer_3_plus_951(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-3859737);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 14
- STEP_BY= 1
- ZETA= -2118186
*/
static KRML_MUSTINLINE void outer_3_plus_3b2(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)14U; i < (size_t)14U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-2118186);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 1
- ZETA= -2108549
*/
static KRML_MUSTINLINE void outer_3_plus_7a3(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-2108549);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 18
- STEP_BY= 1
- ZETA= 2619752
*/
static KRML_MUSTINLINE void outer_3_plus_e40(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)18U; i < (size_t)18U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)2619752);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 1
- ZETA= -1119584
*/
static KRML_MUSTINLINE void outer_3_plus_de1(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-1119584);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 22
- STEP_BY= 1
- ZETA= -549488
*/
static KRML_MUSTINLINE void outer_3_plus_050(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)22U; i < (size_t)22U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-549488);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 1
- ZETA= 3585928
*/
static KRML_MUSTINLINE void outer_3_plus_d92(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)3585928);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 26
- STEP_BY= 1
- ZETA= -1079900
*/
static KRML_MUSTINLINE void outer_3_plus_3a0(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)26U; i < (size_t)26U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)-1079900);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 1
- ZETA= 1024112
*/
static KRML_MUSTINLINE void outer_3_plus_3b00(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)1024112);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 30
- STEP_BY= 1
- ZETA= 2725464
*/
static KRML_MUSTINLINE void outer_3_plus_a00(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)30U; i < (size_t)30U + (size_t)1U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)1U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)1U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)1U], (int32_t)2725464);
  }
}

static KRML_MUSTINLINE void invert_ntt_at_layer_3(Eurydice_arr_a4 *re)
{
  outer_3_plus_994(re);
  outer_3_plus_1c0(re);
  outer_3_plus_6b1(re);
  outer_3_plus_440(re);
  outer_3_plus_a82(re);
  outer_3_plus_1f0(re);
  outer_3_plus_951(re);
  outer_3_plus_3b2(re);
  outer_3_plus_7a3(re);
  outer_3_plus_e40(re);
  outer_3_plus_de1(re);
  outer_3_plus_050(re);
  outer_3_plus_d92(re);
  outer_3_plus_3a0(re);
  outer_3_plus_3b00(re);
  outer_3_plus_a00(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 2
- ZETA= 2680103
*/
static KRML_MUSTINLINE void outer_3_plus_9900(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)2680103);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 4
- STEP_BY= 2
- ZETA= 3111497
*/
static KRML_MUSTINLINE void outer_3_plus_6b00(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)4U; i < (size_t)4U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)3111497);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 2
- ZETA= -2884855
*/
static KRML_MUSTINLINE void outer_3_plus_a800(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)-2884855);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 12
- STEP_BY= 2
- ZETA= 3119733
*/
static KRML_MUSTINLINE void outer_3_plus_9500(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)12U; i < (size_t)12U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)3119733);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 2
- ZETA= -2091905
*/
static KRML_MUSTINLINE void outer_3_plus_7a00(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)-2091905);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 20
- STEP_BY= 2
- ZETA= -359251
*/
static KRML_MUSTINLINE void outer_3_plus_de00(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)20U; i < (size_t)20U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)-359251);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 2
- ZETA= 2353451
*/
static KRML_MUSTINLINE void outer_3_plus_d900(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)2353451);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 28
- STEP_BY= 2
- ZETA= 1826347
*/
static KRML_MUSTINLINE void outer_3_plus_3b10(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)28U; i < (size_t)28U + (size_t)2U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)2U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)2U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)2U], (int32_t)1826347);
  }
}

static KRML_MUSTINLINE void invert_ntt_at_layer_4(Eurydice_arr_a4 *re)
{
  outer_3_plus_9900(re);
  outer_3_plus_6b00(re);
  outer_3_plus_a800(re);
  outer_3_plus_9500(re);
  outer_3_plus_7a00(re);
  outer_3_plus_de00(re);
  outer_3_plus_d900(re);
  outer_3_plus_3b10(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 4
- ZETA= 466468
*/
static KRML_MUSTINLINE void outer_3_plus_9910(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)4U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)4U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)4U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)4U], (int32_t)466468);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 8
- STEP_BY= 4
- ZETA= -876248
*/
static KRML_MUSTINLINE void outer_3_plus_a810(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)8U; i < (size_t)8U + (size_t)4U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)4U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)4U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)4U], (int32_t)-876248);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 4
- ZETA= -777960
*/
static KRML_MUSTINLINE void outer_3_plus_7a10(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)4U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)4U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)4U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)4U], (int32_t)-777960);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 24
- STEP_BY= 4
- ZETA= 237124
*/
static KRML_MUSTINLINE void outer_3_plus_d910(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)24U; i < (size_t)24U + (size_t)4U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)4U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)4U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)4U], (int32_t)237124);
  }
}

static KRML_MUSTINLINE void invert_ntt_at_layer_5(Eurydice_arr_a4 *re)
{
  outer_3_plus_9910(re);
  outer_3_plus_a810(re);
  outer_3_plus_7a10(re);
  outer_3_plus_d910(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 8
- ZETA= -518909
*/
static KRML_MUSTINLINE void outer_3_plus_9920(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)8U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)8U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)8U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)8U], (int32_t)-518909);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 16
- STEP_BY= 8
- ZETA= -2608894
*/
static KRML_MUSTINLINE void outer_3_plus_7a20(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)16U; i < (size_t)16U + (size_t)8U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)8U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)8U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)8U], (int32_t)-2608894);
  }
}

static KRML_MUSTINLINE void invert_ntt_at_layer_6(Eurydice_arr_a4 *re)
{
  outer_3_plus_9920(re);
  outer_3_plus_7a20(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.invntt.outer_3_plus
with const generics
- OFFSET= 0
- STEP_BY= 16
- ZETA= 25847
*/
static KRML_MUSTINLINE void outer_3_plus_9930(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)0U + (size_t)16U; i++)
  {
    size_t j = i;
    Eurydice_arr_d4 rej = re->data[j];
    Eurydice_arr_d4 rejs = re->data[j + (size_t)16U];
    add(&re->data[j], &rejs);
    subtract(&re->data[j + (size_t)16U], &rej);
    montgomery_multiply_by_constant(&re->data[j + (size_t)16U], (int32_t)25847);
  }
}

static KRML_MUSTINLINE void invert_ntt_at_layer_7(Eurydice_arr_a4 *re)
{
  outer_3_plus_9930(re);
}

static KRML_MUSTINLINE void invert_ntt_montgomery(Eurydice_arr_a4 *re)
{
  invert_ntt_at_layer_0(re);
  invert_ntt_at_layer_1(re);
  invert_ntt_at_layer_2(re);
  invert_ntt_at_layer_3(re);
  invert_ntt_at_layer_4(re);
  invert_ntt_at_layer_5(re);
  invert_ntt_at_layer_6(re);
  invert_ntt_at_layer_7(re);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    montgomery_multiply_by_constant(&re->data[i0], (int32_t)41978);
  }
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void invert_ntt_montgomery_65(Eurydice_arr_a4 *simd_units)
{
  invert_ntt_montgomery(simd_units);
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 0
*/
static KRML_MUSTINLINE void shift_left_then_reduce_c3(Eurydice_arr_d4 *simd_unit)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    simd_unit->data[i0] = reduce_element(simd_unit->data[i0] << (uint32_t)(int32_t)0););
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
static void reduce_65(Eurydice_arr_a4 *simd_units)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    shift_left_then_reduce_c3(&simd_units->data[i0]);
  }
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 4627
*/
const Eurydice_arr_38 *libcrux_ml_dsa_types_as_ref_c5_c2(const Eurydice_arr_38 *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 2592
*/
const Eurydice_arr_51 *libcrux_ml_dsa_types_as_ref_7f_d8(const Eurydice_arr_51 *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 4896
*/
const Eurydice_arr_180 *libcrux_ml_dsa_types_as_ref_9b_32(const Eurydice_arr_180 *self)
{
  return self;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 2592
*/
Eurydice_arr_51 libcrux_ml_dsa_types_new_7f_d8(Eurydice_arr_51 value)
{
  return value;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 4896
*/
Eurydice_arr_180 libcrux_ml_dsa_types_new_9b_32(Eurydice_arr_180 value)
{
  return value;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 2420
*/
const Eurydice_arr_400 *libcrux_ml_dsa_types_as_ref_c5_1a(const Eurydice_arr_400 *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 1312
*/
const Eurydice_arr_40 *libcrux_ml_dsa_types_as_ref_7f_db(const Eurydice_arr_40 *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 2560
*/
const Eurydice_arr_18 *libcrux_ml_dsa_types_as_ref_9b_ff(const Eurydice_arr_18 *self)
{
  return self;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 1312
*/
Eurydice_arr_40 libcrux_ml_dsa_types_new_7f_db(Eurydice_arr_40 value)
{
  return value;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 2560
*/
Eurydice_arr_18 libcrux_ml_dsa_types_new_9b_ff(Eurydice_arr_18 value)
{
  return value;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_c5
with const generics
- SIZE= 3309
*/
const Eurydice_arr_96 *libcrux_ml_dsa_types_as_ref_c5_fa(const Eurydice_arr_96 *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_7f
with const generics
- SIZE= 1952
*/
const Eurydice_arr_4a *libcrux_ml_dsa_types_as_ref_7f_97(const Eurydice_arr_4a *self)
{
  return self;
}

/**
 A reference to the raw byte array.
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.as_ref_9b
with const generics
- SIZE= 4032
*/
const Eurydice_arr_d1 *libcrux_ml_dsa_types_as_ref_9b_09(const Eurydice_arr_d1 *self)
{
  return self;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSAVerificationKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_7f
with const generics
- SIZE= 1952
*/
Eurydice_arr_4a libcrux_ml_dsa_types_new_7f_97(Eurydice_arr_4a value)
{
  return value;
}

/**
 Build
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASigningKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.new_9b
with const generics
- SIZE= 4032
*/
Eurydice_arr_d1 libcrux_ml_dsa_types_new_9b_09(Eurydice_arr_d1 value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 24
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_363(const Eurydice_arr_6d *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 24
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_369(Eurydice_arr_6d *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_46(Eurydice_arr_88 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_362(const Eurydice_arr_88 *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_368(Eurydice_arr_88 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 19
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_361(const Eurydice_arr_91 *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 19
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_367(Eurydice_arr_91 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t

*/
Eurydice_dst_ref_mut_fc
Eurydice_slice_subslice_mut_46(Eurydice_dst_ref_mut_fc s, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_dst_ref_mut_fc){ .ptr = s.ptr + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_46(const Eurydice_arr_88 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_subslice_to_mut_6e(Eurydice_arr_60 *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4627
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_24(const Eurydice_arr_38 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4627U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2592
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_f7(const Eurydice_arr_51 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2592U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4896
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e2(const Eurydice_arr_180 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4896U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4627
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_24(Eurydice_arr_38 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4627U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d1(const Eurydice_arr_fb *a)
{
  Eurydice_dst_ref_shared_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 8
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d1(Eurydice_arr_fb *a)
{
  Eurydice_dst_ref_mut_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1024
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_fd(const Eurydice_arr_9e *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1024U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1024
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_fd(Eurydice_arr_9e *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1024U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 56
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_718(const Eurydice_arr_46 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)56U;
  return lit;
}

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 4627
*/
Eurydice_arr_38 libcrux_ml_dsa_types_zero_c5_c2(void)
{
  return (KRML_CLITERAL(Eurydice_arr_38){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2592
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f7(Eurydice_arr_51 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2592U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4896
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e2(Eurydice_arr_180 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4896U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_717(const Eurydice_arr_f8 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)15U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 7
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_716(const Eurydice_arr_25 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)7U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c31(const Eurydice_arr_f8 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_e7){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 7
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_718(Eurydice_arr_25 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)7U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 56
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_717(Eurydice_arr_46 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)56U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 15
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_716(Eurydice_arr_f8 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)15U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 3309
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ee0(const Eurydice_arr_96 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)3309U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1952
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_5b(const Eurydice_arr_4a *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1952U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4032
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ef(const Eurydice_arr_d1 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4032U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 3309
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ee0(Eurydice_arr_96 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)3309U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 6
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d0(const Eurydice_arr_b5 *a)
{
  Eurydice_dst_ref_shared_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 6
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d0(Eurydice_arr_b5 *a)
{
  Eurydice_dst_ref_mut_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 48
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_95(const Eurydice_arr_5f *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)48U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 30
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_715(const Eurydice_arr_a1 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)30U;
  return lit;
}

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 3309
*/
Eurydice_arr_96 libcrux_ml_dsa_types_zero_c5_fa(void)
{
  return (KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1952
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5b(Eurydice_arr_4a *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1952U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4032
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ef(Eurydice_arr_d1 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4032U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 6
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_714(const Eurydice_arr_a3 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 6
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_715(Eurydice_arr_a3 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)6U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_713(const Eurydice_arr_58 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)11U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 5
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_712(const Eurydice_arr_b0 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)5U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c30(const Eurydice_arr_58 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_e7){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 5
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_714(Eurydice_arr_b0 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)5U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 30
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_713(Eurydice_arr_a1 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)30U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 11
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_712(Eurydice_arr_58 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)11U;
  return lit;
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.zero_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
Eurydice_arr_a4 libcrux_ml_dsa_polynomial_zero_ff_37(void)
{
  Eurydice_arr_a4 lit;
  Eurydice_arr_d4 repeat_expression[32U];
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    repeat_expression[i] = zero_65();
  }
  memcpy(lit.data, repeat_expression, (size_t)32U * sizeof (Eurydice_arr_d4));
  return lit;
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.from_i32_array_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_polynomial_from_i32_array_ff_37(
  Eurydice_dst_ref_shared_fc array,
  Eurydice_arr_a4 *result
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_DSA_SIMD_TRAITS_SIMD_UNITS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    from_coefficient_array_65(Eurydice_slice_subslice_shared_46(array,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 256
*/
Eurydice_dst_ref_shared_fc Eurydice_array_to_slice_shared_200(const Eurydice_arr_c3 *a)
{
  Eurydice_dst_ref_shared_fc lit;
  lit.ptr = a->data;
  lit.meta = (size_t)256U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.use_hint
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_use_hint_37(
  int32_t gamma2,
  Eurydice_dst_ref_shared_22 hint,
  Eurydice_dst_ref_mut_e7 re_vector
)
{
  for (size_t i0 = (size_t)0U; i0 < re_vector.meta; i0++)
  {
    size_t i1 = i0;
    Eurydice_arr_a4 tmp = libcrux_ml_dsa_polynomial_zero_ff_37();
    libcrux_ml_dsa_polynomial_from_i32_array_ff_37(Eurydice_array_to_slice_shared_200(&hint.ptr[i1]),
      &tmp);
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      use_hint_65(gamma2, &re_vector.ptr[i1].data[j], &tmp.data[j]);
    }
    re_vector.ptr[i1] = tmp;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.ntt_multiply_montgomery
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
ntt_multiply_montgomery_37(Eurydice_arr_a4 *lhs, const Eurydice_arr_a4 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    montgomery_multiply_65(&lhs->data[i0], &rhs->data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.add_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void add_ff_37(Eurydice_arr_a4 *self, const Eurydice_arr_a4 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    add_65(&self->data[i0], &rhs->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.arithmetic.shift_left_then_reduce
with const generics
- SHIFT_BY= 13
*/
static KRML_MUSTINLINE void shift_left_then_reduce_84(Eurydice_arr_d4 *simd_unit)
{
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    size_t i0 = i;
    simd_unit->data[i0] = reduce_element(simd_unit->data[i0] << (uint32_t)(int32_t)13););
}

/**
This function found in impl {libcrux_ml_dsa::simd::traits::Operations for libcrux_ml_dsa::simd::portable::vector_type::Coefficients}
*/
/**
A monomorphic instance of libcrux_ml_dsa.simd.portable.shift_left_then_reduce_65
with const generics
- SHIFT_BY= 13
*/
static void shift_left_then_reduce_65_84(Eurydice_arr_d4 *simd_unit)
{
  shift_left_then_reduce_84(simd_unit);
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.shift_left_then_reduce
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- SHIFT_BY= 13
*/
static KRML_MUSTINLINE void shift_left_then_reduce_68(Eurydice_arr_a4 *re)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    shift_left_then_reduce_65_84(&re->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void libcrux_ml_dsa_ntt_ntt_37(Eurydice_arr_a4 *re)
{
  ntt_65(re);
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.subtract_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void subtract_ff_37(Eurydice_arr_a4 *self, const Eurydice_arr_a4 *rhs)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    subtract_65(&self->data[i0], &rhs->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.reduce
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void reduce_37(Eurydice_arr_a4 *re)
{
  reduce_65(re);
}

/**
A monomorphic instance of libcrux_ml_dsa.ntt.invert_ntt_montgomery
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_montgomery_37(Eurydice_arr_a4 *re)
{
  invert_ntt_montgomery_65(re);
}

/**
 Compute InvertNTT(Â ◦ ẑ - ĉ ◦ NTT(t₁2ᵈ))
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_w_approx
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_w_approx_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_e7 matrix,
  Eurydice_dst_ref_shared_e7 signer_response,
  const Eurydice_arr_a4 *verifier_challenge_as_ntt,
  Eurydice_dst_ref_mut_e7 t1
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    Eurydice_arr_a4 inner_result = libcrux_ml_dsa_polynomial_zero_ff_37();
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      Eurydice_arr_a4 product = matrix.ptr[i1 * columns_in_a + j];
      ntt_multiply_montgomery_37(&product, &signer_response.ptr[j]);
      add_ff_37(&inner_result, &product);
    }
    shift_left_then_reduce_68(&t1.ptr[i1]);
    libcrux_ml_dsa_ntt_ntt_37(&t1.ptr[i1]);
    ntt_multiply_montgomery_37(&t1.ptr[i1], verifier_challenge_as_ntt);
    subtract_ff_37(&inner_result, &t1.ptr[i1]);
    t1.ptr[i1] = inner_result;
    reduce_37(&t1.ptr[i1]);
    invert_ntt_montgomery_37(&t1.ptr[i1]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2420
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_180(const Eurydice_arr_400 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2420U;
  return lit;
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_7e(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.gamma1.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_gamma1_deserialize_37(
  size_t gamma1_exponent,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_a4 *result
)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    gamma1_deserialize_65(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (gamma1_exponent + (size_t)1U),
            .end = (i0 + (size_t)1U) * (gamma1_exponent + (size_t)1U)
          }
        )),
      &result->data[i0],
      gamma1_exponent);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
core_result_Result_41
libcrux_ml_dsa_encoding_signature_deserialize_37(
  size_t columns_in_a,
  size_t rows_in_a,
  size_t commitment_hash_size,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  size_t signature_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_mut_borrow_slice_u8 out_commitment_hash,
  Eurydice_dst_ref_mut_e7 out_signer_response,
  Eurydice_dst_ref_mut_22 out_hint
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(serialized,
      commitment_hash_size,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 commitment_hash = uu____0.fst;
  Eurydice_borrow_slice_u8 rest_of_serialized = uu____0.snd;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out_commitment_hash,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = commitment_hash_size })),
    commitment_hash,
    uint8_t);
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(rest_of_serialized,
      gamma1_ring_element_size * columns_in_a,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 signer_response_serialized = uu____1.fst;
  Eurydice_borrow_slice_u8 hint_serialized = uu____1.snd;
  for (size_t i = (size_t)0U; i < columns_in_a; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
      Eurydice_slice_subslice_shared_7e(signer_response_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * gamma1_ring_element_size,
            .end = (i0 + (size_t)1U) * gamma1_ring_element_size
          }
        )),
      &out_signer_response.ptr[i0]);
  }
  size_t previous_true_hints_seen = (size_t)0U;
  bool malformed_hint = false;
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    size_t current_true_hints_seen = (size_t)hint_serialized.ptr[max_ones_in_hint + i1];
    if (current_true_hints_seen < previous_true_hints_seen)
    {
      malformed_hint = true;
      break;
    }
    if (current_true_hints_seen > max_ones_in_hint)
    {
      malformed_hint = true;
      break;
    }
    for (size_t i = previous_true_hints_seen; i < current_true_hints_seen; i++)
    {
      size_t j = i;
      if (j > previous_true_hints_seen)
      {
        if (hint_serialized.ptr[j] <= hint_serialized.ptr[j - (size_t)1U])
        {
          malformed_hint = true;
          break;
        }
      }
      libcrux_ml_dsa_encoding_signature_set_hint(out_hint, i1, (size_t)hint_serialized.ptr[j]);
    }
    if (malformed_hint)
    {
      break;
    }
    previous_true_hints_seen = current_true_hints_seen;
  }
  for (size_t i = previous_true_hints_seen; i < max_ones_in_hint; i++)
  {
    size_t j = i;
    if (hint_serialized.ptr[j] != 0U)
    {
      malformed_hint = true;
      break;
    }
  }
  core_result_Result_41 uu____2;
  if (malformed_hint)
  {
    uu____2 =
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_MalformedHintError
        }
      );
  }
  else
  {
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t1.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static void deserialize_37(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_a4 *result)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    t1_deserialize_65(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T1_DESERIALIZE_WINDOW,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T1_DESERIALIZE_WINDOW
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_verification_key_deserialize_37(
  size_t rows_in_a,
  size_t verification_key_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 t1
)
{
  for (size_t i = (size_t)0U; i < rows_in_a; i++)
  {
    size_t i0 = i;
    deserialize_37(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE
          }
        )),
      &t1.ptr[i0]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1312
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_bb(const Eurydice_arr_40 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1312U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2560
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_59(const Eurydice_arr_18 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2560U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2420
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_180(Eurydice_arr_400 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2420U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_shared_22 Eurydice_array_to_slice_shared_6d(const Eurydice_arr_83 *a)
{
  Eurydice_dst_ref_shared_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.gamma1.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
serialize_37(
  const Eurydice_arr_a4 *re,
  Eurydice_mut_borrow_slice_u8 serialized,
  size_t gamma1_exponent
)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_d4 *simd_unit = &re->data[i0];
    gamma1_serialize_65(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * (gamma1_exponent + (size_t)1U),
            .end = (i0 + (size_t)1U) * (gamma1_exponent + (size_t)1U)
          }
        )),
      gamma1_exponent);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signature.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_signature_serialize_37(
  Eurydice_borrow_slice_u8 commitment_hash,
  Eurydice_dst_ref_shared_e7 signer_response,
  Eurydice_dst_ref_shared_22 hint,
  size_t commitment_hash_size,
  size_t columns_in_a,
  size_t rows_in_a,
  size_t gamma1_exponent,
  size_t gamma1_ring_element_size,
  size_t max_ones_in_hint,
  Eurydice_mut_borrow_slice_u8 signature
)
{
  size_t offset = (size_t)0U;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signature,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + commitment_hash_size
        }
      )),
    commitment_hash,
    uint8_t);
  offset = offset + commitment_hash_size;
  for (size_t i = (size_t)0U; i < columns_in_a; i++)
  {
    size_t i0 = i;
    serialize_37(&signer_response.ptr[i0],
      Eurydice_slice_subslice_mut_7e(signature,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + gamma1_ring_element_size
          }
        )),
      gamma1_exponent);
    offset = offset + gamma1_ring_element_size;
  }
  size_t true_hints_seen = (size_t)0U;
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)256U; i++)
    {
      size_t j = i;
      if (hint.ptr[i1].data[j] == (int32_t)1)
      {
        signature.ptr[offset + true_hints_seen] = (uint8_t)j;
        true_hints_seen++;
      }
    }
    signature.ptr[offset + max_ones_in_hint + i1] = (uint8_t)true_hints_seen;
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$256size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_22 Eurydice_array_to_slice_mut_6d(Eurydice_arr_83 *a)
{
  Eurydice_dst_ref_mut_22 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int32_t, core_ops_range_Range size_t, Eurydice_derefed_slice int32_t
with const generics
- N= 256
*/
Eurydice_dst_ref_mut_fc
Eurydice_array_to_subslice_mut_7f(Eurydice_arr_c3 *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_dst_ref_mut_fc){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.to_i32_array_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static Eurydice_arr_c3 to_i32_array_ff_37(const Eurydice_arr_a4 *self)
{
  Eurydice_arr_c3 result = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    to_coefficient_array_65(&self->data[i0],
      Eurydice_array_to_subslice_mut_7f(&result,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT
          }
        )));
  }
  return result;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.make_hint
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
size_t
libcrux_ml_dsa_arithmetic_make_hint_37(
  Eurydice_dst_ref_shared_e7 low,
  Eurydice_dst_ref_shared_e7 high,
  int32_t gamma2,
  Eurydice_dst_ref_mut_22 hint
)
{
  size_t true_hints = (size_t)0U;
  Eurydice_arr_a4 hint_simd = libcrux_ml_dsa_polynomial_zero_ff_37();
  for (size_t i0 = (size_t)0U; i0 < low.meta; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      size_t
      one_hints_count =
        compute_hint_65(&low.ptr[i1].data[j],
          &high.ptr[i1].data[j],
          gamma2,
          &hint_simd.data[j]);
      true_hints = true_hints + one_hints_count;
    }
    Eurydice_arr_c3 uu____0 = to_i32_array_ff_37(&hint_simd);
    hint.ptr[i1] = uu____0;
  }
  return true_hints;
}

/**
This function found in impl {libcrux_ml_dsa::polynomial::PolynomialRingElement<SIMDUnit>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_dsa.polynomial.infinity_norm_exceeds_ff
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE bool
infinity_norm_exceeds_ff_37(const Eurydice_arr_a4 *self, int32_t bound)
{
  bool result = false;
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    bool uu____0;
    if (result)
    {
      uu____0 = true;
    }
    else
    {
      uu____0 = infinity_norm_exceeds_65(&self->data[i0], bound);
    }
    result = uu____0;
  }
  return result;
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.vector_infinity_norm_exceeds
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(
  Eurydice_dst_ref_shared_e7 vector,
  int32_t bound
)
{
  bool result = false;
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t i0 = i;
    bool uu____0;
    if (result)
    {
      uu____0 = true;
    }
    else
    {
      uu____0 = infinity_norm_exceeds_ff_37(&vector.ptr[i0], bound);
    }
    result = uu____0;
  }
  return result;
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.subtract_vectors
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_subtract_vectors_37(
  size_t dimension,
  Eurydice_dst_ref_mut_e7 lhs,
  Eurydice_dst_ref_shared_e7 rhs
)
{
  for (size_t i = (size_t)0U; i < dimension; i++)
  {
    size_t i0 = i;
    subtract_ff_37(&lhs.ptr[i0], &rhs.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.add_vectors
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_add_vectors_37(
  size_t dimension,
  Eurydice_dst_ref_mut_e7 lhs,
  Eurydice_dst_ref_shared_e7 rhs
)
{
  for (size_t i = (size_t)0U; i < dimension; i++)
  {
    size_t i0 = i;
    add_ff_37(&lhs.ptr[i0], &rhs.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.matrix.vector_times_ring_element
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_vector_times_ring_element_37(
  Eurydice_dst_ref_mut_e7 vector,
  const Eurydice_arr_a4 *ring_element
)
{
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t i0 = i;
    ntt_multiply_montgomery_37(&vector.ptr[i0], ring_element);
    invert_ntt_montgomery_37(&vector.ptr[i0]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_8c(const Eurydice_arr_3d *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)136U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_360(const Eurydice_arr_3d *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ee(const Eurydice_arr_56 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)768U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ee(Eurydice_arr_56 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)768U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.commitment.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
serialize_370(const Eurydice_arr_a4 *re, Eurydice_mut_borrow_slice_u8 serialized)
{
  size_t output_bytes_per_simd_unit = serialized.meta / ((size_t)8U * (size_t)4U);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_d4 *simd_unit = &re->data[i0];
    commitment_serialize_65(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * output_bytes_per_simd_unit,
            .end = (i0 + (size_t)1U) * output_bytes_per_simd_unit
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.commitment.serialize_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_commitment_serialize_vector_37(
  size_t ring_element_size,
  Eurydice_dst_ref_shared_e7 vector,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  size_t offset = (size_t)0U;
  for (size_t i = (size_t)0U; i < vector.meta; i++)
  {
    size_t _cloop_j = i;
    const Eurydice_arr_a4 *ring_element = &vector.ptr[_cloop_j];
    serialize_370(ring_element,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + ring_element_size
          }
        )));
    offset = offset + ring_element_size;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.decompose_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_decompose_vector_37(
  size_t dimension,
  int32_t gamma2,
  Eurydice_dst_ref_shared_e7 t,
  Eurydice_dst_ref_mut_e7 low,
  Eurydice_dst_ref_mut_e7 high
)
{
  for (size_t i0 = (size_t)0U; i0 < dimension; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      decompose_65(gamma2, &t.ptr[i1].data[j], &low.ptr[i1].data[j], &high.ptr[i1].data[j]);
    }
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 16
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_711(const Eurydice_arr_66 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
 Compute InvertNTT(Â ◦ ŷ)
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_matrix_x_mask
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_matrix_x_mask_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_shared_e7 matrix,
  Eurydice_dst_ref_shared_e7 mask,
  Eurydice_dst_ref_mut_e7 result
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      Eurydice_arr_a4 product = mask.ptr[j];
      ntt_multiply_montgomery_37(&product, &matrix.ptr[i1 * columns_in_a + j]);
      add_ff_37(&result.ptr[i1], &product);
    }
    reduce_37(&result.ptr[i1]);
    invert_ntt_montgomery_37(&result.ptr[i1]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 640
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7d0(const Eurydice_arr_c30 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)640U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 640
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_7d(Eurydice_arr_c30 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)640U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 576
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_fa(const Eurydice_arr_5f0 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)576U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 576
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_fa(Eurydice_arr_5f0 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)576U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 11
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_da(const Eurydice_arr_cb *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)11U;
  return lit;
}

/**
 Returns `true` if the option is a [`Some`] value.

 # Examples

 ```
 let x: Option<u32> = Some(2);
 assert_eq!(x.is_some(), true);

 let x: Option<u32> = None;
 assert_eq!(x.is_some(), false);
 ```
*/
/**
This function found in impl {core::option::Option<T>[TraitClause@0]}
*/
/**
A monomorphic instance of core.option.is_some_cd
with types Eurydice_arr uint8_t[[$11size_t]]

*/
bool core_option_is_some_cd_4e(const core_option_Option_b5 *self)
{
  return (ptrdiff_t)self->tag == (ptrdiff_t)1;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_07(const Eurydice_arr_f10 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
deserialize_370(Eurydice_borrow_slice_u8 serialized, Eurydice_arr_a4 *result)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    t0_deserialize_65(Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_t0_deserialize_to_vector_then_ntt_37(
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 ring_elements
)
{
  for
  (size_t
    i = (size_t)0U;
    i < serialized.meta / LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE,
            .end = i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE +
              LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE
          }
        ));
    deserialize_370(bytes, &ring_elements.ptr[i0]);
    libcrux_ml_dsa_ntt_ntt_37(&ring_elements.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.deserialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
deserialize_371(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_arr_a4 *result
)
{
  size_t chunk_size = libcrux_ml_dsa_encoding_error_chunk_size(eta);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    error_deserialize_65(eta,
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * chunk_size,
            .end = (i0 + (size_t)1U) * chunk_size
          }
        )),
      &result->data[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.deserialize_to_vector_then_ntt
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(
  libcrux_ml_dsa_constants_Eta eta,
  size_t ring_element_size,
  Eurydice_borrow_slice_u8 serialized,
  Eurydice_dst_ref_mut_e7 ring_elements
)
{
  for (size_t i = (size_t)0U; i < serialized.meta / ring_element_size; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * ring_element_size,
            .end = i0 * ring_element_size + ring_element_size
          }
        ));
    deserialize_371(eta, bytes, &ring_elements.ptr[i0]);
    libcrux_ml_dsa_ntt_ntt_37(&ring_elements.ptr[i0]);
  }
}

/**
 Init with zero
*/
/**
This function found in impl {libcrux_ml_dsa::types::MLDSASignature<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_dsa.types.zero_c5
with const generics
- SIZE= 2420
*/
Eurydice_arr_400 libcrux_ml_dsa_types_zero_c5_1a(void)
{
  return (KRML_CLITERAL(Eurydice_arr_400){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1312
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_bb(Eurydice_arr_40 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1312U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2560
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_59(Eurydice_arr_18 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2560U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t0.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_t0_serialize_37(
  const Eurydice_arr_a4 *re,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_d4 *simd_unit = &re->data[i0];
    t0_serialize_65(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_DSA_ENCODING_T0_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.error.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_error_serialize_37(
  libcrux_ml_dsa_constants_Eta eta,
  const Eurydice_arr_a4 *re,
  Eurydice_mut_borrow_slice_u8 serialized
)
{
  size_t output_bytes_per_simd_unit = libcrux_ml_dsa_encoding_error_chunk_size(eta);
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_d4 *simd_unit = &re->data[i0];
    error_serialize_65(eta,
      simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * output_bytes_per_simd_unit,
            .end = (i0 + (size_t)1U) * output_bytes_per_simd_unit
          }
        )));
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d8(const Eurydice_arr_060 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)64U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.t1.serialize
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE void
serialize_371(const Eurydice_arr_a4 *re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < (size_t)32U; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_d4 *simd_unit = &re->data[i0];
    t1_serialize_65(simd_unit,
      Eurydice_slice_subslice_mut_7e(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = i0 * LIBCRUX_ML_DSA_ENCODING_T1_SERIALIZE_OUTPUT_BYTES_PER_SIMD_UNIT,
            .end = (i0 + (size_t)1U) *
              LIBCRUX_ML_DSA_ENCODING_T1_SERIALIZE_OUTPUT_BYTES_PER_SIMD_UNIT
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.verification_key.generate_serialized
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_encoding_verification_key_generate_serialized_37(
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_shared_e7 t1,
  Eurydice_mut_borrow_slice_u8 verification_key_serialized
)
{
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(verification_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE
        }
      )),
    seed,
    uint8_t);
  for (size_t i = (size_t)0U; i < t1.meta; i++)
  {
    size_t i0 = i;
    const Eurydice_arr_a4 *ring_element = &t1.ptr[i0];
    size_t
    offset =
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE +
        i0 * LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE;
    serialize_371(ring_element,
      Eurydice_slice_subslice_mut_7e(verification_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T1S_SIZE
          }
        )));
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.arithmetic.power2round_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_arithmetic_power2round_vector_37(
  Eurydice_dst_ref_mut_e7 t,
  Eurydice_dst_ref_mut_e7 t1
)
{
  for (size_t i0 = (size_t)0U; i0 < t.meta; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)32U; i++)
    {
      size_t j = i;
      power2round_65(&t.ptr[i1].data[j], &t1.ptr[i1].data[j]);
    }
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_710(const Eurydice_arr_db *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 4
*/
Eurydice_dst_ref_shared_e7 Eurydice_array_to_slice_shared_71(const Eurydice_arr_a80 *a)
{
  Eurydice_dst_ref_shared_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
 Compute InvertNTT(Â ◦ ŝ₁) + s₂
*/
/**
A monomorphic instance of libcrux_ml_dsa.matrix.compute_as1_plus_s2
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_matrix_compute_as1_plus_s2_37(
  size_t rows_in_a,
  size_t columns_in_a,
  Eurydice_dst_ref_mut_e7 a_as_ntt,
  Eurydice_dst_ref_shared_e7 s1_ntt,
  Eurydice_dst_ref_shared_e7 s1_s2,
  Eurydice_dst_ref_mut_e7 result
)
{
  for (size_t i0 = (size_t)0U; i0 < rows_in_a; i0++)
  {
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < columns_in_a; i++)
    {
      size_t j = i;
      ntt_multiply_montgomery_37(&a_as_ntt.ptr[i1 * columns_in_a + j], &s1_ntt.ptr[j]);
      add_ff_37(&result.ptr[i1], &a_as_ntt.ptr[i1 * columns_in_a + j]);
    }
  }
  for (size_t i = (size_t)0U; i < result.meta; i++)
  {
    size_t i0 = i;
    reduce_37(&result.ptr[i0]);
    invert_ntt_montgomery_37(&result.ptr[i0]);
    add_ff_37(&result.ptr[i0], &s1_s2.ptr[columns_in_a + i0]);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients, core_ops_range_Range size_t, Eurydice_derefed_slice libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_shared_e7
Eurydice_array_to_subslice_shared_c3(const Eurydice_arr_db *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_e7){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_711(Eurydice_arr_a80 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 16
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_710(Eurydice_arr_66 *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr int32_t[[$263size_t]]
with const generics
- N= 4
*/
Eurydice_dst_ref_mut_4c Eurydice_array_to_slice_mut_f6(Eurydice_arr_380 *a)
{
  Eurydice_dst_ref_mut_4c lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 840
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_a8(const Eurydice_arr_12 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)840U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types int32_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice int32_t
with const generics
- N= 263
*/
Eurydice_dst_ref_mut_fc Eurydice_array_to_subslice_from_mut_96(Eurydice_arr_13 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_dst_ref_mut_fc){ .ptr = a->data + r, .meta = (size_t)263U - r });
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_field_modulus
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)24U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)24U,
            .end = _cloop_i * (size_t)24U + (size_t)24U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        rejection_sample_less_than_field_modulus_65(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 34
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_8d(const Eurydice_arr_48 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)34U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- N= 8
*/
Eurydice_dst_ref_mut_e7 Eurydice_array_to_slice_mut_71(Eurydice_arr_db *a)
{
  Eurydice_dst_ref_mut_e7 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 263
*/
Eurydice_dst_ref_shared_fc Eurydice_array_to_slice_shared_20(const Eurydice_arr_13 *a)
{
  Eurydice_dst_ref_shared_fc lit;
  lit.ptr = a->data;
  lit.meta = (size_t)263U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta_equals_4
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE bool
rejection_sample_less_than_eta_equals_4_37(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)4U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)4U,
            .end = _cloop_i * (size_t)4U + (size_t)4U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        rejection_sample_less_than_eta_equals_4_65(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta_equals_2
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
static KRML_MUSTINLINE bool
rejection_sample_less_than_eta_equals_2_37(
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled_coefficients,
  Eurydice_arr_13 *out
)
{
  bool done = false;
  for (size_t i = (size_t)0U; i < randomness.meta / (size_t)4U; i++)
  {
    size_t _cloop_i = i;
    Eurydice_borrow_slice_u8
    random_bytes =
      Eurydice_slice_subslice_shared_7e(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = _cloop_i * (size_t)4U,
            .end = _cloop_i * (size_t)4U + (size_t)4U
          }
        ));
    if (!done)
    {
      size_t
      sampled =
        rejection_sample_less_than_eta_equals_2_65(random_bytes,
          Eurydice_array_to_subslice_from_mut_96(out, sampled_coefficients[0U]));
      sampled_coefficients[0U] = sampled_coefficients[0U] + sampled;
      if (sampled_coefficients[0U] >= LIBCRUX_ML_DSA_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        done = true;
      }
    }
  }
  return done;
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.rejection_sample_less_than_eta
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
bool
libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 randomness,
  size_t *sampled,
  Eurydice_arr_13 *out
)
{
  switch (eta)
  {
    case libcrux_ml_dsa_constants_Eta_Two:
      {
        break;
      }
    case libcrux_ml_dsa_constants_Eta_Four:
      {
        return rejection_sample_less_than_eta_equals_4_37(randomness, sampled, out);
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return rejection_sample_less_than_eta_equals_2_37(randomness, sampled, out);
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 66
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_39(const Eurydice_arr_a2 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)66U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 128
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_18(const Eurydice_arr_d10 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)128U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_18(Eurydice_arr_d10 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)128U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_26(const Eurydice_array_u8x2 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_6e(const Eurydice_arr_60 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)32U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_7b(Eurydice_arr_27 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)168U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 840
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_a8(Eurydice_arr_12 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)840U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d4(Eurydice_arr_3d *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)136U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_95(Eurydice_arr_5f *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)48U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_c0(Eurydice_arr_f1 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)28U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 104
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_9c(const Eurydice_arr_181 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)104U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_366(Eurydice_arr_181 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 144
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d1(const Eurydice_arr_a8 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)144U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_365(Eurydice_arr_a8 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_36(const Eurydice_arr_60 *a, core_ops_range_Range_08 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_6e(Eurydice_arr_60 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)32U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_364(Eurydice_arr_60 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d8(Eurydice_arr_060 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)64U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 72
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7d(const Eurydice_arr_a0 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)72U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_363(Eurydice_arr_a0 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.slice_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_to_shared_c6(Eurydice_borrow_slice_u8 s, size_t r)
{
  return (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = s.ptr, .meta = r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_8c(Eurydice_arr_3d *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)136U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_6e(const Eurydice_array_u8x8 *a, size_t r)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_41(const Eurydice_array_u8x8 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d4(const Eurydice_arr_3d *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)136U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_362(Eurydice_arr_3d *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7b(const Eurydice_arr_27 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)168U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_ab(core_result_Result_8e self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_361(Eurydice_arr_27 *a, core_ops_range_Range_08 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa_core_H
#define libcrux_mldsa_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_08_tags;

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_08_s
{
  core_option_Option_08_tags tag;
  size_t f0;
}
core_option_Option_08;

static inline uint64_t core_num__u64__from_le_bytes(Eurydice_array_u8x8 x0);

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1);

static inline Eurydice_array_u8x8 core_num__u64__to_le_bytes(uint64_t x0);

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_08_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_08;

#define libcrux_ml_dsa_constants_Eta_Two 2
#define libcrux_ml_dsa_constants_Eta_Four 4

typedef uint8_t libcrux_ml_dsa_constants_Eta;

#define LIBCRUX_ML_DSA_SIMD_TRAITS_COEFFICIENTS_IN_SIMD_UNIT ((size_t)8U)

#define LIBCRUX_ML_DSA_CONSTANTS_BITS_IN_LOWER_PART_OF_T ((size_t)13U)

#define libcrux_ml_dsa_types_VerificationError_MalformedHintError 0
#define libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError 1
#define libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError 2
#define libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError 3

typedef uint8_t libcrux_ml_dsa_types_VerificationError;

#define libcrux_ml_dsa_types_SigningError_RejectionSamplingError 0
#define libcrux_ml_dsa_types_SigningError_ContextTooLongError 1

typedef uint8_t libcrux_ml_dsa_types_SigningError;

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_a8_tags;

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $8size_t
*/
typedef struct Eurydice_arr_d4_s { int32_t data[8U]; } Eurydice_arr_d4;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types int32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_fc_s
{
  const int32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_fc;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types int32_t, size_t

*/
typedef struct Eurydice_dst_ref_mut_fc_s
{
  int32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_fc;

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_shared_7e(Eurydice_borrow_slice_u8 s, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_a4_s { Eurydice_arr_d4 data[32U]; } Eurydice_arr_a4;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $2560size_t
*/
typedef struct Eurydice_arr_18_s { uint8_t data[2560U]; } Eurydice_arr_18;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1312size_t
*/
typedef struct Eurydice_arr_40_s { uint8_t data[1312U]; } Eurydice_arr_40;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $4032size_t
*/
typedef struct Eurydice_arr_d1_s { uint8_t data[4032U]; } Eurydice_arr_d1;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1952size_t
*/
typedef struct Eurydice_arr_4a_s { uint8_t data[1952U]; } Eurydice_arr_4a;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $4896size_t
*/
typedef struct Eurydice_arr_180_s { uint8_t data[4896U]; } Eurydice_arr_180;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $2592size_t
*/
typedef struct Eurydice_arr_51_s { uint8_t data[2592U]; } Eurydice_arr_51;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $4627size_t
*/
typedef struct Eurydice_arr_38_s { uint8_t data[4627U]; } Eurydice_arr_38;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $2420size_t
*/
typedef struct Eurydice_arr_400_s { uint8_t data[2420U]; } Eurydice_arr_400;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $3309size_t
*/
typedef struct Eurydice_arr_96_s { uint8_t data[3309U]; } Eurydice_arr_96;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_88_s { uint8_t data[16U]; } Eurydice_arr_88;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_88
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_0e_s { Eurydice_arr_88 data[16U]; } Eurydice_arr_0e;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_60_s { uint8_t data[32U]; } Eurydice_arr_60;

/**
A monomorphic instance of core.result.Result
with types libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87Signature, libcrux_ml_dsa_types_SigningError

*/
typedef struct core_result_Result_8b_s
{
  core_result_Result_a8_tags tag;
  union {
    Eurydice_arr_38 case_Ok;
    libcrux_ml_dsa_types_SigningError case_Err;
  }
  val;
}
core_result_Result_8b;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $64size_t
*/
typedef struct Eurydice_arr_060_s { uint8_t data[64U]; } Eurydice_arr_060;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types libcrux_ml_dsa_polynomial_PolynomialRingElement_e8, size_t

*/
typedef struct Eurydice_dst_ref_mut_e7_s
{
  Eurydice_arr_a4 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_e7;

/**
A monomorphic instance of core.result.Result
with types libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65Signature, libcrux_ml_dsa_types_SigningError

*/
typedef struct core_result_Result_8c_s
{
  core_result_Result_a8_tags tag;
  union {
    Eurydice_arr_96 case_Ok;
    libcrux_ml_dsa_types_SigningError case_Err;
  }
  val;
}
core_result_Result_8c;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $48size_t
*/
typedef struct Eurydice_arr_5f_s { uint8_t data[48U]; } Eurydice_arr_5f;

/**
A monomorphic instance of core.result.Result
with types (), libcrux_ml_dsa_types_VerificationError

*/
typedef struct core_result_Result_41_s
{
  core_result_Result_a8_tags tag;
  libcrux_ml_dsa_types_VerificationError f0;
}
core_result_Result_41;

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_7e(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_08 r);

/**
A monomorphic instance of core.result.Result
with types libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44Signature, libcrux_ml_dsa_types_SigningError

*/
typedef struct core_result_Result_48_s
{
  core_result_Result_a8_tags tag;
  union {
    Eurydice_arr_400 case_Ok;
    libcrux_ml_dsa_types_SigningError case_Err;
  }
  val;
}
core_result_Result_48;

/**
A monomorphic instance of core.result.Result
with types (), libcrux_ml_dsa_types_SigningError

*/
typedef struct core_result_Result_53_s
{
  core_result_Result_a8_tags tag;
  libcrux_ml_dsa_types_SigningError f0;
}
core_result_Result_53;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $136size_t
*/
typedef struct Eurydice_arr_3d_s { uint8_t data[136U]; } Eurydice_arr_3d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $640size_t
*/
typedef struct Eurydice_arr_c30_s { uint8_t data[640U]; } Eurydice_arr_c30;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $576size_t
*/
typedef struct Eurydice_arr_5f0_s { uint8_t data[576U]; } Eurydice_arr_5f0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $840size_t
*/
typedef struct Eurydice_arr_12_s { uint8_t data[840U]; } Eurydice_arr_12;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $168size_t
*/
typedef struct Eurydice_arr_27_s { uint8_t data[168U]; } Eurydice_arr_27;

typedef struct Eurydice_arr_27_x4_s
{
  Eurydice_arr_27 fst;
  Eurydice_arr_27 snd;
  Eurydice_arr_27 thd;
  Eurydice_arr_27 f3;
}
Eurydice_arr_27_x4;

typedef struct Eurydice_arr_3d_x4_s
{
  Eurydice_arr_3d fst;
  Eurydice_arr_3d snd;
  Eurydice_arr_3d thd;
  Eurydice_arr_3d f3;
}
Eurydice_arr_3d_x4;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_95(Eurydice_arr_5f *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $28size_t
*/
typedef struct Eurydice_arr_f1_s { uint8_t data[28U]; } Eurydice_arr_f1;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_c0(Eurydice_arr_f1 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $104size_t
*/
typedef struct Eurydice_arr_181_s { uint8_t data[104U]; } Eurydice_arr_181;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 104
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_9c(const Eurydice_arr_181 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_366(Eurydice_arr_181 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $144size_t
*/
typedef struct Eurydice_arr_a8_s { uint8_t data[144U]; } Eurydice_arr_a8;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 144
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d1(const Eurydice_arr_a8 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_365(Eurydice_arr_a8 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_6e(Eurydice_arr_60 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_6e(const Eurydice_array_u8x8 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_41(const Eurydice_array_u8x8 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d4(const Eurydice_arr_3d *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_362(Eurydice_arr_3d *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_a5_s { uint64_t data[5U]; } Eurydice_arr_a5;

typedef struct size_t_x2_s
{
  size_t fst;
  size_t snd;
}
size_t_x2;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_borrow_slice_u8
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_06_s { Eurydice_borrow_slice_u8 data[1U]; } Eurydice_arr_06;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_7b(const Eurydice_arr_27 *a);

/**
A monomorphic instance of core.result.Result
with types Eurydice_array_u8x8, core_array_TryFromSliceError

*/
typedef struct core_result_Result_8e_s
{
  core_result_Result_a8_tags tag;
  union {
    Eurydice_array_u8x8 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_8e;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_ab(core_result_Result_8e self);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_361(Eurydice_arr_27 *a, core_ops_range_Range_08 r);

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_a7_s { uint64_t data[24U]; } Eurydice_arr_a7;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_3d
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_3e_s { Eurydice_arr_3d data[1U]; } Eurydice_arr_3e;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_26_s { uint64_t data[25U]; } Eurydice_arr_26;

typedef struct libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair_s
{
  Eurydice_arr_180 signing_key;
  Eurydice_arr_51 verification_key;
}
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_87_MLDSA87KeyPair;

typedef struct libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair_s
{
  Eurydice_arr_d1 signing_key;
  Eurydice_arr_4a verification_key;
}
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_65_MLDSA65KeyPair;

typedef struct libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair_s
{
  Eurydice_arr_18 signing_key;
  Eurydice_arr_40 verification_key;
}
libcrux_ml_dsa_ml_dsa_generic_ml_dsa_44_MLDSA44KeyPair;

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa_core_H_DEFINED
#endif /* libcrux_mldsa_core_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mldsa_portable.h"

#include "libcrux_sha3_internal.h"
#include "libcrux_sha3.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_sha3_internal.h"
#include "internal/libcrux_mldsa_core.h"

KRML_MUSTINLINE libcrux_ml_dsa_hash_functions_portable_Shake128X4
libcrux_ml_dsa_hash_functions_portable_init_absorb(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  Eurydice_arr_26 state0 = libcrux_sha3_portable_incremental_shake128_init();
  libcrux_sha3_portable_incremental_shake128_absorb_final(&state0, input0);
  Eurydice_arr_26 state1 = libcrux_sha3_portable_incremental_shake128_init();
  libcrux_sha3_portable_incremental_shake128_absorb_final(&state1, input1);
  Eurydice_arr_26 state2 = libcrux_sha3_portable_incremental_shake128_init();
  libcrux_sha3_portable_incremental_shake128_absorb_final(&state2, input2);
  Eurydice_arr_26 state3 = libcrux_sha3_portable_incremental_shake128_init();
  libcrux_sha3_portable_incremental_shake128_absorb_final(&state3, input3);
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_hash_functions_portable_Shake128X4){
        .state0 = state0,
        .state1 = state1,
        .state2 = state2,
        .state3 = state3
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_26
libcrux_ml_dsa_hash_functions_portable_init_absorb_final_shake256(
  Eurydice_borrow_slice_u8 input
)
{
  Eurydice_arr_26 state = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state, input);
  return state;
}

KRML_MUSTINLINE libcrux_ml_dsa_hash_functions_portable_Shake256X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_x4(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  Eurydice_arr_26 state0 = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state0, input0);
  Eurydice_arr_26 state1 = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state1, input1);
  Eurydice_arr_26 state2 = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state2, input2);
  Eurydice_arr_26 state3 = libcrux_sha3_portable_incremental_shake256_init();
  libcrux_sha3_portable_incremental_shake256_absorb_final(&state3, input3);
  return
    (
      KRML_CLITERAL(libcrux_ml_dsa_hash_functions_portable_Shake256X4){
        .state0 = state0,
        .state1 = state1,
        .state2 = state2,
        .state3 = state3
      }
    );
}

KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake128(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_portable_shake128(out, input);
}

KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_shake256(Eurydice_arr_26 *state)
{
  Eurydice_arr_3d out = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(state,
    Eurydice_array_to_slice_mut_d4(&out));
  return out;
}

KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *state
)
{
  Eurydice_arr_3d out0 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(&state->state0,
    Eurydice_array_to_slice_mut_d4(&out0));
  Eurydice_arr_3d out1 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(&state->state1,
    Eurydice_array_to_slice_mut_d4(&out1));
  Eurydice_arr_3d out2 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(&state->state2,
    Eurydice_array_to_slice_mut_d4(&out2));
  Eurydice_arr_3d out3 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_first_block(&state->state3,
    Eurydice_array_to_slice_mut_d4(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_3d_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *state,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
)
{
  libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(&state->state0,
    Eurydice_array_to_slice_mut_a8(out0));
  libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(&state->state1,
    Eurydice_array_to_slice_mut_a8(out1));
  libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(&state->state2,
    Eurydice_array_to_slice_mut_a8(out2));
  libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(&state->state3,
    Eurydice_array_to_slice_mut_a8(out3));
}

KRML_MUSTINLINE Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *state
)
{
  Eurydice_arr_27 out0 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&state->state0,
    Eurydice_array_to_slice_mut_7b(&out0));
  Eurydice_arr_27 out1 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&state->state1,
    Eurydice_array_to_slice_mut_7b(&out1));
  Eurydice_arr_27 out2 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&state->state2,
    Eurydice_array_to_slice_mut_7b(&out2));
  Eurydice_arr_27 out3 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&state->state3,
    Eurydice_array_to_slice_mut_7b(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_27_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_shake256(Eurydice_arr_26 *state)
{
  Eurydice_arr_3d out = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(state,
    Eurydice_array_to_slice_mut_d4(&out));
  return out;
}

KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *state
)
{
  Eurydice_arr_3d out0 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(&state->state0,
    Eurydice_array_to_slice_mut_d4(&out0));
  Eurydice_arr_3d out1 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(&state->state1,
    Eurydice_array_to_slice_mut_d4(&out1));
  Eurydice_arr_3d out2 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(&state->state2,
    Eurydice_array_to_slice_mut_d4(&out2));
  Eurydice_arr_3d out3 = { .data = { 0U } };
  libcrux_sha3_portable_incremental_shake256_squeeze_next_block(&state->state3,
    Eurydice_array_to_slice_mut_d4(&out3));
  return
    (KRML_CLITERAL(Eurydice_arr_3d_x4){ .fst = out0, .snd = out1, .thd = out2, .f3 = out3 });
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::Xof for libcrux_ml_dsa::hash_functions::portable::Shake128}
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake128_7b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_ml_dsa_hash_functions_portable_shake128(input, out);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
KRML_MUSTINLINE libcrux_ml_dsa_hash_functions_portable_Shake128X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_11(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  return libcrux_ml_dsa_hash_functions_portable_init_absorb(input0, input1, input2, input3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks_11(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *self,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
)
{
  libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks(self, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
KRML_MUSTINLINE Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *self
)
{
  return libcrux_ml_dsa_hash_functions_portable_squeeze_next_block(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
KRML_MUSTINLINE Eurydice_arr_26
libcrux_ml_dsa_hash_functions_portable_init_absorb_final_61(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_dsa_hash_functions_portable_init_absorb_final_shake256(input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_61(Eurydice_arr_26 *self)
{
  return libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_shake256(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
KRML_MUSTINLINE Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_61(Eurydice_arr_26 *self)
{
  return libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_shake256(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_absorb_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
)
{
  libcrux_sha3_portable_incremental_absorb_42(self, input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_absorb_final_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
)
{
  libcrux_sha3_portable_incremental_absorb_final_42(self, input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
libcrux_ml_dsa_hash_functions_portable_init_26(void)
{
  return libcrux_sha3_portable_incremental_new_42();
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_squeeze_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_portable_incremental_squeeze_42(self, out);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
KRML_MUSTINLINE libcrux_ml_dsa_hash_functions_portable_Shake256X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_x4_9b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
)
{
  return libcrux_ml_dsa_hash_functions_portable_init_absorb_x4(input0, input1, input2, input3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4_9b(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *self
)
{
  return libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4(self);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
KRML_MUSTINLINE Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *self
)
{
  return libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4(self);
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_four_error_ring_elements
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
sample_four_error_ring_elements_29(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 seed,
  uint16_t start_index,
  Eurydice_dst_ref_mut_e7 re
)
{
  Eurydice_arr_a2 seed0 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, start_index);
  Eurydice_arr_a2
  seed1 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 1U);
  Eurydice_arr_a2
  seed2 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 2U);
  Eurydice_arr_a2
  seed3 = libcrux_ml_dsa_sample_add_error_domain_separator(seed, (uint32_t)start_index + 3U);
  libcrux_ml_dsa_hash_functions_portable_Shake256X4
  state =
    libcrux_ml_dsa_hash_functions_portable_init_absorb_x4_9b(Eurydice_array_to_slice_shared_39(&seed0),
      Eurydice_array_to_slice_shared_39(&seed1),
      Eurydice_array_to_slice_shared_39(&seed2),
      Eurydice_array_to_slice_shared_39(&seed3));
  Eurydice_arr_3d_x4
  randomnesses0 = libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4_9b(&state);
  Eurydice_arr_380
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  size_t sampled0 = (size_t)0U;
  size_t sampled1 = (size_t)0U;
  size_t sampled2 = (size_t)0U;
  size_t sampled3 = (size_t)0U;
  libcrux_ml_dsa_constants_Eta uu____0 = eta;
  bool
  done0 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____0,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.fst),
      &sampled0,
      out.data);
  libcrux_ml_dsa_constants_Eta uu____1 = eta;
  bool
  done1 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____1,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.snd),
      &sampled1,
      &out.data[1U]);
  libcrux_ml_dsa_constants_Eta uu____2 = eta;
  bool
  done2 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____2,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.thd),
      &sampled2,
      &out.data[2U]);
  libcrux_ml_dsa_constants_Eta uu____3 = eta;
  bool
  done3 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____3,
      Eurydice_array_to_slice_shared_d4(&randomnesses0.f3),
      &sampled3,
      &out.data[3U]);
  while (true)
  {
    if (done0)
    {
      if (done1)
      {
        if (done2)
        {
          if (done3)
          {
            break;
          }
          else
          {
            Eurydice_arr_3d_x4
            randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(&state);
            if (!done0)
            {
              libcrux_ml_dsa_constants_Eta uu____4 = eta;
              done0 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____4,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
                  &sampled0,
                  out.data);
            }
            if (!done1)
            {
              libcrux_ml_dsa_constants_Eta uu____5 = eta;
              done1 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____5,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
                  &sampled1,
                  &out.data[1U]);
            }
            if (!done2)
            {
              libcrux_ml_dsa_constants_Eta uu____6 = eta;
              done2 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____6,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
                  &sampled2,
                  &out.data[2U]);
            }
            if (!done3)
            {
              libcrux_ml_dsa_constants_Eta uu____7 = eta;
              done3 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____7,
                  Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
                  &sampled3,
                  &out.data[3U]);
            }
          }
        }
        else
        {
          Eurydice_arr_3d_x4
          randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(&state);
          if (!done0)
          {
            libcrux_ml_dsa_constants_Eta uu____8 = eta;
            done0 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____8,
                Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
                &sampled0,
                out.data);
          }
          if (!done1)
          {
            libcrux_ml_dsa_constants_Eta uu____9 = eta;
            done1 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____9,
                Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
                &sampled1,
                &out.data[1U]);
          }
          if (!done2)
          {
            libcrux_ml_dsa_constants_Eta uu____10 = eta;
            done2 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____10,
                Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
                &sampled2,
                &out.data[2U]);
          }
          if (!done3)
          {
            libcrux_ml_dsa_constants_Eta uu____11 = eta;
            done3 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____11,
                Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
                &sampled3,
                &out.data[3U]);
          }
        }
      }
      else
      {
        Eurydice_arr_3d_x4
        randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(&state);
        if (!done0)
        {
          libcrux_ml_dsa_constants_Eta uu____12 = eta;
          done0 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____12,
              Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
              &sampled0,
              out.data);
        }
        if (!done1)
        {
          libcrux_ml_dsa_constants_Eta uu____13 = eta;
          done1 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____13,
              Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
              &sampled1,
              &out.data[1U]);
        }
        if (!done2)
        {
          libcrux_ml_dsa_constants_Eta uu____14 = eta;
          done2 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____14,
              Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
              &sampled2,
              &out.data[2U]);
        }
        if (!done3)
        {
          libcrux_ml_dsa_constants_Eta uu____15 = eta;
          done3 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____15,
              Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
              &sampled3,
              &out.data[3U]);
        }
      }
    }
    else
    {
      Eurydice_arr_3d_x4
      randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(&state);
      if (!done0)
      {
        libcrux_ml_dsa_constants_Eta uu____16 = eta;
        done0 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____16,
            Eurydice_array_to_slice_shared_d4(&randomnesses.fst),
            &sampled0,
            out.data);
      }
      if (!done1)
      {
        libcrux_ml_dsa_constants_Eta uu____17 = eta;
        done1 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____17,
            Eurydice_array_to_slice_shared_d4(&randomnesses.snd),
            &sampled1,
            &out.data[1U]);
      }
      if (!done2)
      {
        libcrux_ml_dsa_constants_Eta uu____18 = eta;
        done2 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____18,
            Eurydice_array_to_slice_shared_d4(&randomnesses.thd),
            &sampled2,
            &out.data[2U]);
      }
      if (!done3)
      {
        libcrux_ml_dsa_constants_Eta uu____19 = eta;
        done3 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_eta_37(uu____19,
            Eurydice_array_to_slice_shared_d4(&randomnesses.f3),
            &sampled3,
            &out.data[3U]);
      }
    }
  }
  size_t max0 = (size_t)start_index + (size_t)4U;
  size_t max;
  if (re.meta < max0)
  {
    max = re.meta;
  }
  else
  {
    max = max0;
  }
  for (size_t i = (size_t)start_index; i < max; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_polynomial_from_i32_array_ff_37(Eurydice_array_to_slice_shared_20(&out.data[i0 %
          (size_t)4U]),
      &re.ptr[i0]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.samplex4.sample_s1_and_s2
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
sample_s1_and_s2_29(
  libcrux_ml_dsa_constants_Eta eta,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_e7 s1_s2
)
{
  size_t len = s1_s2.meta;
  for (size_t i = (size_t)0U; i < len / (size_t)4U; i++)
  {
    size_t i0 = i;
    sample_four_error_ring_elements_29(eta, seed, 4U * (uint32_t)(uint16_t)i0, s1_s2);
  }
  size_t remainder = len % (size_t)4U;
  if (remainder != (size_t)0U)
  {
    sample_four_error_ring_elements_29(eta, seed, (uint16_t)(len - remainder), s1_s2);
  }
}

/**
 Sample and write out up to four ring elements.

 If i <= `elements_requested`, a field element with domain separated
 seed according to the provided index is generated in
 `tmp_stack[i]`. After successful rejection sampling in
 `tmp_stack[i]`, the ring element is written to `matrix` at the
 provided index in `indices[i]`.
 `rand_stack` is a working buffer that holds initial Shake output.
*/
/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_up_to_four_ring_elements_flat
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake128X4
with const generics

*/
static KRML_MUSTINLINE void
sample_up_to_four_ring_elements_flat_63(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_e7 matrix,
  Eurydice_arr_12 *rand_stack0,
  Eurydice_arr_12 *rand_stack1,
  Eurydice_arr_12 *rand_stack2,
  Eurydice_arr_12 *rand_stack3,
  Eurydice_dst_ref_mut_4c tmp_stack,
  size_t start_index,
  size_t elements_requested
)
{
  Eurydice_arr_48
  seed0 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index, columns));
  Eurydice_arr_48
  seed1 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)1U,
        columns));
  Eurydice_arr_48
  seed2 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)2U,
        columns));
  Eurydice_arr_48
  seed3 =
    libcrux_ml_dsa_sample_add_domain_separator(seed,
      libcrux_ml_dsa_sample_sample_up_to_four_ring_elements_flat_xy(start_index + (size_t)3U,
        columns));
  libcrux_ml_dsa_hash_functions_portable_Shake128X4
  state =
    libcrux_ml_dsa_hash_functions_portable_init_absorb_11(Eurydice_array_to_slice_shared_8d(&seed0),
      Eurydice_array_to_slice_shared_8d(&seed1),
      Eurydice_array_to_slice_shared_8d(&seed2),
      Eurydice_array_to_slice_shared_8d(&seed3));
  libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks_11(&state,
    rand_stack0,
    rand_stack1,
    rand_stack2,
    rand_stack3);
  size_t sampled0 = (size_t)0U;
  size_t sampled1 = (size_t)0U;
  size_t sampled2 = (size_t)0U;
  size_t sampled3 = (size_t)0U;
  bool
  done0 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_a8(rand_stack0),
      &sampled0,
      tmp_stack.ptr);
  bool
  done1 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_a8(rand_stack1),
      &sampled1,
      &tmp_stack.ptr[1U]);
  bool
  done2 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_a8(rand_stack2),
      &sampled2,
      &tmp_stack.ptr[2U]);
  bool
  done3 =
    libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_a8(rand_stack3),
      &sampled3,
      &tmp_stack.ptr[3U]);
  while (true)
  {
    if (done0)
    {
      if (done1)
      {
        if (done2)
        {
          if (done3)
          {
            break;
          }
          else
          {
            Eurydice_arr_27_x4
            randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(&state);
            if (!done0)
            {
              done0 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
                  &sampled0,
                  tmp_stack.ptr);
            }
            if (!done1)
            {
              done1 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
                  &sampled1,
                  &tmp_stack.ptr[1U]);
            }
            if (!done2)
            {
              done2 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
                  &sampled2,
                  &tmp_stack.ptr[2U]);
            }
            if (!done3)
            {
              done3 =
                libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
                  &sampled3,
                  &tmp_stack.ptr[3U]);
            }
          }
        }
        else
        {
          Eurydice_arr_27_x4
          randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(&state);
          if (!done0)
          {
            done0 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
                &sampled0,
                tmp_stack.ptr);
          }
          if (!done1)
          {
            done1 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
                &sampled1,
                &tmp_stack.ptr[1U]);
          }
          if (!done2)
          {
            done2 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
                &sampled2,
                &tmp_stack.ptr[2U]);
          }
          if (!done3)
          {
            done3 =
              libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
                &sampled3,
                &tmp_stack.ptr[3U]);
          }
        }
      }
      else
      {
        Eurydice_arr_27_x4
        randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(&state);
        if (!done0)
        {
          done0 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
              &sampled0,
              tmp_stack.ptr);
        }
        if (!done1)
        {
          done1 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
              &sampled1,
              &tmp_stack.ptr[1U]);
        }
        if (!done2)
        {
          done2 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
              &sampled2,
              &tmp_stack.ptr[2U]);
        }
        if (!done3)
        {
          done3 =
            libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
              &sampled3,
              &tmp_stack.ptr[3U]);
        }
      }
    }
    else
    {
      Eurydice_arr_27_x4
      randomnesses = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(&state);
      if (!done0)
      {
        done0 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.fst),
            &sampled0,
            tmp_stack.ptr);
      }
      if (!done1)
      {
        done1 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.snd),
            &sampled1,
            &tmp_stack.ptr[1U]);
      }
      if (!done2)
      {
        done2 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.thd),
            &sampled2,
            &tmp_stack.ptr[2U]);
      }
      if (!done3)
      {
        done3 =
          libcrux_ml_dsa_sample_rejection_sample_less_than_field_modulus_37(Eurydice_array_to_slice_shared_7b(&randomnesses.f3),
            &sampled3,
            &tmp_stack.ptr[3U]);
      }
    }
  }
  for (size_t i = (size_t)0U; i < elements_requested; i++)
  {
    size_t k = i;
    libcrux_ml_dsa_polynomial_from_i32_array_ff_37(Eurydice_array_to_slice_shared_20(&tmp_stack.ptr[k]),
      &matrix.ptr[start_index + k]);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.samplex4.matrix_flat
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake128X4
with const generics

*/
static KRML_MUSTINLINE void
matrix_flat_63(size_t columns, Eurydice_borrow_slice_u8 seed, Eurydice_dst_ref_mut_e7 matrix)
{
  Eurydice_arr_12 rand_stack0 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack1 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack2 = { .data = { 0U } };
  Eurydice_arr_12 rand_stack3 = { .data = { 0U } };
  Eurydice_arr_380
  tmp_stack =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  for (size_t i = (size_t)0U; i < matrix.meta / (size_t)4U + (size_t)1U; i++)
  {
    size_t start_index = i;
    size_t start_index0 = start_index * (size_t)4U;
    if (start_index0 >= matrix.meta)
    {
      break;
    }
    size_t elements_requested;
    if (start_index0 + (size_t)4U <= matrix.meta)
    {
      elements_requested = (size_t)4U;
    }
    else
    {
      elements_requested = matrix.meta - start_index0;
    }
    sample_up_to_four_ring_elements_flat_63(columns,
      seed,
      matrix,
      &rand_stack0,
      &rand_stack1,
      &rand_stack2,
      &rand_stack3,
      Eurydice_array_to_slice_mut_f6(&tmp_stack),
      start_index0,
      elements_requested);
  }
}

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::portable::PortableSampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.portable.matrix_flat_a8
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_e7 matrix
)
{
  matrix_flat_63(columns, seed, matrix);
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 64
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_d8(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 64
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_61_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
)
{
  libcrux_ml_dsa_hash_functions_portable_shake256_24(input, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.encoding.signing_key.generate_serialized
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256
with const generics

*/
static KRML_MUSTINLINE void
generate_serialized_2e(
  libcrux_ml_dsa_constants_Eta eta,
  size_t error_ring_element_size,
  Eurydice_borrow_slice_u8 seed_matrix,
  Eurydice_borrow_slice_u8 seed_signing,
  Eurydice_borrow_slice_u8 verification_key,
  Eurydice_dst_ref_shared_e7 s1_2,
  Eurydice_dst_ref_shared_e7 t0,
  Eurydice_mut_borrow_slice_u8 signing_key_serialized
)
{
  size_t offset = (size_t)0U;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE
        }
      )),
    seed_matrix,
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE;
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE
        }
      )),
    seed_signing,
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE;
  Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
  libcrux_ml_dsa_hash_functions_portable_shake256_61_24(verification_key,
    &verification_key_hash);
  Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(signing_key_serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = offset,
          .end = offset + LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH
        }
      )),
    Eurydice_array_to_slice_shared_d8(&verification_key_hash),
    uint8_t);
  offset = offset + LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH;
  for (size_t i = (size_t)0U; i < s1_2.meta; i++)
  {
    size_t i0 = i;
    libcrux_ml_dsa_encoding_error_serialize_37(eta,
      &s1_2.ptr[i0],
      Eurydice_slice_subslice_mut_7e(signing_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + error_ring_element_size
          }
        )));
    offset = offset + error_ring_element_size;
  }
  for (size_t i = (size_t)0U; i < t0.meta; i++)
  {
    size_t _cloop_j = i;
    const Eurydice_arr_a4 *ring_element = &t0.ptr[_cloop_j];
    libcrux_ml_dsa_encoding_t0_serialize_37(ring_element,
      Eurydice_slice_subslice_mut_7e(signing_key_serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = offset,
            .end = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE
          }
        )));
    offset = offset + LIBCRUX_ML_DSA_CONSTANTS_RING_ELEMENT_OF_T0S_SIZE;
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.generate_key_pair
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
generate_key_pair_5a(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  Eurydice_arr_db s1_s2;
  Eurydice_arr_a4 repeat_expression0[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)8U * sizeof (Eurydice_arr_a4));
  sample_s1_and_s2_29(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    seed_for_error_vectors,
    Eurydice_array_to_slice_mut_71(&s1_s2));
  Eurydice_arr_a80 t0;
  Eurydice_arr_a4 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_66 a_as_ntt;
  Eurydice_arr_a4 repeat_expression2[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)16U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_710(&a_as_ntt));
  Eurydice_arr_a80 s1_ntt;
  Eurydice_arr_a4 repeat_expression3[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)4U * sizeof (Eurydice_arr_a4));
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_711(&s1_ntt),
    Eurydice_array_to_subslice_shared_c3(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_a4);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_ml_dsa_ntt_ntt_37(&s1_ntt.data[i0]););
  libcrux_ml_dsa_matrix_compute_as1_plus_s2_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    Eurydice_array_to_slice_mut_710(&a_as_ntt),
    Eurydice_array_to_slice_shared_71(&s1_ntt),
    Eurydice_array_to_slice_shared_710(&s1_s2),
    Eurydice_array_to_slice_mut_711(&t0));
  Eurydice_arr_a80 t1;
  Eurydice_arr_a4 repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_arithmetic_power2round_vector_37(Eurydice_array_to_slice_mut_711(&t0),
    Eurydice_array_to_slice_mut_711(&t1));
  libcrux_ml_dsa_encoding_verification_key_generate_serialized_37(seed_for_a,
    Eurydice_array_to_slice_shared_71(&t1),
    verification_key);
  generate_serialized_2e(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    Eurydice_array_to_slice_shared_710(&s1_s2),
    Eurydice_array_to_slice_shared_71(&t0),
    signing_key);
}

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_18 *signing_key,
  Eurydice_arr_40 *verification_key
)
{
  generate_key_pair_5a(randomness,
    Eurydice_array_to_slice_mut_59(signing_key),
    Eurydice_array_to_slice_mut_bb(verification_key));
}

/**
 This corresponds to line 6 in algorithm 7 in FIPS 204 (line 7 in algorithm
 8, resp.).

 If `domain_separation_context` is supplied, applies domain
 separation and length encoding to the context string,
 before appending the message (in the regular variant) or the
 pre-hash OID as well as the pre-hashed message digest. Otherwise,
 it is assumed that `message` already contains domain separation
 information.

 In FIPS 204 M' is the concatenation of the domain separated context, any
 potential pre-hash OID and the message (or the message pre-hash). We do not
 explicitely construct the concatenation in memory since it is of statically unknown
 length, but feed its components directly into the incremental XOF.

 Refer to line 10 of Algorithm 2 (and line 5 of Algorithm 3, resp.) in [FIPS
 204](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.204.pdf#section.5)
 for details on the domain separation for regular ML-DSA. Line
 23 of Algorithm 4 (and line 18 of Algorithm 5,resp.) describe domain separation for the HashMl-DSA
 variant.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.derive_message_representative
with types libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
void
libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(
  Eurydice_borrow_slice_u8 verification_key_hash,
  const core_option_Option_84 *domain_separation_context,
  Eurydice_borrow_slice_u8 message,
  Eurydice_arr_060 *message_representative
)
{
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake, verification_key_hash);
  if (domain_separation_context->tag == core_option_Some)
  {
    const
    libcrux_ml_dsa_pre_hash_DomainSeparationContext
    *domain_separation_context0 = &domain_separation_context->f0;
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *uu____0 = &shake;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_f10
    lvalue0 =
      {
        .data = {
          (uint8_t)core_option_is_some_cd_4e(libcrux_ml_dsa_pre_hash_pre_hash_oid_88(domain_separation_context0))
        }
      };
    libcrux_ml_dsa_hash_functions_portable_absorb_26(uu____0,
      Eurydice_array_to_slice_shared_07(&lvalue0));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *uu____1 = &shake;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_f10
    lvalue =
      { .data = { (uint8_t)libcrux_ml_dsa_pre_hash_context_88(domain_separation_context0).meta } };
    libcrux_ml_dsa_hash_functions_portable_absorb_26(uu____1,
      Eurydice_array_to_slice_shared_07(&lvalue));
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      libcrux_ml_dsa_pre_hash_context_88(domain_separation_context0));
    const
    core_option_Option_b5
    *uu____2 = libcrux_ml_dsa_pre_hash_pre_hash_oid_88(domain_separation_context0);
    if (uu____2->tag == core_option_Some)
    {
      const Eurydice_arr_cb *pre_hash_oid = &uu____2->f0;
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_da(pre_hash_oid));
    }
  }
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake, message);
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_d8(message_representative));
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 576
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_fa(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_x4_9b
with const generics
- OUT_LEN= 576
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
)
{
  libcrux_ml_dsa_hash_functions_portable_shake256_1b(input0, out0);
  libcrux_ml_dsa_hash_functions_portable_shake256_1b(input1, out1);
  libcrux_ml_dsa_hash_functions_portable_shake256_1b(input2, out2);
  libcrux_ml_dsa_hash_functions_portable_shake256_1b(input3, out3);
}

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 640
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
)
{
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_7d(out), input);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_x4_9b
with const generics
- OUT_LEN= 640
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
)
{
  libcrux_ml_dsa_hash_functions_portable_shake256_c8(input0, out0);
  libcrux_ml_dsa_hash_functions_portable_shake256_c8(input1, out1);
  libcrux_ml_dsa_hash_functions_portable_shake256_c8(input2, out2);
  libcrux_ml_dsa_hash_functions_portable_shake256_c8(input3, out3);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 640
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_61_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
)
{
  libcrux_ml_dsa_hash_functions_portable_shake256_c8(input, out);
}

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 576
*/
KRML_MUSTINLINE void
libcrux_ml_dsa_hash_functions_portable_shake256_61_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
)
{
  libcrux_ml_dsa_hash_functions_portable_shake256_1b(input, out);
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_mask_ring_element
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256
with const generics

*/
static KRML_MUSTINLINE void
sample_mask_ring_element_2e(
  const Eurydice_arr_a2 *seed,
  Eurydice_arr_a4 *result,
  size_t gamma1_exponent
)
{
  switch (gamma1_exponent)
  {
    case 17U:
      {
        break;
      }
    case 19U:
      {
        Eurydice_arr_c30 out = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_portable_shake256_61_c8(Eurydice_array_to_slice_shared_39(seed),
          &out);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_7d0(&out),
          result);
        return;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  Eurydice_arr_5f0 out = { .data = { 0U } };
  libcrux_ml_dsa_hash_functions_portable_shake256_61_1b(Eurydice_array_to_slice_shared_39(seed),
    &out);
  libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
    Eurydice_array_to_slice_shared_fa(&out),
    result);
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_mask_vector
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
sample_mask_vector_67(
  size_t dimension,
  size_t gamma1_exponent,
  const Eurydice_arr_060 *seed,
  uint16_t *domain_separator,
  Eurydice_dst_ref_mut_e7 mask
)
{
  Eurydice_arr_a2
  seed0 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      domain_separator[0U]);
  Eurydice_arr_a2
  seed1 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 1U);
  Eurydice_arr_a2
  seed2 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 2U);
  Eurydice_arr_a2
  seed3 =
    libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
      (uint32_t)domain_separator[0U] + 3U);
  domain_separator[0U] = (uint32_t)domain_separator[0U] + 4U;
  switch (gamma1_exponent)
  {
    case 17U:
      {
        Eurydice_arr_5f0 out0 = { .data = { 0U } };
        Eurydice_arr_5f0 out1 = { .data = { 0U } };
        Eurydice_arr_5f0 out2 = { .data = { 0U } };
        Eurydice_arr_5f0 out3 = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_1b(Eurydice_array_to_slice_shared_39(&seed0),
          Eurydice_array_to_slice_shared_39(&seed1),
          Eurydice_array_to_slice_shared_39(&seed2),
          Eurydice_array_to_slice_shared_39(&seed3),
          &out0,
          &out1,
          &out2,
          &out3);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_fa(&out0),
          mask.ptr);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_fa(&out1),
          &mask.ptr[1U]);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_fa(&out2),
          &mask.ptr[2U]);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_fa(&out3),
          &mask.ptr[3U]);
        break;
      }
    case 19U:
      {
        Eurydice_arr_c30 out0 = { .data = { 0U } };
        Eurydice_arr_c30 out1 = { .data = { 0U } };
        Eurydice_arr_c30 out2 = { .data = { 0U } };
        Eurydice_arr_c30 out3 = { .data = { 0U } };
        libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_c8(Eurydice_array_to_slice_shared_39(&seed0),
          Eurydice_array_to_slice_shared_39(&seed1),
          Eurydice_array_to_slice_shared_39(&seed2),
          Eurydice_array_to_slice_shared_39(&seed3),
          &out0,
          &out1,
          &out2,
          &out3);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_7d0(&out0),
          mask.ptr);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_7d0(&out1),
          &mask.ptr[1U]);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_7d0(&out2),
          &mask.ptr[2U]);
        libcrux_ml_dsa_encoding_gamma1_deserialize_37(gamma1_exponent,
          Eurydice_array_to_slice_shared_7d0(&out3),
          &mask.ptr[3U]);
        break;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
        KRML_HOST_EXIT(255U);
      }
  }
  for (size_t i = (size_t)4U; i < dimension; i++)
  {
    size_t i0 = i;
    Eurydice_arr_a2
    seed4 =
      libcrux_ml_dsa_sample_add_error_domain_separator(Eurydice_array_to_slice_shared_d8(seed),
        domain_separator[0U]);
    domain_separator[0U] = (uint32_t)domain_separator[0U] + 1U;
    sample_mask_ring_element_2e(&seed4, &mask.ptr[i0], gamma1_exponent);
  }
}

/**
A monomorphic instance of libcrux_ml_dsa.sample.sample_challenge_ring_element
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_hash_functions_portable_Shake256
with const generics

*/
static KRML_MUSTINLINE void
sample_challenge_ring_element_2e(
  Eurydice_borrow_slice_u8 seed,
  size_t number_of_ones,
  Eurydice_arr_a4 *re
)
{
  Eurydice_arr_26 state = libcrux_ml_dsa_hash_functions_portable_init_absorb_final_61(seed);
  Eurydice_arr_3d
  randomness0 = libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_61(&state);
  Eurydice_array_u8x8 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_360(&randomness0,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })).ptr,
    (size_t)8U * sizeof (uint8_t));
  uint64_t
  signs =
    core_num__u64__from_le_bytes(core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        )));
  Eurydice_arr_c3 result = { .data = { 0U } };
  size_t out_index = (size_t)256U - number_of_ones;
  bool
  done =
    libcrux_ml_dsa_sample_inside_out_shuffle(Eurydice_array_to_subslice_from_shared_8c(&randomness0,
        (size_t)8U),
      &out_index,
      &signs,
      &result);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_3d
      randomness = libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_61(&state);
      done =
        libcrux_ml_dsa_sample_inside_out_shuffle(Eurydice_array_to_slice_shared_d4(&randomness),
          &out_index,
          &signs,
          &result);
    }
  }
  libcrux_ml_dsa_polynomial_from_i32_array_ff_37(Eurydice_array_to_slice_shared_200(&result),
    re);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_internal_5a(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_a80 s1_as_ntt;
  Eurydice_arr_a4 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_a80 s2_as_ntt;
  Eurydice_arr_a4 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_a80 t0_as_ntt;
  Eurydice_arr_a4 repeat_expression2[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)4U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    Eurydice_array_to_slice_mut_711(&s1_as_ntt));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    Eurydice_array_to_slice_mut_711(&s2_as_ntt));
  libcrux_ml_dsa_encoding_t0_deserialize_to_vector_then_ntt_37(t0_serialized,
    Eurydice_array_to_slice_mut_711(&t0_as_ntt));
  Eurydice_arr_66 matrix;
  Eurydice_arr_a4 repeat_expression3[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(matrix.data, repeat_expression3, (size_t)16U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_710(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_90 commitment_hash0 = { .tag = core_option_None };
  core_option_Option_43 signer_response0 = { .tag = core_option_None };
  core_option_Option_cf hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_a80 mask;
    Eurydice_arr_a4 repeat_expression4[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression4[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(mask.data, repeat_expression4, (size_t)4U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_a80 w0;
    Eurydice_arr_a4 repeat_expression5[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression5[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(w0.data, repeat_expression5, (size_t)4U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_a80 commitment;
    Eurydice_arr_a4 repeat_expression6[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression6[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(commitment.data, repeat_expression6, (size_t)4U * sizeof (Eurydice_arr_a4));
    sample_mask_vector_67(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      Eurydice_array_to_slice_mut_711(&mask));
    Eurydice_arr_a80 a_x_mask;
    Eurydice_arr_a4 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_a80
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &mask,
        Eurydice_arr_a4,
        Eurydice_arr_a80);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t i0 = i;
      libcrux_ml_dsa_ntt_ntt_37(&mask_ntt.data[i0]););
    libcrux_ml_dsa_matrix_compute_matrix_x_mask_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      Eurydice_array_to_slice_shared_711(&matrix),
      Eurydice_array_to_slice_shared_71(&mask_ntt),
      Eurydice_array_to_slice_mut_711(&a_x_mask));
    libcrux_ml_dsa_arithmetic_decompose_vector_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
      Eurydice_array_to_slice_shared_71(&a_x_mask),
      Eurydice_array_to_slice_mut_711(&w0),
      Eurydice_array_to_slice_mut_711(&commitment));
    Eurydice_arr_60 commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
    libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_COMMITMENT_RING_ELEMENT_SIZE,
      Eurydice_array_to_slice_shared_71(&commitment),
      Eurydice_array_to_slice_mut_ee(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_ee(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_6e(&commitment_hash_candidate));
    Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
    sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_6e(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
    Eurydice_arr_a80
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &s1_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_a80);
    Eurydice_arr_a80
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
        &s2_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_a80);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_711(&challenge_times_s1),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_711(&challenge_times_s2),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      Eurydice_array_to_slice_mut_711(&mask),
      Eurydice_array_to_slice_shared_71(&challenge_times_s1));
    libcrux_ml_dsa_matrix_subtract_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      Eurydice_array_to_slice_mut_711(&w0),
      Eurydice_array_to_slice_shared_71(&challenge_times_s2));
    if
    (
      !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_71(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
    )
    {
      if
      (
        !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_71(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
      )
      {
        Eurydice_arr_a80
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)4U,
            &t0_as_ntt,
            Eurydice_arr_a4,
            Eurydice_arr_a80);
        libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_711(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_71(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2)
        )
        {
          libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
            Eurydice_array_to_slice_mut_711(&w0),
            Eurydice_array_to_slice_shared_71(&challenge_times_t0));
          Eurydice_arr_83
          hint_candidate =
            {
              .data = {
                { .data = { 0U } },
                { .data = { 0U } },
                { .data = { 0U } },
                { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            libcrux_ml_dsa_arithmetic_make_hint_37(Eurydice_array_to_slice_shared_71(&w0),
              Eurydice_array_to_slice_shared_71(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
              Eurydice_array_to_slice_mut_6d(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_90){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 =
              (KRML_CLITERAL(core_option_Option_43){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_cf){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_60 commitment_hash = commitment_hash0.f0;
    Eurydice_arr_60 commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_a80 signer_response = signer_response0.f0;
      Eurydice_arr_a80 signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_83 hint = hint0.f0;
        Eurydice_arr_83 hint1 = hint;
        libcrux_ml_dsa_encoding_signature_serialize_37(Eurydice_array_to_slice_shared_6e(&commitment_hash1),
          Eurydice_array_to_slice_shared_71(&signer_response1),
          Eurydice_array_to_slice_shared_6d(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_180(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_mut_5a(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_5a(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_48
sign_5a(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_400 signature = libcrux_ml_dsa_types_zero_c5_1a();
  core_result_Result_53
  uu____0 = sign_mut_5a(signing_key, message, context, randomness, &signature);
  core_result_Result_48 uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_48){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_48){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_5a(Eurydice_array_to_slice_shared_59(signing_key), message, context, randomness);
}

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  return
    sign_mut_5a(Eurydice_array_to_slice_shared_59(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
This function found in impl {libcrux_ml_dsa::pre_hash::PreHash for libcrux_ml_dsa::pre_hash::SHAKE128_PH}
*/
/**
A monomorphic instance of libcrux_ml_dsa.pre_hash.hash_30
with types libcrux_ml_dsa_hash_functions_portable_Shake128
with const generics

*/
void
libcrux_ml_dsa_pre_hash_hash_30_83(
  Eurydice_borrow_slice_u8 message,
  Eurydice_mut_borrow_slice_u8 output
)
{
  libcrux_ml_dsa_hash_functions_portable_shake128_7b(message, output);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_3f(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_5a(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.sign_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_48
sign_pre_hashed_3f(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_400 signature = libcrux_ml_dsa_types_zero_c5_1a();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_3f(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_48 uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_48){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_48){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign (pre-hashed).
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_3f(Eurydice_array_to_slice_shared_59(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_internal_5a(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_400 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_bb(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_a80 t1;
  Eurydice_arr_a4 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_verification_key_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_VERIFICATION_KEY_SIZE,
    t1_serialized,
    Eurydice_array_to_slice_mut_711(&t1));
  Eurydice_arr_60 deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_a80 deserialized_signer_response;
  Eurydice_arr_a4 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)4U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_83
  deserialized_hint =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  core_result_Result_41
  uu____1 =
    libcrux_ml_dsa_encoding_signature_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_MAX_ONES_IN_HINT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_SIGNATURE_SIZE,
      Eurydice_array_to_slice_shared_180(signature_serialized),
      Eurydice_array_to_slice_mut_6e(&deserialized_commitment_hash),
      Eurydice_array_to_slice_mut_711(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_71(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      Eurydice_arr_66 matrix;
      Eurydice_arr_a4 repeat_expression[16U];
      KRML_MAYBE_FOR16(i,
        (size_t)0U,
        (size_t)16U,
        (size_t)1U,
        repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
      memcpy(matrix.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_a4));
      libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
        seed_for_a,
        Eurydice_array_to_slice_mut_710(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_portable_shake256_61_24(Eurydice_array_to_slice_shared_bb(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
      sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_6e(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
      KRML_MAYBE_FOR4(i,
        (size_t)0U,
        (size_t)4U,
        (size_t)1U,
        size_t i0 = i;
        libcrux_ml_dsa_ntt_ntt_37(&deserialized_signer_response.data[i0]););
      libcrux_ml_dsa_matrix_compute_w_approx_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_COLUMNS_IN_A,
        Eurydice_array_to_slice_shared_711(&matrix),
        Eurydice_array_to_slice_shared_71(&deserialized_signer_response),
        &verifier_challenge,
        Eurydice_array_to_slice_mut_711(&t1));
      Eurydice_arr_60 recomputed_commitment_hash = { .data = { 0U } };
      libcrux_ml_dsa_arithmetic_use_hint_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_44_GAMMA2,
        Eurydice_array_to_slice_shared_6d(&deserialized_hint),
        Eurydice_array_to_slice_mut_711(&t1));
      Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
      libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_44_COMMITMENT_RING_ELEMENT_SIZE,
        Eurydice_array_to_slice_shared_71(&t1),
        Eurydice_array_to_slice_mut_ee(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_ee(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_6e(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)32U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_5a(
  const Eurydice_arr_40 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
)
{
  return verify_5a(verification_key, message, context, signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_44.verify_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_3f(
  const Eurydice_arr_40 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
)
{
  return verify_pre_hashed_3f(verification_key, message, context, pre_hash_buffer, signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.generate_key_pair
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
generate_key_pair_5a0(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  Eurydice_arr_58 s1_s2;
  Eurydice_arr_a4 repeat_expression0[11U];
  KRML_MAYBE_FOR11(i,
    (size_t)0U,
    (size_t)11U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)11U * sizeof (Eurydice_arr_a4));
  sample_s1_and_s2_29(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    seed_for_error_vectors,
    Eurydice_array_to_slice_mut_712(&s1_s2));
  Eurydice_arr_a3 t0;
  Eurydice_arr_a4 repeat_expression1[6U];
  KRML_MAYBE_FOR6(i,
    (size_t)0U,
    (size_t)6U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0.data, repeat_expression1, (size_t)6U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_a1 a_as_ntt;
  Eurydice_arr_a4 repeat_expression2[30U];
  for (size_t i = (size_t)0U; i < (size_t)30U; i++)
  {
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
  }
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)30U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_713(&a_as_ntt));
  Eurydice_arr_b0 s1_ntt;
  Eurydice_arr_a4 repeat_expression3[5U];
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)5U * sizeof (Eurydice_arr_a4));
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_714(&s1_ntt),
    Eurydice_array_to_subslice_shared_c30(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_a4);
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_ml_dsa_ntt_ntt_37(&s1_ntt.data[i0]););
  libcrux_ml_dsa_matrix_compute_as1_plus_s2_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    Eurydice_array_to_slice_mut_713(&a_as_ntt),
    Eurydice_array_to_slice_shared_712(&s1_ntt),
    Eurydice_array_to_slice_shared_713(&s1_s2),
    Eurydice_array_to_slice_mut_715(&t0));
  Eurydice_arr_a3 t1;
  Eurydice_arr_a4 repeat_expression[6U];
  KRML_MAYBE_FOR6(i,
    (size_t)0U,
    (size_t)6U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression, (size_t)6U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_arithmetic_power2round_vector_37(Eurydice_array_to_slice_mut_715(&t0),
    Eurydice_array_to_slice_mut_715(&t1));
  libcrux_ml_dsa_encoding_verification_key_generate_serialized_37(seed_for_a,
    Eurydice_array_to_slice_shared_714(&t1),
    verification_key);
  generate_serialized_2e(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    Eurydice_array_to_slice_shared_713(&s1_s2),
    Eurydice_array_to_slice_shared_714(&t0),
    signing_key);
}

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
)
{
  generate_key_pair_5a0(randomness,
    Eurydice_array_to_slice_mut_ef(signing_key),
    Eurydice_array_to_slice_mut_5b(verification_key));
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_internal_5a0(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_b0 s1_as_ntt;
  Eurydice_arr_a4 repeat_expression0[5U];
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)5U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_a3 s2_as_ntt;
  Eurydice_arr_a4 repeat_expression1[6U];
  KRML_MAYBE_FOR6(i,
    (size_t)0U,
    (size_t)6U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)6U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_a3 t0_as_ntt;
  Eurydice_arr_a4 repeat_expression2[6U];
  KRML_MAYBE_FOR6(i,
    (size_t)0U,
    (size_t)6U,
    (size_t)1U,
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)6U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    Eurydice_array_to_slice_mut_714(&s1_as_ntt));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    Eurydice_array_to_slice_mut_715(&s2_as_ntt));
  libcrux_ml_dsa_encoding_t0_deserialize_to_vector_then_ntt_37(t0_serialized,
    Eurydice_array_to_slice_mut_715(&t0_as_ntt));
  Eurydice_arr_a1 matrix;
  Eurydice_arr_a4 repeat_expression3[30U];
  for (size_t i = (size_t)0U; i < (size_t)30U; i++)
  {
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
  }
  memcpy(matrix.data, repeat_expression3, (size_t)30U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_713(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_a6 commitment_hash0 = { .tag = core_option_None };
  core_option_Option_c8 signer_response0 = { .tag = core_option_None };
  core_option_Option_cb hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_b0 mask;
    Eurydice_arr_a4 repeat_expression4[5U];
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      repeat_expression4[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(mask.data, repeat_expression4, (size_t)5U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_a3 w0;
    Eurydice_arr_a4 repeat_expression5[6U];
    KRML_MAYBE_FOR6(i,
      (size_t)0U,
      (size_t)6U,
      (size_t)1U,
      repeat_expression5[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(w0.data, repeat_expression5, (size_t)6U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_a3 commitment;
    Eurydice_arr_a4 repeat_expression6[6U];
    KRML_MAYBE_FOR6(i,
      (size_t)0U,
      (size_t)6U,
      (size_t)1U,
      repeat_expression6[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(commitment.data, repeat_expression6, (size_t)6U * sizeof (Eurydice_arr_a4));
    sample_mask_vector_67(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      Eurydice_array_to_slice_mut_714(&mask));
    Eurydice_arr_a3 a_x_mask;
    Eurydice_arr_a4 repeat_expression[6U];
    KRML_MAYBE_FOR6(i,
      (size_t)0U,
      (size_t)6U,
      (size_t)1U,
      repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)6U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_b0
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)5U,
        &mask,
        Eurydice_arr_a4,
        Eurydice_arr_b0);
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t i0 = i;
      libcrux_ml_dsa_ntt_ntt_37(&mask_ntt.data[i0]););
    libcrux_ml_dsa_matrix_compute_matrix_x_mask_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      Eurydice_array_to_slice_shared_715(&matrix),
      Eurydice_array_to_slice_shared_712(&mask_ntt),
      Eurydice_array_to_slice_mut_715(&a_x_mask));
    libcrux_ml_dsa_arithmetic_decompose_vector_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
      Eurydice_array_to_slice_shared_714(&a_x_mask),
      Eurydice_array_to_slice_mut_715(&w0),
      Eurydice_array_to_slice_mut_715(&commitment));
    Eurydice_arr_5f commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
    libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_COMMITMENT_RING_ELEMENT_SIZE,
      Eurydice_array_to_slice_shared_714(&commitment),
      Eurydice_array_to_slice_mut_ee(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_ee(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_95(&commitment_hash_candidate));
    Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
    sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_95(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
    Eurydice_arr_b0
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)5U,
        &s1_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_b0);
    Eurydice_arr_a3
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)6U,
        &s2_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_a3);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_714(&challenge_times_s1),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_715(&challenge_times_s2),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      Eurydice_array_to_slice_mut_714(&mask),
      Eurydice_array_to_slice_shared_712(&challenge_times_s1));
    libcrux_ml_dsa_matrix_subtract_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      Eurydice_array_to_slice_mut_715(&w0),
      Eurydice_array_to_slice_shared_714(&challenge_times_s2));
    if
    (
      !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_712(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
    )
    {
      if
      (
        !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_714(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
      )
      {
        Eurydice_arr_a3
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)6U,
            &t0_as_ntt,
            Eurydice_arr_a4,
            Eurydice_arr_a3);
        libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_715(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_714(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2)
        )
        {
          libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
            Eurydice_array_to_slice_mut_715(&w0),
            Eurydice_array_to_slice_shared_714(&challenge_times_t0));
          Eurydice_arr_b5
          hint_candidate =
            {
              .data = {
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
                { .data = { 0U } }, { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            libcrux_ml_dsa_arithmetic_make_hint_37(Eurydice_array_to_slice_shared_714(&w0),
              Eurydice_array_to_slice_shared_714(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
              Eurydice_array_to_slice_mut_6d0(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_a6){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 =
              (KRML_CLITERAL(core_option_Option_c8){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_cb){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_5f commitment_hash = commitment_hash0.f0;
    Eurydice_arr_5f commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_b0 signer_response = signer_response0.f0;
      Eurydice_arr_b0 signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_b5 hint = hint0.f0;
        Eurydice_arr_b5 hint1 = hint;
        libcrux_ml_dsa_encoding_signature_serialize_37(Eurydice_array_to_slice_shared_95(&commitment_hash1),
          Eurydice_array_to_slice_shared_712(&signer_response1),
          Eurydice_array_to_slice_shared_6d0(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_ee0(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_mut_5a0(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_5a0(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_8c
sign_5a0(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_96 signature = libcrux_ml_dsa_types_zero_c5_fa();
  core_result_Result_53
  uu____0 = sign_mut_5a0(signing_key, message, context, randomness, &signature);
  core_result_Result_8c uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8c){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8c){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_5a0(Eurydice_array_to_slice_shared_ef(signing_key), message, context, randomness);
}

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  return
    sign_mut_5a0(Eurydice_array_to_slice_shared_ef(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_3f0(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_5a0(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.sign_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_8c
sign_pre_hashed_3f0(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_96 signature = libcrux_ml_dsa_types_zero_c5_fa();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_3f0(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_8c uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8c){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8c){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign (pre-hashed).
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_3f0(Eurydice_array_to_slice_shared_ef(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_internal_5a0(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_96 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_5b(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_a3 t1;
  Eurydice_arr_a4 repeat_expression0[6U];
  KRML_MAYBE_FOR6(i,
    (size_t)0U,
    (size_t)6U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression0, (size_t)6U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_verification_key_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_VERIFICATION_KEY_SIZE,
    t1_serialized,
    Eurydice_array_to_slice_mut_715(&t1));
  Eurydice_arr_5f deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_b0 deserialized_signer_response;
  Eurydice_arr_a4 repeat_expression1[5U];
  KRML_MAYBE_FOR5(i,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)5U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_b5
  deserialized_hint =
    {
      .data = {
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
        { .data = { 0U } }, { .data = { 0U } }
      }
    };
  core_result_Result_41
  uu____1 =
    libcrux_ml_dsa_encoding_signature_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_MAX_ONES_IN_HINT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_SIGNATURE_SIZE,
      Eurydice_array_to_slice_shared_ee0(signature_serialized),
      Eurydice_array_to_slice_mut_95(&deserialized_commitment_hash),
      Eurydice_array_to_slice_mut_714(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d0(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_712(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      Eurydice_arr_a1 matrix;
      Eurydice_arr_a4 repeat_expression[30U];
      for (size_t i = (size_t)0U; i < (size_t)30U; i++)
      {
        repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
      }
      memcpy(matrix.data, repeat_expression, (size_t)30U * sizeof (Eurydice_arr_a4));
      libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
        seed_for_a,
        Eurydice_array_to_slice_mut_713(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_portable_shake256_61_24(Eurydice_array_to_slice_shared_5b(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
      sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_95(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
      KRML_MAYBE_FOR5(i,
        (size_t)0U,
        (size_t)5U,
        (size_t)1U,
        size_t i0 = i;
        libcrux_ml_dsa_ntt_ntt_37(&deserialized_signer_response.data[i0]););
      libcrux_ml_dsa_matrix_compute_w_approx_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_COLUMNS_IN_A,
        Eurydice_array_to_slice_shared_715(&matrix),
        Eurydice_array_to_slice_shared_712(&deserialized_signer_response),
        &verifier_challenge,
        Eurydice_array_to_slice_mut_715(&t1));
      Eurydice_arr_5f recomputed_commitment_hash = { .data = { 0U } };
      libcrux_ml_dsa_arithmetic_use_hint_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_65_GAMMA2,
        Eurydice_array_to_slice_shared_6d0(&deserialized_hint),
        Eurydice_array_to_slice_mut_715(&t1));
      Eurydice_arr_56 commitment_serialized = { .data = { 0U } };
      libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_65_COMMITMENT_RING_ELEMENT_SIZE,
        Eurydice_array_to_slice_shared_714(&t1),
        Eurydice_array_to_slice_mut_ee(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_ee(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_95(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)48U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_5a0(
  const Eurydice_arr_4a *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a0(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
)
{
  return verify_5a0(verification_key, message, context, signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_65.verify_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_3f0(
  const Eurydice_arr_4a *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a0(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
)
{
  return verify_pre_hashed_3f0(verification_key, message, context, pre_hash_buffer, signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.generate_key_pair
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE void
generate_key_pair_5a1(
  Eurydice_arr_60 randomness,
  Eurydice_mut_borrow_slice_u8 signing_key,
  Eurydice_mut_borrow_slice_u8 verification_key
)
{
  Eurydice_arr_d10 seed_expanded0 = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
    Eurydice_array_to_slice_shared_6e(&randomness));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x2
  lvalue =
    {
      .data = {
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
        (uint8_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A
      }
    };
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
    Eurydice_array_to_slice_shared_26(&lvalue));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
    Eurydice_array_to_slice_mut_18(&seed_expanded0));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_18(&seed_expanded0),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_expanded = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(seed_expanded,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_ERROR_VECTORS_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_error_vectors = uu____1.fst;
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.snd;
  Eurydice_arr_f8 s1_s2;
  Eurydice_arr_a4 repeat_expression0[15U];
  KRML_MAYBE_FOR15(i,
    (size_t)0U,
    (size_t)15U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_s2.data, repeat_expression0, (size_t)15U * sizeof (Eurydice_arr_a4));
  sample_s1_and_s2_29(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    seed_for_error_vectors,
    Eurydice_array_to_slice_mut_716(&s1_s2));
  Eurydice_arr_db t0;
  Eurydice_arr_a4 repeat_expression1[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0.data, repeat_expression1, (size_t)8U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_46 a_as_ntt;
  Eurydice_arr_a4 repeat_expression2[56U];
  for (size_t i = (size_t)0U; i < (size_t)56U; i++)
  {
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
  }
  memcpy(a_as_ntt.data, repeat_expression2, (size_t)56U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_717(&a_as_ntt));
  Eurydice_arr_25 s1_ntt;
  Eurydice_arr_a4 repeat_expression3[7U];
  KRML_MAYBE_FOR7(i,
    (size_t)0U,
    (size_t)7U,
    (size_t)1U,
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_ntt.data, repeat_expression3, (size_t)7U * sizeof (Eurydice_arr_a4));
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_718(&s1_ntt),
    Eurydice_array_to_subslice_shared_c31(&s1_s2,
      (
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A
        }
      )),
    Eurydice_arr_a4);
  KRML_MAYBE_FOR7(i,
    (size_t)0U,
    (size_t)7U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_ml_dsa_ntt_ntt_37(&s1_ntt.data[i0]););
  libcrux_ml_dsa_matrix_compute_as1_plus_s2_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
    LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    Eurydice_array_to_slice_mut_717(&a_as_ntt),
    Eurydice_array_to_slice_shared_716(&s1_ntt),
    Eurydice_array_to_slice_shared_717(&s1_s2),
    Eurydice_array_to_slice_mut_71(&t0));
  Eurydice_arr_db t1;
  Eurydice_arr_a4 repeat_expression[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression, (size_t)8U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_arithmetic_power2round_vector_37(Eurydice_array_to_slice_mut_71(&t0),
    Eurydice_array_to_slice_mut_71(&t1));
  libcrux_ml_dsa_encoding_verification_key_generate_serialized_37(seed_for_a,
    Eurydice_array_to_slice_shared_710(&t1),
    verification_key);
  generate_serialized_2e(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    seed_for_a,
    seed_for_signing,
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8){
        .ptr = verification_key.ptr,
        .meta = verification_key.meta
      }
    ),
    Eurydice_array_to_slice_shared_717(&s1_s2),
    Eurydice_array_to_slice_shared_710(&t0),
    signing_key);
}

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_180 *signing_key,
  Eurydice_arr_51 *verification_key
)
{
  generate_key_pair_5a1(randomness,
    Eurydice_array_to_slice_mut_e2(signing_key),
    Eurydice_array_to_slice_mut_f7(verification_key));
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_internal_5a1(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(signing_key,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 remaining_serialized0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(remaining_serialized0,
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_SIGNING_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_signing = uu____1.fst;
  Eurydice_borrow_slice_u8 remaining_serialized1 = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(remaining_serialized1,
      LIBCRUX_ML_DSA_CONSTANTS_BYTES_FOR_VERIFICATION_KEY_HASH,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 verification_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 remaining_serialized2 = uu____2.snd;
  Eurydice_borrow_slice_u8_x2
  uu____3 =
    Eurydice_slice_split_at(remaining_serialized2,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s1_serialized = uu____3.fst;
  Eurydice_borrow_slice_u8 remaining_serialized = uu____3.snd;
  Eurydice_borrow_slice_u8_x2
  uu____4 =
    Eurydice_slice_split_at(remaining_serialized,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE *
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 s2_serialized = uu____4.fst;
  Eurydice_borrow_slice_u8 t0_serialized = uu____4.snd;
  Eurydice_arr_25 s1_as_ntt;
  Eurydice_arr_a4 repeat_expression0[7U];
  KRML_MAYBE_FOR7(i,
    (size_t)0U,
    (size_t)7U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s1_as_ntt.data, repeat_expression0, (size_t)7U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_db s2_as_ntt;
  Eurydice_arr_a4 repeat_expression1[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(s2_as_ntt.data, repeat_expression1, (size_t)8U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_db t0_as_ntt;
  Eurydice_arr_a4 repeat_expression2[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression2[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t0_as_ntt.data, repeat_expression2, (size_t)8U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    s1_serialized,
    Eurydice_array_to_slice_mut_718(&s1_as_ntt));
  libcrux_ml_dsa_encoding_error_deserialize_to_vector_then_ntt_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ETA,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_ERROR_RING_ELEMENT_SIZE,
    s2_serialized,
    Eurydice_array_to_slice_mut_71(&s2_as_ntt));
  libcrux_ml_dsa_encoding_t0_deserialize_to_vector_then_ntt_37(t0_serialized,
    Eurydice_array_to_slice_mut_71(&t0_as_ntt));
  Eurydice_arr_46 matrix;
  Eurydice_arr_a4 repeat_expression3[56U];
  for (size_t i = (size_t)0U; i < (size_t)56U; i++)
  {
    repeat_expression3[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
  }
  memcpy(matrix.data, repeat_expression3, (size_t)56U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
    seed_for_a,
    Eurydice_array_to_slice_mut_717(&matrix));
  Eurydice_arr_060 message_representative = { .data = { 0U } };
  libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(verification_key_hash,
    &domain_separation_context,
    message,
    &message_representative);
  Eurydice_arr_060 mask_seed = { .data = { 0U } };
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
  shake0 = libcrux_ml_dsa_hash_functions_portable_init_26();
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0, seed_for_signing);
  libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake0,
    Eurydice_array_to_slice_shared_6e(&randomness));
  libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake0,
    Eurydice_array_to_slice_shared_d8(&message_representative));
  libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake0,
    Eurydice_array_to_slice_mut_d8(&mask_seed));
  uint16_t domain_separator_for_mask = 0U;
  size_t attempt = (size_t)0U;
  core_option_Option_d9 commitment_hash0 = { .tag = core_option_None };
  core_option_Option_0d signer_response0 = { .tag = core_option_None };
  core_option_Option_b9 hint0 = { .tag = core_option_None };
  while (attempt < LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN)
  {
    attempt++;
    Eurydice_arr_25 mask;
    Eurydice_arr_a4 repeat_expression4[7U];
    KRML_MAYBE_FOR7(i,
      (size_t)0U,
      (size_t)7U,
      (size_t)1U,
      repeat_expression4[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(mask.data, repeat_expression4, (size_t)7U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_db w0;
    Eurydice_arr_a4 repeat_expression5[8U];
    KRML_MAYBE_FOR8(i,
      (size_t)0U,
      (size_t)8U,
      (size_t)1U,
      repeat_expression5[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(w0.data, repeat_expression5, (size_t)8U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_db commitment;
    Eurydice_arr_a4 repeat_expression6[8U];
    KRML_MAYBE_FOR8(i,
      (size_t)0U,
      (size_t)8U,
      (size_t)1U,
      repeat_expression6[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(commitment.data, repeat_expression6, (size_t)8U * sizeof (Eurydice_arr_a4));
    sample_mask_vector_67(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
      &mask_seed,
      &domain_separator_for_mask,
      Eurydice_array_to_slice_mut_718(&mask));
    Eurydice_arr_db a_x_mask;
    Eurydice_arr_a4 repeat_expression[8U];
    KRML_MAYBE_FOR8(i,
      (size_t)0U,
      (size_t)8U,
      (size_t)1U,
      repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
    memcpy(a_x_mask.data, repeat_expression, (size_t)8U * sizeof (Eurydice_arr_a4));
    Eurydice_arr_25
    mask_ntt =
      core_array__core__clone__Clone_for__T__N___clone((size_t)7U,
        &mask,
        Eurydice_arr_a4,
        Eurydice_arr_25);
    KRML_MAYBE_FOR7(i,
      (size_t)0U,
      (size_t)7U,
      (size_t)1U,
      size_t i0 = i;
      libcrux_ml_dsa_ntt_ntt_37(&mask_ntt.data[i0]););
    libcrux_ml_dsa_matrix_compute_matrix_x_mask_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      Eurydice_array_to_slice_shared_718(&matrix),
      Eurydice_array_to_slice_shared_716(&mask_ntt),
      Eurydice_array_to_slice_mut_71(&a_x_mask));
    libcrux_ml_dsa_arithmetic_decompose_vector_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
      Eurydice_array_to_slice_shared_710(&a_x_mask),
      Eurydice_array_to_slice_mut_71(&w0),
      Eurydice_array_to_slice_mut_71(&commitment));
    Eurydice_arr_060 commitment_hash_candidate = { .data = { 0U } };
    Eurydice_arr_9e commitment_serialized = { .data = { 0U } };
    libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_COMMITMENT_RING_ELEMENT_SIZE,
      Eurydice_array_to_slice_shared_710(&commitment),
      Eurydice_array_to_slice_mut_fd(&commitment_serialized));
    libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
    shake = libcrux_ml_dsa_hash_functions_portable_init_26();
    libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
      Eurydice_array_to_slice_shared_d8(&message_representative));
    libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
      Eurydice_array_to_slice_shared_fd(&commitment_serialized));
    libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
      Eurydice_array_to_slice_mut_d8(&commitment_hash_candidate));
    Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
    sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_d8(&commitment_hash_candidate),
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE,
      &verifier_challenge);
    libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
    Eurydice_arr_25
    challenge_times_s1 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)7U,
        &s1_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_25);
    Eurydice_arr_db
    challenge_times_s2 =
      core_array__core__clone__Clone_for__T__N___clone((size_t)8U,
        &s2_as_ntt,
        Eurydice_arr_a4,
        Eurydice_arr_db);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_718(&challenge_times_s1),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_71(&challenge_times_s2),
      &verifier_challenge);
    libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      Eurydice_array_to_slice_mut_718(&mask),
      Eurydice_array_to_slice_shared_716(&challenge_times_s1));
    libcrux_ml_dsa_matrix_subtract_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      Eurydice_array_to_slice_mut_71(&w0),
      Eurydice_array_to_slice_shared_710(&challenge_times_s2));
    if
    (
      !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_716(&mask),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
    )
    {
      if
      (
        !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_710(&w0),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2 - LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
      )
      {
        Eurydice_arr_db
        challenge_times_t0 =
          core_array__core__clone__Clone_for__T__N___clone((size_t)8U,
            &t0_as_ntt,
            Eurydice_arr_a4,
            Eurydice_arr_db);
        libcrux_ml_dsa_matrix_vector_times_ring_element_37(Eurydice_array_to_slice_mut_71(&challenge_times_t0),
          &verifier_challenge);
        if
        (
          !libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_710(&challenge_times_t0),
            LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2)
        )
        {
          libcrux_ml_dsa_matrix_add_vectors_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
            Eurydice_array_to_slice_mut_71(&w0),
            Eurydice_array_to_slice_shared_710(&challenge_times_t0));
          Eurydice_arr_fb
          hint_candidate =
            {
              .data = {
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
                { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
              }
            };
          size_t
          ones_in_hint =
            libcrux_ml_dsa_arithmetic_make_hint_37(Eurydice_array_to_slice_shared_710(&w0),
              Eurydice_array_to_slice_shared_710(&commitment),
              LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
              Eurydice_array_to_slice_mut_6d1(&hint_candidate));
          if (!(ones_in_hint > LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT))
          {
            attempt = LIBCRUX_ML_DSA_CONSTANTS_REJECTION_SAMPLE_BOUND_SIGN;
            commitment_hash0 =
              (
                KRML_CLITERAL(core_option_Option_d9){
                  .tag = core_option_Some,
                  .f0 = commitment_hash_candidate
                }
              );
            signer_response0 =
              (KRML_CLITERAL(core_option_Option_0d){ .tag = core_option_Some, .f0 = mask });
            hint0 =
              (
                KRML_CLITERAL(core_option_Option_b9){
                  .tag = core_option_Some,
                  .f0 = hint_candidate
                }
              );
          }
        }
      }
    }
  }
  core_result_Result_53 uu____5;
  if (commitment_hash0.tag == core_option_None)
  {
    uu____5 =
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
        }
      );
  }
  else
  {
    Eurydice_arr_060 commitment_hash = commitment_hash0.f0;
    Eurydice_arr_060 commitment_hash1 = commitment_hash;
    if (signer_response0.tag == core_option_None)
    {
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
    else
    {
      Eurydice_arr_25 signer_response = signer_response0.f0;
      Eurydice_arr_25 signer_response1 = signer_response;
      if (!(hint0.tag == core_option_None))
      {
        Eurydice_arr_fb hint = hint0.f0;
        Eurydice_arr_fb hint1 = hint;
        libcrux_ml_dsa_encoding_signature_serialize_37(Eurydice_array_to_slice_shared_d8(&commitment_hash1),
          Eurydice_array_to_slice_shared_716(&signer_response1),
          Eurydice_array_to_slice_shared_6d1(&hint1),
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_GAMMA1_RING_ELEMENT_SIZE,
          LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT,
          Eurydice_array_to_slice_mut_24(signature));
        return (KRML_CLITERAL(core_result_Result_53){ .tag = core_result_Ok });
      }
      uu____5 =
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_RejectionSamplingError
          }
        );
    }
  }
  return uu____5;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_mut_5a1(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_53){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    sign_internal_5a1(signing_key,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4
with const generics

*/
static KRML_MUSTINLINE core_result_Result_8b
sign_5a1(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_38 signature = libcrux_ml_dsa_types_zero_c5_c2();
  core_result_Result_53
  uu____0 = sign_mut_5a1(signing_key, message, context, randomness, &signature);
  core_result_Result_8b uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8b){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8b){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
)
{
  return sign_5a1(Eurydice_array_to_slice_shared_e2(signing_key), message, context, randomness);
}

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  return
    sign_mut_5a1(Eurydice_array_to_slice_shared_e2(signing_key),
      message,
      context,
      randomness,
      signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_pre_hashed_mut
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_53
sign_pre_hashed_mut_3f1(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
)
{
  if (!(context.meta > LIBCRUX_ML_DSA_CONSTANTS_CONTEXT_MAX_LEN))
  {
    libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
    core_result_Result_a8
    uu____0 =
      libcrux_ml_dsa_pre_hash_new_88(context,
        (
          KRML_CLITERAL(core_option_Option_b5){
            .tag = core_option_Some,
            .f0 = libcrux_ml_dsa_pre_hash_oid_30()
          }
        ));
    if (!(uu____0.tag == core_result_Ok))
    {
      return
        (
          KRML_CLITERAL(core_result_Result_53){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
          }
        );
    }
    libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
    libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
    return
      sign_internal_5a1(signing_key,
        (
          KRML_CLITERAL(Eurydice_borrow_slice_u8){
            .ptr = pre_hash_buffer.ptr,
            .meta = pre_hash_buffer.meta
          }
        ),
        (
          KRML_CLITERAL(core_option_Option_84){
            .tag = core_option_Some,
            .f0 = domain_separation_context
          }
        ),
        randomness,
        signature);
  }
  return
    (
      KRML_CLITERAL(core_result_Result_53){
        .tag = core_result_Err,
        .f0 = libcrux_ml_dsa_types_SigningError_ContextTooLongError
      }
    );
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.sign_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_hash_functions_portable_Shake256X4, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_8b
sign_pre_hashed_3f1(
  Eurydice_borrow_slice_u8 signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  Eurydice_arr_38 signature = libcrux_ml_dsa_types_zero_c5_c2();
  core_result_Result_53
  uu____0 =
    sign_pre_hashed_mut_3f1(signing_key,
      message,
      context,
      pre_hash_buffer,
      randomness,
      &signature);
  core_result_Result_8b uu____1;
  if (uu____0.tag == core_result_Ok)
  {
    uu____1 =
      (
        KRML_CLITERAL(core_result_Result_8b){
          .tag = core_result_Ok,
          .val = { .case_Ok = signature }
        }
      );
  }
  else
  {
    libcrux_ml_dsa_types_SigningError e = uu____0.f0;
    uu____1 =
      (KRML_CLITERAL(core_result_Result_8b){ .tag = core_result_Err, .val = { .case_Err = e } });
  }
  return uu____1;
}

/**
 Sign (pre-hashed).
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
)
{
  return
    sign_pre_hashed_3f1(Eurydice_array_to_slice_shared_e2(signing_key),
      message,
      context,
      pre_hash_buffer,
      randomness);
}

/**
 The internal verification API.

 If no `domain_separation_context` is supplied, it is assumed that
 `message` already contains the domain separation.
*/
/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify_internal
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_internal_5a1(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  core_option_Option_84 domain_separation_context,
  const Eurydice_arr_38 *signature_serialized
)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_f7(verification_key),
      LIBCRUX_ML_DSA_CONSTANTS_SEED_FOR_A_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_a = uu____0.fst;
  Eurydice_borrow_slice_u8 t1_serialized = uu____0.snd;
  Eurydice_arr_db t1;
  Eurydice_arr_a4 repeat_expression0[8U];
  KRML_MAYBE_FOR8(i,
    (size_t)0U,
    (size_t)8U,
    (size_t)1U,
    repeat_expression0[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(t1.data, repeat_expression0, (size_t)8U * sizeof (Eurydice_arr_a4));
  libcrux_ml_dsa_encoding_verification_key_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
    LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_VERIFICATION_KEY_SIZE,
    t1_serialized,
    Eurydice_array_to_slice_mut_71(&t1));
  Eurydice_arr_060 deserialized_commitment_hash = { .data = { 0U } };
  Eurydice_arr_25 deserialized_signer_response;
  Eurydice_arr_a4 repeat_expression1[7U];
  KRML_MAYBE_FOR7(i,
    (size_t)0U,
    (size_t)7U,
    (size_t)1U,
    repeat_expression1[i] = libcrux_ml_dsa_polynomial_zero_ff_37(););
  memcpy(deserialized_signer_response.data,
    repeat_expression1,
    (size_t)7U * sizeof (Eurydice_arr_a4));
  Eurydice_arr_fb
  deserialized_hint =
    {
      .data = {
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
        { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
      }
    };
  core_result_Result_41
  uu____1 =
    libcrux_ml_dsa_encoding_signature_deserialize_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COMMITMENT_HASH_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_GAMMA1_RING_ELEMENT_SIZE,
      LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_MAX_ONES_IN_HINT,
      LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_SIGNATURE_SIZE,
      Eurydice_array_to_slice_shared_24(signature_serialized),
      Eurydice_array_to_slice_mut_d8(&deserialized_commitment_hash),
      Eurydice_array_to_slice_mut_718(&deserialized_signer_response),
      Eurydice_array_to_slice_mut_6d1(&deserialized_hint));
  core_result_Result_41 uu____2;
  if (uu____1.tag == core_result_Ok)
  {
    if
    (
      libcrux_ml_dsa_arithmetic_vector_infinity_norm_exceeds_37(Eurydice_array_to_slice_shared_716(&deserialized_signer_response),
        ((int32_t)1 << (uint32_t)LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA1_EXPONENT) -
          LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_BETA)
    )
    {
      uu____2 =
        (
          KRML_CLITERAL(core_result_Result_41){
            .tag = core_result_Err,
            .f0 = libcrux_ml_dsa_types_VerificationError_SignerResponseExceedsBoundError
          }
        );
    }
    else
    {
      Eurydice_arr_46 matrix;
      Eurydice_arr_a4 repeat_expression[56U];
      for (size_t i = (size_t)0U; i < (size_t)56U; i++)
      {
        repeat_expression[i] = libcrux_ml_dsa_polynomial_zero_ff_37();
      }
      memcpy(matrix.data, repeat_expression, (size_t)56U * sizeof (Eurydice_arr_a4));
      libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
        seed_for_a,
        Eurydice_array_to_slice_mut_717(&matrix));
      Eurydice_arr_060 verification_key_hash = { .data = { 0U } };
      libcrux_ml_dsa_hash_functions_portable_shake256_61_24(Eurydice_array_to_slice_shared_f7(verification_key),
        &verification_key_hash);
      Eurydice_arr_060 message_representative = { .data = { 0U } };
      libcrux_ml_dsa_ml_dsa_generic_derive_message_representative_43(Eurydice_array_to_slice_shared_d8(&verification_key_hash),
        &domain_separation_context,
        message,
        &message_representative);
      Eurydice_arr_a4 verifier_challenge = libcrux_ml_dsa_polynomial_zero_ff_37();
      sample_challenge_ring_element_2e(Eurydice_array_to_slice_shared_d8(&deserialized_commitment_hash),
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ONES_IN_VERIFIER_CHALLENGE,
        &verifier_challenge);
      libcrux_ml_dsa_ntt_ntt_37(&verifier_challenge);
      KRML_MAYBE_FOR7(i,
        (size_t)0U,
        (size_t)7U,
        (size_t)1U,
        size_t i0 = i;
        libcrux_ml_dsa_ntt_ntt_37(&deserialized_signer_response.data[i0]););
      libcrux_ml_dsa_matrix_compute_w_approx_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_ROWS_IN_A,
        LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_COLUMNS_IN_A,
        Eurydice_array_to_slice_shared_718(&matrix),
        Eurydice_array_to_slice_shared_716(&deserialized_signer_response),
        &verifier_challenge,
        Eurydice_array_to_slice_mut_71(&t1));
      Eurydice_arr_060 recomputed_commitment_hash = { .data = { 0U } };
      libcrux_ml_dsa_arithmetic_use_hint_37(LIBCRUX_ML_DSA_CONSTANTS_ML_DSA_87_GAMMA2,
        Eurydice_array_to_slice_shared_6d1(&deserialized_hint),
        Eurydice_array_to_slice_mut_71(&t1));
      Eurydice_arr_9e commitment_serialized = { .data = { 0U } };
      libcrux_ml_dsa_encoding_commitment_serialize_vector_37(LIBCRUX_ML_DSA_ML_DSA_GENERIC_ML_DSA_87_COMMITMENT_RING_ELEMENT_SIZE,
        Eurydice_array_to_slice_shared_710(&t1),
        Eurydice_array_to_slice_mut_fd(&commitment_serialized));
      libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
      shake = libcrux_ml_dsa_hash_functions_portable_init_26();
      libcrux_ml_dsa_hash_functions_portable_absorb_26(&shake,
        Eurydice_array_to_slice_shared_d8(&message_representative));
      libcrux_ml_dsa_hash_functions_portable_absorb_final_26(&shake,
        Eurydice_array_to_slice_shared_fd(&commitment_serialized));
      libcrux_ml_dsa_hash_functions_portable_squeeze_26(&shake,
        Eurydice_array_to_slice_mut_d8(&recomputed_commitment_hash));
      if
      (
        Eurydice_array_eq((size_t)64U,
          &deserialized_commitment_hash,
          &recomputed_commitment_hash,
          uint8_t)
      )
      {
        uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Ok });
      }
      else
      {
        uu____2 =
          (
            KRML_CLITERAL(core_result_Result_41){
              .tag = core_result_Err,
              .f0 = libcrux_ml_dsa_types_VerificationError_CommitmentHashesDontMatchError
            }
          );
      }
    }
  }
  else
  {
    libcrux_ml_dsa_types_VerificationError e = uu____1.f0;
    uu____2 = (KRML_CLITERAL(core_result_Result_41){ .tag = core_result_Err, .f0 = e });
  }
  return uu____2;
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_5a1(
  const Eurydice_arr_51 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature_serialized
)
{
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (KRML_CLITERAL(core_option_Option_b5){ .tag = core_option_None }));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a1(verification_key_serialized,
      message,
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
)
{
  return verify_5a1(verification_key, message, context, signature);
}

/**
A monomorphic instance of libcrux_ml_dsa.ml_dsa_generic.ml_dsa_87.verify_pre_hashed
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients, libcrux_ml_dsa_samplex4_portable_PortableSampler, libcrux_ml_dsa_hash_functions_portable_Shake128, libcrux_ml_dsa_hash_functions_portable_Shake128X4, libcrux_ml_dsa_hash_functions_portable_Shake256, libcrux_ml_dsa_hash_functions_portable_Shake256Xof, libcrux_ml_dsa_pre_hash_SHAKE128_PH
with const generics

*/
static KRML_MUSTINLINE core_result_Result_41
verify_pre_hashed_3f1(
  const Eurydice_arr_51 *verification_key_serialized,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature_serialized
)
{
  libcrux_ml_dsa_pre_hash_hash_30_83(message, pre_hash_buffer);
  core_result_Result_a8
  uu____0 =
    libcrux_ml_dsa_pre_hash_new_88(context,
      (
        KRML_CLITERAL(core_option_Option_b5){
          .tag = core_option_Some,
          .f0 = libcrux_ml_dsa_pre_hash_oid_30()
        }
      ));
  if (!(uu____0.tag == core_result_Ok))
  {
    return
      (
        KRML_CLITERAL(core_result_Result_41){
          .tag = core_result_Err,
          .f0 = libcrux_ml_dsa_types_VerificationError_VerificationContextTooLongError
        }
      );
  }
  libcrux_ml_dsa_pre_hash_DomainSeparationContext dsc = uu____0.val.case_Ok;
  libcrux_ml_dsa_pre_hash_DomainSeparationContext domain_separation_context = dsc;
  return
    verify_internal_5a1(verification_key_serialized,
      (
        KRML_CLITERAL(Eurydice_borrow_slice_u8){
          .ptr = pre_hash_buffer.ptr,
          .meta = pre_hash_buffer.meta
        }
      ),
      (
        KRML_CLITERAL(core_option_Option_84){
          .tag = core_option_Some,
          .f0 = domain_separation_context
        }
      ),
      signature_serialized);
}

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
)
{
  return verify_pre_hashed_3f1(verification_key, message, context, pre_hash_buffer, signature);
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_mldsa_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mldsa_portable_H
#define libcrux_mldsa_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_sha3_internal.h"
#include "libcrux_mldsa_core.h"

typedef struct libcrux_ml_dsa_hash_functions_portable_Shake128X4_s
{
  Eurydice_arr_26 state0;
  Eurydice_arr_26 state1;
  Eurydice_arr_26 state2;
  Eurydice_arr_26 state3;
}
libcrux_ml_dsa_hash_functions_portable_Shake128X4;

typedef libcrux_sha3_portable_KeccakState libcrux_ml_dsa_hash_functions_portable_Shake256;

typedef struct libcrux_ml_dsa_hash_functions_portable_Shake256X4_s
{
  Eurydice_arr_26 state0;
  Eurydice_arr_26 state1;
  Eurydice_arr_26 state2;
  Eurydice_arr_26 state3;
}
libcrux_ml_dsa_hash_functions_portable_Shake256X4;

typedef libcrux_sha3_portable_incremental_Shake256Xof
libcrux_ml_dsa_hash_functions_portable_Shake256Xof;

libcrux_ml_dsa_hash_functions_portable_Shake128X4
libcrux_ml_dsa_hash_functions_portable_init_absorb(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

Eurydice_arr_26
libcrux_ml_dsa_hash_functions_portable_init_absorb_final_shake256(
  Eurydice_borrow_slice_u8 input
);

libcrux_ml_dsa_hash_functions_portable_Shake256X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_x4(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

void
libcrux_ml_dsa_hash_functions_portable_shake128(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 out
);

Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_shake256(Eurydice_arr_26 *state);

Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *state
);

void
libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *state,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
);

Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *state
);

Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_shake256(Eurydice_arr_26 *state);

Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *state
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::Xof for libcrux_ml_dsa::hash_functions::portable::Shake128}
*/
void
libcrux_ml_dsa_hash_functions_portable_shake128_7b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
libcrux_ml_dsa_hash_functions_portable_Shake128X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_11(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
void
libcrux_ml_dsa_hash_functions_portable_squeeze_first_five_blocks_11(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *self,
  Eurydice_arr_12 *out0,
  Eurydice_arr_12 *out1,
  Eurydice_arr_12 *out2,
  Eurydice_arr_12 *out3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake128::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake128X4}
*/
Eurydice_arr_27_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_11(
  libcrux_ml_dsa_hash_functions_portable_Shake128X4 *self
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
Eurydice_arr_26
libcrux_ml_dsa_hash_functions_portable_init_absorb_final_61(Eurydice_borrow_slice_u8 input);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_61(Eurydice_arr_26 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
Eurydice_arr_3d
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_61(Eurydice_arr_26 *self);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_absorb_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_absorb_final_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_borrow_slice_u8 input
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
libcrux_ml_dsa_hash_functions_portable_init_26(void);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::Xof for libcrux_ml_dsa::hash_functions::portable::Shake256Xof}
*/
void
libcrux_ml_dsa_hash_functions_portable_squeeze_26(
  libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
libcrux_ml_dsa_hash_functions_portable_Shake256X4
libcrux_ml_dsa_hash_functions_portable_init_absorb_x4_9b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_first_block_x4_9b(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *self
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
Eurydice_arr_3d_x4
libcrux_ml_dsa_hash_functions_portable_squeeze_next_block_x4_9b(
  libcrux_ml_dsa_hash_functions_portable_Shake256X4 *self
);

/**
This function found in impl {libcrux_ml_dsa::samplex4::X4Sampler for libcrux_ml_dsa::samplex4::portable::PortableSampler}
*/
/**
A monomorphic instance of libcrux_ml_dsa.samplex4.portable.matrix_flat_a8
with types libcrux_ml_dsa_simd_portable_vector_type_Coefficients
with const generics

*/
void
libcrux_ml_dsa_samplex4_portable_matrix_flat_a8_37(
  size_t columns,
  Eurydice_borrow_slice_u8 seed,
  Eurydice_dst_ref_mut_e7 matrix
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 64
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 64
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_61_24(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_060 *out
);

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_18 *signing_key,
  Eurydice_arr_40 *verification_key
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 576
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_x4_9b
with const generics
- OUT_LEN= 576
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_1b(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_5f0 *out0,
  Eurydice_arr_5f0 *out1,
  Eurydice_arr_5f0 *out2,
  Eurydice_arr_5f0 *out3
);

/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256
with const generics
- OUTPUT_LENGTH= 640
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::XofX4 for libcrux_ml_dsa::hash_functions::portable::Shake256X4}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_x4_9b
with const generics
- OUT_LEN= 640
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_x4_9b_c8(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_arr_c30 *out0,
  Eurydice_arr_c30 *out1,
  Eurydice_arr_c30 *out2,
  Eurydice_arr_c30 *out3
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 640
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_61_c8(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_c30 *out
);

/**
This function found in impl {libcrux_ml_dsa::hash_functions::shake256::DsaXof for libcrux_ml_dsa::hash_functions::portable::Shake256}
*/
/**
A monomorphic instance of libcrux_ml_dsa.hash_functions.portable.shake256_61
with const generics
- OUTPUT_LENGTH= 576
*/
void
libcrux_ml_dsa_hash_functions_portable_shake256_61_1b(
  Eurydice_borrow_slice_u8 input,
  Eurydice_arr_5f0 *out
);

/**
 Sign.
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_mut(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_400 *signature
);

/**
 Sign (pre-hashed).
*/
core_result_Result_48
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_sign_pre_hashed_shake128(
  const Eurydice_arr_18 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_400 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_44_verify_pre_hashed_shake128(
  const Eurydice_arr_40 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_400 *signature
);

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_d1 *signing_key,
  Eurydice_arr_4a *verification_key
);

/**
 Sign.
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_mut(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_96 *signature
);

/**
 Sign (pre-hashed).
*/
core_result_Result_8c
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_sign_pre_hashed_shake128(
  const Eurydice_arr_d1 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_96 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_65_verify_pre_hashed_shake128(
  const Eurydice_arr_4a *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_96 *signature
);

/**
 Generate key pair.
*/
void
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_generate_key_pair(
  Eurydice_arr_60 randomness,
  Eurydice_arr_180 *signing_key,
  Eurydice_arr_51 *verification_key
);

/**
 Sign.
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness
);

/**
 Sign.
*/
core_result_Result_53
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_mut(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_arr_60 randomness,
  Eurydice_arr_38 *signature
);

/**
 Sign (pre-hashed).
*/
core_result_Result_8b
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_sign_pre_hashed_shake128(
  const Eurydice_arr_180 *signing_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  Eurydice_arr_60 randomness
);

/**
 Verify.
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  const Eurydice_arr_38 *signature
);

/**
 Verify (pre-hashed with SHAKE-128).
*/
core_result_Result_41
libcrux_ml_dsa_ml_dsa_generic_instantiations_portable_ml_dsa_87_verify_pre_hashed_shake128(
  const Eurydice_arr_51 *verification_key,
  Eurydice_borrow_slice_u8 message,
  Eurydice_borrow_slice_u8 context,
  Eurydice_mut_borrow_slice_u8 pre_hash_buffer,
  const Eurydice_arr_38 *signature
);

#if defined(__cplusplus)
}
#endif

#define libcrux_mldsa_portable_H_DEFINED
#endif /* libcrux_mldsa_portable_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_sha3.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_H
#define libcrux_sha3_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_sha3_internal.h"
#include "libcrux_mldsa_core.h"

/**
 A portable SHAKE128 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_shake128(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_c6(data, digest);
}

/**
 A portable SHAKE256 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_shake256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_ad(data, digest);
}

/**
 A portable SHA3 224 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_sha224(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_1e(data, digest);
}

/**
 A portable SHA3 256 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_sha256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_ad0(data, digest);
}

/**
 A portable SHA3 384 implementation.
*/
static KRML_MUSTINLINE void
libcrux_sha3_portable_sha384(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_7c(data, digest);
}

/**
 SHA3 224

 Preconditions:
 - `digest.len() == 28`
*/
static inline void
libcrux_sha3_sha224_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha224(digest, payload);
}

/**
 SHA3 224
*/
static inline Eurydice_arr_f1 libcrux_sha3_sha224(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_f1 out = { .data = { 0U } };
  libcrux_sha3_sha224_ema(Eurydice_array_to_slice_mut_c0(&out), data);
  return out;
}

/**
 SHA3 256
*/
static inline void
libcrux_sha3_sha256_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha256(digest, payload);
}

/**
 SHA3 256
*/
static inline Eurydice_arr_60 libcrux_sha3_sha256(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_60 out = { .data = { 0U } };
  libcrux_sha3_sha256_ema(Eurydice_array_to_slice_mut_6e(&out), data);
  return out;
}

/**
 SHA3 384
*/
static inline void
libcrux_sha3_sha384_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha384(digest, payload);
}

/**
 SHA3 384
*/
static inline Eurydice_arr_5f libcrux_sha3_sha384(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_5f out = { .data = { 0U } };
  libcrux_sha3_sha384_ema(Eurydice_array_to_slice_mut_95(&out), data);
  return out;
}

/**
 SHAKE 128

 Writes `out.len()` bytes.
*/
static inline void
libcrux_sha3_shake128_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake128(out, data);
}

/**
 SHAKE 256

 Writes `out.len()` bytes.
*/
static inline void
libcrux_sha3_shake256_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake256(out, data);
}

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_H_DEFINED
#endif /* libcrux_sha3_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_sha3_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_sha3_avx2.h"

#include "libcrux_sha3_internal.h"
#include "libcrux_mldsa_core.h"
#include "internal/libcrux_mldsa_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i zero_b0(void)
{
  return mm256_set1_epi64x((int64_t)0LL);
}

static KRML_MUSTINLINE __m256i
_veor5q_u64(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  __m256i ab = mm256_xor_si256(a, b);
  __m256i cd = mm256_xor_si256(c, d);
  __m256i abcd = mm256_xor_si256(ab, cd);
  return mm256_xor_si256(abcd, e);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor5_b0(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  return _veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i rotate_left_76(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)1, x, __m256i),
      mm256_srli_epi64((int32_t)63, x, __m256i));
}

static KRML_MUSTINLINE __m256i _vrax1q_u64(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, rotate_left_76(b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i rotate_left1_and_xor_b0(__m256i a, __m256i b)
{
  return _vrax1q_u64(a, b);
}

static KRML_MUSTINLINE __m256i _vbcaxq_u64(__m256i a, __m256i b, __m256i c)
{
  return mm256_xor_si256(a, mm256_andnot_si256(c, b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i and_not_xor_b0(__m256i a, __m256i b, __m256i c)
{
  return _vbcaxq_u64(a, b, c);
}

static KRML_MUSTINLINE __m256i _veorq_n_u64(__m256i a, uint64_t c)
{
  __m256i c0 = mm256_set1_epi64x((int64_t)c);
  return mm256_xor_si256(a, c0);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_constant_b0(__m256i a, uint64_t c)
{
  return _veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_b0(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE Eurydice_arr_05 libcrux_sha3_generic_keccak_new_80_a6(void)
{
  Eurydice_arr_05 lit;
  __m256i repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = zero_b0();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (__m256i));
  return lit;
}

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_05 libcrux_sha3_avx2_x4_incremental_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_a6();
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_traits_set_ij_a6(Eurydice_arr_05 *arr, size_t i, size_t j, __m256i value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE const
__m256i
*libcrux_sha3_traits_get_ij_a6(const Eurydice_arr_05 *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
load_block_3a(Eurydice_arr_05 *state, const Eurydice_arr_cd *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256((int32_t)32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256((int32_t)32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256((int32_t)49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256((int32_t)49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    libcrux_sha3_traits_set_ij_a6(state,
      i0,
      j0,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i0, j0)[0U], v0));
    libcrux_sha3_traits_set_ij_a6(state,
      i1,
      j1,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i1, j1)[0U], v1));
    libcrux_sha3_traits_set_ij_a6(state,
      i2,
      j2,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i2, j2)[0U], v2));
    libcrux_sha3_traits_set_ij_a6(state,
      i3,
      j3,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)168U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)168U / (size_t)32U);
  Eurydice_arr_60 u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)168U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)168U / (size_t)32U) % (size_t)5U;
  libcrux_sha3_traits_set_ij_a6(state,
    i0,
    j0,
    mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_60 u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    libcrux_sha3_traits_set_ij_a6(state,
      i,
      j,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_c6(Eurydice_arr_05 *state, const Eurydice_arr_cd *blocks, size_t start, size_t len)
{
  Eurydice_arr_b3
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_361(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_shared_7e(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)168U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_cd
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_shared_7b(buffers.data),
        Eurydice_array_to_slice_shared_7b(&buffers.data[1U]),
        Eurydice_array_to_slice_shared_7b(&buffers.data[2U]),
        Eurydice_array_to_slice_shared_7b(&buffers.data[3U])
      }
    };
  load_block_3a(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 168
- DELIMITER= 31
*/
static void
load_last_8f_c6(Eurydice_arr_05 *self, const Eurydice_arr_cd *input, size_t start, size_t len)
{
  load_last_c6(self, input, start, len);
}

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
const
__m256i
*libcrux_sha3_generic_keccak_index_c2_a6(const Eurydice_arr_05 *self, size_t_x2 index)
{
  return libcrux_sha3_traits_get_ij_a6(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE Eurydice_arr_c0 libcrux_sha3_generic_keccak_theta_80_a6(Eurydice_arr_05 *self)
{
  Eurydice_arr_c0
  c =
    {
      .data = {
        xor5_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        xor5_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        xor5_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        xor5_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        xor5_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(Eurydice_arr_c0){
        .data = {
          rotate_left1_and_xor_b0(c.data[((size_t)0U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)1U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)2U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)3U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)4U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
void
libcrux_sha3_generic_keccak_set_80_a6(Eurydice_arr_05 *self, size_t i, size_t j, __m256i v)
{
  libcrux_sha3_traits_set_ij_a6(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i rotate_left_02(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)36, x, __m256i),
      mm256_srli_epi64((int32_t)28, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_02(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_02(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_02(__m256i a, __m256i b)
{
  return _vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i rotate_left_ac(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)3, x, __m256i),
      mm256_srli_epi64((int32_t)61, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ac(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ac(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ac(__m256i a, __m256i b)
{
  return _vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i rotate_left_020(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)41, x, __m256i),
      mm256_srli_epi64((int32_t)23, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_020(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_020(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_020(__m256i a, __m256i b)
{
  return _vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i rotate_left_a9(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)18, x, __m256i),
      mm256_srli_epi64((int32_t)46, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_a9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_a9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_a9(__m256i a, __m256i b)
{
  return _vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_0_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)0U,
    xor_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)0U,
    xor_and_rotate_b0_02(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)0U,
    xor_and_rotate_b0_ac(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)0U,
    xor_and_rotate_b0_020(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)0U,
    xor_and_rotate_b0_a9(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_76(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_76(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_76(__m256i a, __m256i b)
{
  return _vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i rotate_left_58(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)44, x, __m256i),
      mm256_srli_epi64((int32_t)20, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_58(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_58(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_58(__m256i a, __m256i b)
{
  return _vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i rotate_left_e0(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)10, x, __m256i),
      mm256_srli_epi64((int32_t)54, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_e0(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_e0(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_e0(__m256i a, __m256i b)
{
  return _vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i rotate_left_63(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)45, x, __m256i),
      mm256_srli_epi64((int32_t)19, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_63(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_63(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_63(__m256i a, __m256i b)
{
  return _vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i rotate_left_6a(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)2, x, __m256i),
      mm256_srli_epi64((int32_t)62, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6a(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6a(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6a(__m256i a, __m256i b)
{
  return _vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_1_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)1U,
    xor_and_rotate_b0_76(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)1U,
    xor_and_rotate_b0_58(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)1U,
    xor_and_rotate_b0_e0(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)1U,
    xor_and_rotate_b0_63(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)1U,
    xor_and_rotate_b0_6a(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i rotate_left_ab(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)62, x, __m256i),
      mm256_srli_epi64((int32_t)2, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ab(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ab(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ab(__m256i a, __m256i b)
{
  return _vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i rotate_left_5b(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)6, x, __m256i),
      mm256_srli_epi64((int32_t)58, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_5b(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_5b(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_5b(__m256i a, __m256i b)
{
  return _vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i rotate_left_6f(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)43, x, __m256i),
      mm256_srli_epi64((int32_t)21, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6f(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6f(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6f(__m256i a, __m256i b)
{
  return _vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i rotate_left_62(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)15, x, __m256i),
      mm256_srli_epi64((int32_t)49, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_62(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_62(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_62(__m256i a, __m256i b)
{
  return _vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i rotate_left_23(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)61, x, __m256i),
      mm256_srli_epi64((int32_t)3, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_23(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_23(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_23(__m256i a, __m256i b)
{
  return _vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_2_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)2U,
    xor_and_rotate_b0_ab(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)2U,
    xor_and_rotate_b0_5b(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)2U,
    xor_and_rotate_b0_6f(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)2U,
    xor_and_rotate_b0_62(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)2U,
    xor_and_rotate_b0_23(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i rotate_left_37(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)28, x, __m256i),
      mm256_srli_epi64((int32_t)36, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_37(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_37(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_37(__m256i a, __m256i b)
{
  return _vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i rotate_left_bb(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)55, x, __m256i),
      mm256_srli_epi64((int32_t)9, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_bb(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_bb(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_bb(__m256i a, __m256i b)
{
  return _vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i rotate_left_b9(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)25, x, __m256i),
      mm256_srli_epi64((int32_t)39, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_b9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_b9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_b9(__m256i a, __m256i b)
{
  return _vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i rotate_left_54(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)21, x, __m256i),
      mm256_srli_epi64((int32_t)43, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_54(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_54(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_54(__m256i a, __m256i b)
{
  return _vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i rotate_left_4c(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)56, x, __m256i),
      mm256_srli_epi64((int32_t)8, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_4c(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_4c(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_4c(__m256i a, __m256i b)
{
  return _vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_3_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)3U,
    xor_and_rotate_b0_37(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)3U,
    xor_and_rotate_b0_bb(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)3U,
    xor_and_rotate_b0_b9(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)3U,
    xor_and_rotate_b0_54(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)3U,
    xor_and_rotate_b0_4c(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i rotate_left_ce(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)27, x, __m256i),
      mm256_srli_epi64((int32_t)37, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ce(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ce(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ce(__m256i a, __m256i b)
{
  return _vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i rotate_left_77(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)20, x, __m256i),
      mm256_srli_epi64((int32_t)44, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_77(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_77(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_77(__m256i a, __m256i b)
{
  return _vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i rotate_left_25(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)39, x, __m256i),
      mm256_srli_epi64((int32_t)25, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_25(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_25(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_25(__m256i a, __m256i b)
{
  return _vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i rotate_left_af(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)8, x, __m256i),
      mm256_srli_epi64((int32_t)56, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_af(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_af(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_af(__m256i a, __m256i b)
{
  return _vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i rotate_left_fd(__m256i x)
{
  return
    mm256_xor_si256(mm256_slli_epi64((int32_t)14, x, __m256i),
      mm256_srli_epi64((int32_t)50, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_fd(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_fd(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_fd(__m256i a, __m256i b)
{
  return _vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_4_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)4U,
    xor_and_rotate_b0_ce(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)4U,
    xor_and_rotate_b0_77(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)4U,
    xor_and_rotate_b0_25(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)4U,
    xor_and_rotate_b0_af(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)4U,
    xor_and_rotate_b0_fd(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_80_a6(Eurydice_arr_05 *self, Eurydice_arr_c0 t)
{
  libcrux_sha3_generic_keccak_rho_0_80_a6(self, t);
  libcrux_sha3_generic_keccak_rho_1_80_a6(self, t);
  libcrux_sha3_generic_keccak_rho_2_80_a6(self, t);
  libcrux_sha3_generic_keccak_rho_3_80_a6(self, t);
  libcrux_sha3_generic_keccak_rho_4_80_a6(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_0_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_1_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_2_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_3_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_4_80_a6(Eurydice_arr_05 *self, Eurydice_arr_05 old)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_a6(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_pi_80_a6(Eurydice_arr_05 *self)
{
  Eurydice_arr_05 old = self[0U];
  libcrux_sha3_generic_keccak_pi_0_80_a6(self, old);
  libcrux_sha3_generic_keccak_pi_1_80_a6(self, old);
  libcrux_sha3_generic_keccak_pi_2_80_a6(self, old);
  libcrux_sha3_generic_keccak_pi_3_80_a6(self, old);
  libcrux_sha3_generic_keccak_pi_4_80_a6(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_chi_80_a6(Eurydice_arr_05 *self)
{
  Eurydice_arr_05 old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      libcrux_sha3_generic_keccak_set_80_a6(self,
        i1,
        j,
        and_not_xor_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_a6(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_iota_80_a6(Eurydice_arr_05 *self, size_t i)
{
  libcrux_sha3_generic_keccak_set_80_a6(self,
    (size_t)0U,
    (size_t)0U,
    xor_constant_b0(libcrux_sha3_generic_keccak_index_c2_a6(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_keccakf1600_80_a6(Eurydice_arr_05 *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_arr_c0 t = libcrux_sha3_generic_keccak_theta_80_a6(self);
    libcrux_sha3_generic_keccak_rho_80_a6(self, t);
    libcrux_sha3_generic_keccak_pi_80_a6(self);
    libcrux_sha3_generic_keccak_chi_80_a6(self);
    libcrux_sha3_generic_keccak_iota_80_a6(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 168
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_fb(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start,
  size_t len
)
{
  load_last_8f_c6(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
}

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_05 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_cd lvalue = { .data = { data0, data1, data2, data3 } };
  libcrux_sha3_generic_keccak_absorb_final_80_fb(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
load_block_5b(Eurydice_arr_05 *state, const Eurydice_arr_cd *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_7e(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256((int32_t)32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256((int32_t)32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256((int32_t)49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256((int32_t)49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    libcrux_sha3_traits_set_ij_a6(state,
      i0,
      j0,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i0, j0)[0U], v0));
    libcrux_sha3_traits_set_ij_a6(state,
      i1,
      j1,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i1, j1)[0U], v1));
    libcrux_sha3_traits_set_ij_a6(state,
      i2,
      j2,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i2, j2)[0U], v2));
    libcrux_sha3_traits_set_ij_a6(state,
      i3,
      j3,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)136U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)136U / (size_t)32U);
  Eurydice_arr_60 u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_shared_7e(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)136U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)136U / (size_t)32U) % (size_t)5U;
  libcrux_sha3_traits_set_ij_a6(state,
    i0,
    j0,
    mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_60 u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_364(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_shared_7e(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    libcrux_sha3_traits_set_ij_a6(state,
      i,
      j,
      mm256_xor_si256(libcrux_sha3_traits_get_ij_a6(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_ad(Eurydice_arr_05 *state, const Eurydice_arr_cd *blocks, size_t start, size_t len)
{
  Eurydice_arr_1a
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_362(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_shared_7e(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)136U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_cd
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_shared_d4(buffers.data),
        Eurydice_array_to_slice_shared_d4(&buffers.data[1U]),
        Eurydice_array_to_slice_shared_d4(&buffers.data[2U]),
        Eurydice_array_to_slice_shared_d4(&buffers.data[3U])
      }
    };
  load_block_5b(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 136
- DELIMITER= 31
*/
static void
load_last_8f_ad(Eurydice_arr_05 *self, const Eurydice_arr_cd *input, size_t start, size_t len)
{
  load_last_ad(self, input, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_fb0(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start,
  size_t len
)
{
  load_last_8f_ad(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
}

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_05 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_cd lvalue = { .data = { data0, data1, data2, data3 } };
  libcrux_sha3_generic_keccak_absorb_final_80_fb0(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
store_block_5b(
  const Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_60 u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_6e(&u8s);
          mm256_storeu_si256_u8(uu____1, libcrux_sha3_traits_get_ij_a6(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_6e(&u8s);
          mm256_storeu_si256_u8(uu____2, libcrux_sha3_traits_get_ij_a6(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l =
      mm256_permute2x128_si256((int32_t)32,
        libcrux_sha3_traits_get_ij_a6(s, i0, j0)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i2, j2)[0U],
        __m256i);
    __m256i
    v1h =
      mm256_permute2x128_si256((int32_t)32,
        libcrux_sha3_traits_get_ij_a6(s, i1, j1)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i3, j3)[0U],
        __m256i);
    __m256i
    v2l =
      mm256_permute2x128_si256((int32_t)49,
        libcrux_sha3_traits_get_ij_a6(s, i0, j0)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i2, j2)[0U],
        __m256i);
    __m256i
    v3h =
      mm256_permute2x128_si256((int32_t)49,
        libcrux_sha3_traits_get_ij_a6(s, i1, j1)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i3, j3)[0U],
        __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 136
*/
static void
squeeze4_17_5b(
  const Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_5b(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block_8f
with const generics
- RATE= 136
*/
static void load_block_8f_5b(Eurydice_arr_05 *self, const Eurydice_arr_cd *input, size_t start)
{
  load_block_5b(self, input, start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_97(
  Eurydice_arr_05 *self,
  const Eurydice_arr_cd *input,
  size_t start
)
{
  load_block_8f_5b(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.keccak4
with const generics
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
keccak4_ad(
  const Eurydice_arr_cd *data,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  Eurydice_arr_05 s = libcrux_sha3_generic_keccak_new_80_a6();
  size_t data_len = data->data->meta;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = data_len / (size_t)136U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = data_len % (size_t)136U;
      libcrux_sha3_generic_keccak_absorb_final_80_fb0(&s, data, data_len - rem, rem);
      size_t outlen = out0.meta;
      size_t blocks = outlen / (size_t)136U;
      size_t last = outlen - outlen % (size_t)136U;
      if (blocks == (size_t)0U)
      {
        squeeze4_17_5b(&s, out0, out1, out2, out3, (size_t)0U, outlen);
      }
      else
      {
        squeeze4_17_5b(&s, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_a6(&s);
          squeeze4_17_5b(&s, out0, out1, out2, out3, i0 * (size_t)136U, (size_t)136U);
        }
        if (last < outlen)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_a6(&s);
          squeeze4_17_5b(&s, out0, out1, out2, out3, last, outlen - last);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    libcrux_sha3_generic_keccak_absorb_block_80_97(&s, data, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_cd lvalue = { .data = { input0, input1, input2, input3 } };
  keccak4_ad(&lvalue, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_first_block_81_5b(
  const Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_5b(self, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
}

/**
 Squeeze block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_block_81_5b(&s[0U], out0, out1, out2, out3);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
store_block_3a(
  const Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_60 u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_6e(&u8s);
          mm256_storeu_si256_u8(uu____1, libcrux_sha3_traits_get_ij_a6(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_6e(&u8s);
          mm256_storeu_si256_u8(uu____2, libcrux_sha3_traits_get_ij_a6(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_36(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_08){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l =
      mm256_permute2x128_si256((int32_t)32,
        libcrux_sha3_traits_get_ij_a6(s, i0, j0)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i2, j2)[0U],
        __m256i);
    __m256i
    v1h =
      mm256_permute2x128_si256((int32_t)32,
        libcrux_sha3_traits_get_ij_a6(s, i1, j1)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i3, j3)[0U],
        __m256i);
    __m256i
    v2l =
      mm256_permute2x128_si256((int32_t)49,
        libcrux_sha3_traits_get_ij_a6(s, i0, j0)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i2, j2)[0U],
        __m256i);
    __m256i
    v3h =
      mm256_permute2x128_si256((int32_t)49,
        libcrux_sha3_traits_get_ij_a6(s, i1, j1)[0U],
        libcrux_sha3_traits_get_ij_a6(s, i3, j3)[0U],
        __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_7e(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_08){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 168
*/
static void
squeeze4_17_3a(
  const Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_3a(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_five_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_five_blocks_81_3a(
  Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)3U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_five_blocks_81_3a(s, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_3a(
  Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, start, (size_t)168U);
}

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_3a(s, out0, out1, out2, out3, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_5b(
  Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_5b(self, out0, out1, out2, out3, start, (size_t)136U);
}

/**
 Squeeze next block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_5b(s, out0, out1, out2, out3, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_three_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_three_blocks_81_3a(
  Eurydice_arr_05 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_a6(self);
  squeeze4_17_3a(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_three_blocks_81_3a(s, out0, out1, out2, out3);
}



================================================
FILE: out/test-libcrux-ml-dsa/libcrux_sha3_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_avx2_H
#define libcrux_sha3_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_05_s { __m256i data[25U]; } Eurydice_arr_05;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types core_core_arch_x86___m256i
with const generics
- $4size_t
*/
typedef Eurydice_arr_05 libcrux_sha3_generic_keccak_KeccakState_55;

typedef libcrux_sha3_generic_keccak_KeccakState_55
libcrux_sha3_avx2_x4_incremental_KeccakState;

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_05 libcrux_sha3_avx2_x4_incremental_init(void);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_05 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_05 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
);

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze five blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze next block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze three blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_05 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_avx2_H_DEFINED
#endif /* libcrux_sha3_avx2_H */


================================================
FILE: out/test-libcrux-ml-dsa/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_internal_H
#define libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_mldsa_core.h"

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types uint64_t
with const generics
- $1size_t
*/
typedef Eurydice_arr_26 libcrux_sha3_generic_keccak_KeccakState_17;

typedef libcrux_sha3_generic_keccak_KeccakState_17 libcrux_sha3_portable_KeccakState;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $136size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_e2_s
{
  Eurydice_arr_26 inner;
  Eurydice_arr_3e buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_e2;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_e2
libcrux_sha3_portable_incremental_Shake256Xof;

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_zero_d2(void)
{
  return 0ULL;
}

static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__veor5q_u64(
  uint64_t a,
  uint64_t b,
  uint64_t c,
  uint64_t d,
  uint64_t e
)
{
  return (((a ^ b) ^ c) ^ d) ^ e;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor5_d2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e)
{
  return libcrux_sha3_simd_portable__veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_76(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)1);
}

static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, uint64_t b)
{
  return a ^ libcrux_sha3_simd_portable_rotate_left_76(b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vrax1q_u64(a, b);
}

static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, uint64_t b, uint64_t c)
{
  return a ^ (b & ~c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, uint64_t b, uint64_t c)
{
  return libcrux_sha3_simd_portable__vbcaxq_u64(a, b, c);
}

static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, uint64_t c)
{
  return a ^ c;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c)
{
  return libcrux_sha3_simd_portable__veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_xor_d2(uint64_t a, uint64_t b)
{
  return a ^ b;
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE Eurydice_arr_26 libcrux_sha3_generic_keccak_new_80_04(void)
{
  Eurydice_arr_26 lit;
  uint64_t repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = libcrux_sha3_simd_portable_zero_d2();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (uint64_t));
  return lit;
}

#define LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS ((KRML_CLITERAL(Eurydice_arr_a7){ .data = { 1ULL, 32898ULL, 9223372036854808714ULL, 9223372039002292224ULL, 32907ULL, 2147483649ULL, 9223372039002292353ULL, 9223372036854808585ULL, 138ULL, 136ULL, 2147516425ULL, 2147483658ULL, 2147516555ULL, 9223372036854775947ULL, 9223372036854808713ULL, 9223372036854808579ULL, 9223372036854808578ULL, 9223372036854775936ULL, 32778ULL, 9223372039002259466ULL, 9223372039002292353ULL, 9223372036854808704ULL, 2147483649ULL, 9223372039002292232ULL } }))

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE const
uint64_t
*libcrux_sha3_traits_get_ij_04(const Eurydice_arr_26 *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_traits_set_ij_04(Eurydice_arr_26 *arr, size_t i, size_t j, uint64_t value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_3a(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_26 state_flat = { .data = { 0U } };
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = (size_t)168U / (size_t)8U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_04(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_7e(blocks,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_c6(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_27 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_361(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)168U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_3a(state,
    Eurydice_array_to_slice_shared_7b(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 168
- DELIMITER= 31
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_c6(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_c6(self, input->data[0U], start, len);
}

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types uint64_t
with const generics
- N= 1
*/
static inline const
uint64_t
*libcrux_sha3_generic_keccak_index_c2_04(const Eurydice_arr_26 *self, size_t_x2 index)
{
  return libcrux_sha3_traits_get_ij_04(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE Eurydice_arr_a5
libcrux_sha3_generic_keccak_theta_80_04(Eurydice_arr_26 *self)
{
  Eurydice_arr_a5
  c =
    {
      .data = {
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(Eurydice_arr_a5){
        .data = {
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)0U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)1U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)2U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)3U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)4U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types uint64_t
with const generics
- N= 1
*/
static inline void
libcrux_sha3_generic_keccak_set_80_04(Eurydice_arr_26 *self, size_t i, size_t j, uint64_t v)
{
  libcrux_sha3_traits_set_ij_04(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_02(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)36);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_02(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)3);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ac(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_020(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)41);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_020(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)18);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_a9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_0_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_02(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_020(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_76(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_58(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)44);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_58(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)10);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_e0(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_63(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)45);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_63(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)2);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6a(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_1_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_76(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_58(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_63(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)62);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ab(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)6);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_5b(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)43);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6f(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_62(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)15);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_62(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_23(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)61);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_23(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_2_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_62(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_23(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_37(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)28);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_37(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)55);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_bb(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)25);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_b9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_54(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)21);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_54(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)56);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_4c(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_3_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_37(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_54(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)27);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ce(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_77(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)20);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_77(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_25(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)39);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_25(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_af(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)8);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_af(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)(int32_t)14);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_fd(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_4_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_77(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_25(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_af(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_80_04(Eurydice_arr_26 *self, Eurydice_arr_a5 t)
{
  libcrux_sha3_generic_keccak_rho_0_80_04(self, t);
  libcrux_sha3_generic_keccak_rho_1_80_04(self, t);
  libcrux_sha3_generic_keccak_rho_2_80_04(self, t);
  libcrux_sha3_generic_keccak_rho_3_80_04(self, t);
  libcrux_sha3_generic_keccak_rho_4_80_04(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_0_80_04(Eurydice_arr_26 *self, Eurydice_arr_26 old)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_1_80_04(Eurydice_arr_26 *self, Eurydice_arr_26 old)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_2_80_04(Eurydice_arr_26 *self, Eurydice_arr_26 old)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_3_80_04(Eurydice_arr_26 *self, Eurydice_arr_26 old)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_4_80_04(Eurydice_arr_26 *self, Eurydice_arr_26 old)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_04(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void libcrux_sha3_generic_keccak_pi_80_04(Eurydice_arr_26 *self)
{
  Eurydice_arr_26 old = self[0U];
  libcrux_sha3_generic_keccak_pi_0_80_04(self, old);
  libcrux_sha3_generic_keccak_pi_1_80_04(self, old);
  libcrux_sha3_generic_keccak_pi_2_80_04(self, old);
  libcrux_sha3_generic_keccak_pi_3_80_04(self, old);
  libcrux_sha3_generic_keccak_pi_4_80_04(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void libcrux_sha3_generic_keccak_chi_80_04(Eurydice_arr_26 *self)
{
  Eurydice_arr_26 old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      libcrux_sha3_generic_keccak_set_80_04(self,
        i1,
        j,
        libcrux_sha3_simd_portable_and_not_xor_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_04(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_iota_80_04(Eurydice_arr_26 *self, size_t i)
{
  libcrux_sha3_generic_keccak_set_80_04(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_constant_d2(libcrux_sha3_generic_keccak_index_c2_04(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types uint64_t
with const generics
- N= 1
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_keccakf1600_80_04(Eurydice_arr_26 *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_arr_a5 t = libcrux_sha3_generic_keccak_theta_80_04(self);
    libcrux_sha3_generic_keccak_rho_80_04(self, t);
    libcrux_sha3_generic_keccak_pi_80_04(self);
    libcrux_sha3_generic_keccak_chi_80_04(self);
    libcrux_sha3_generic_keccak_iota_80_04(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
- DELIM= 31
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_c6(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_5b(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_26 state_flat = { .data = { 0U } };
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = (size_t)136U / (size_t)8U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_04(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_7e(blocks,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_ad(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_3d buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_362(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_5b(state,
    Eurydice_array_to_slice_shared_d4(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 31
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_ad(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_ad(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e0(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_ad(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_5b(
  const Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_41(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_6e(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 136
*/
static inline void
libcrux_sha3_simd_portable_squeeze_9b_5b(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_5b(self, out, start, len);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_3a(
  const Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_41(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_6e(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 168
*/
static inline void
libcrux_sha3_simd_portable_squeeze_9b_3a(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_3a(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 136
*/
static inline void
libcrux_sha3_simd_portable_load_block_a1_5b(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_5b(self, input->data[0U], start);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 104
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_7a(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_26 state_flat = { .data = { 0U } };
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = (size_t)104U / (size_t)8U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)104U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_04(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_7e(blocks,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 104
- DELIMITER= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_7c(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_181 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_366(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)104U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_7a(state,
    Eurydice_array_to_slice_shared_9c(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 104
- DELIMITER= 6
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_7c(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_7c(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
- DELIM= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e4(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_7c(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 104
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_7a(
  const Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_41(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_6e(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 104
*/
static inline void
libcrux_sha3_simd_portable_squeeze_9b_7a(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_7a(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 104
*/
static inline void
libcrux_sha3_simd_portable_load_block_a1_7a(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_7a(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_c63(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_7a(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 104
- DELIM= 6
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_7c(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)104U;
  size_t input_rem = input_len % (size_t)104U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e4(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)104U;
      size_t output_rem = output_len % (size_t)104U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_7a(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_7a(&s, output, (size_t)0U, (size_t)104U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_7a(&s, output, i0 * (size_t)104U, (size_t)104U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_7a(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c63(&s, &lvalue, i * (size_t)104U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_ad0(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_3d buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_362(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_5b(state,
    Eurydice_array_to_slice_shared_d4(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 6
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_ad0(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_ad0(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e3(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_ad0(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_c61(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_5b(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 6
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_ad0(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e3(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c61(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 144
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_2c(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_26 state_flat = { .data = { 0U } };
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){
          .start = (size_t)0U,
          .end = (size_t)144U / (size_t)8U
        }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)144U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_04(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_7e(blocks,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_ab((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 144
- DELIMITER= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_1e(
  Eurydice_arr_26 *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_a8 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_365(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_7e(blocks,
      (KRML_CLITERAL(core_ops_range_Range_08){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)144U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_2c(state,
    Eurydice_array_to_slice_shared_d1(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 144
- DELIMITER= 6
*/
static inline void
libcrux_sha3_simd_portable_load_last_a1_1e(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_1e(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
- DELIM= 6
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_9e2(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_1e(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 144
*/
static KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_2c(
  const Eurydice_arr_26 *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_41(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_04(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_7e(out,
        (KRML_CLITERAL(core_ops_range_Range_08){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_6e(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 144
*/
static inline void
libcrux_sha3_simd_portable_squeeze_9b_2c(
  const Eurydice_arr_26 *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_2c(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 144
*/
static inline void
libcrux_sha3_simd_portable_load_block_a1_2c(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_2c(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_c62(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_2c(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 144
- DELIM= 6
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_1e(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)144U;
  size_t input_rem = input_len % (size_t)144U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e2(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)144U;
      size_t output_rem = output_len % (size_t)144U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_2c(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_2c(&s, output, (size_t)0U, (size_t)144U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_2c(&s, output, i0 * (size_t)144U, (size_t)144U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_2c(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c62(&s, &lvalue, i * (size_t)144U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 31
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_ad(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e0(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_5b(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c61(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 168
*/
static inline void
libcrux_sha3_simd_portable_load_block_a1_3a(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_3a(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
*/
static KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_c60(
  Eurydice_arr_26 *self,
  const Eurydice_arr_06 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_3a(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_04(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 168
- DELIM= 31
*/
static inline void
libcrux_sha3_generic_keccak_portable_keccak1_c6(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_26 s = libcrux_sha3_generic_keccak_new_80_04();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)168U;
  size_t input_rem = input_len % (size_t)168U;
  core_ops_range_Range_08
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_08){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_08,
      size_t,
      core_ops_range_Range_08);
  while (true)
  {
    core_option_Option_08
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_08);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_06 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_9e(&s, &lvalue, input_len - input_rem, input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)168U;
      size_t output_rem = output_len % (size_t)168U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_3a(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_3a(&s, output, (size_t)0U, (size_t)168U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_3a(&s, output, i0 * (size_t)168U, (size_t)168U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_04(&s);
          libcrux_sha3_simd_portable_squeeze_9b_3a(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_06 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_c60(&s, &lvalue, i * (size_t)168U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_internal_H_DEFINED
#endif /* libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_core_H
#define internal_libcrux_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "../libcrux_core.h"

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_87_tags;

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_87_tags tag;
  size_t f0;
}
core_option_Option_87;

static inline uint64_t core_num__u64__from_le_bytes(Eurydice_array_u8x8 x0);

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1);

static inline Eurydice_array_u8x8 core_num__u64__to_le_bytes(uint64_t x0);

static inline uint32_t core_num__u8__count_ones(uint8_t x0);

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

uint8_t
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(
  Eurydice_borrow_slice_u8 lhs,
  Eurydice_borrow_slice_u8 rhs
);

Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(
  Eurydice_borrow_slice_u8 lhs,
  Eurydice_borrow_slice_u8 rhs,
  uint8_t selector
);

Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(
  Eurydice_borrow_slice_u8 lhs_c,
  Eurydice_borrow_slice_u8 rhs_c,
  Eurydice_borrow_slice_u8 lhs_s,
  Eurydice_borrow_slice_u8 rhs_s
);

#define LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE ((size_t)32U)

/**
 K * BITS_PER_RING_ELEMENT / 8

 [eurydice] Note that we can't use const generics here because that breaks
            C extraction with eurydice.
*/
size_t libcrux_ml_kem_constants_ranked_bytes_per_ring_element(size_t rank);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_declassify_d8_39(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint8_t libcrux_secrets_int_as_u8_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_classify_27_39(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u8}
*/
int16_t libcrux_secrets_int_as_i16_59(uint8_t self);

int16_t libcrux_secrets_int_I16(int16_t v);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int32_t libcrux_secrets_int_as_i32_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i32}
*/
int16_t libcrux_secrets_int_as_i16_36(int32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int32_t libcrux_secrets_int_as_i32_b8(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint16_t libcrux_secrets_int_as_u16_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
int16_t libcrux_secrets_int_as_i16_ca(uint16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
uint64_t libcrux_secrets_int_as_u64_ca(uint16_t self);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint32_t

*/
uint32_t libcrux_secrets_int_public_integers_classify_27_df(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u64}
*/
uint32_t libcrux_secrets_int_as_u32_a3(uint64_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int16_t libcrux_secrets_int_as_i16_b8(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int16_t libcrux_secrets_int_as_i16_f5(int16_t self);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_default_d3_0e(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_212(const Eurydice_arr_d1 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d49(const Eurydice_arr_a8 *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_51_d9(Eurydice_arr_d1 value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_types_from_17_70(Eurydice_arr_a8 sk, Eurydice_arr_d1 pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_from_b2_0e(Eurydice_arr_a8 value);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1536size_t
*/
typedef struct Eurydice_arr_df_s { uint8_t data[1536U]; } Eurydice_arr_df;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_2f(const Eurydice_arr_df *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d420(Eurydice_arr_a8 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2f(Eurydice_arr_df *a);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_19_d9(Eurydice_arr_d1 value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1568
*/
const Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_e6_d9(const Eurydice_arr_d1 *self);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1568
*/
const Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_a9_d9(const Eurydice_arr_d1 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f6(Eurydice_arr_d1 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d419(Eurydice_arr_d1 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $352size_t
*/
typedef struct Eurydice_arr_e7_s { uint8_t data[352U]; } Eurydice_arr_e7;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d418(Eurydice_arr_e7 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 352
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_25(const Eurydice_arr_e7 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $128size_t
*/
typedef struct Eurydice_arr_89_s { uint8_t data[128U]; } Eurydice_arr_89;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_3b0_s { Eurydice_arr_89 data[4U]; } Eurydice_arr_3b0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $33size_t
*/
typedef struct Eurydice_arr_fa_s { uint8_t data[33U]; } Eurydice_arr_fa;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_890_s { Eurydice_arr_fa data[4U]; } Eurydice_arr_890;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 4
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_23(Eurydice_arr_890 *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $272size_t
*/
typedef struct Eurydice_arr_5b_s { int16_t data[272U]; } Eurydice_arr_5b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_24_s { Eurydice_arr_5b data[4U]; } Eurydice_arr_24;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cc_s { size_t data[4U]; } Eurydice_arr_cc;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $504size_t
*/
typedef struct Eurydice_arr_79_s { uint8_t data[504U]; } Eurydice_arr_79;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_7c0_s { Eurydice_arr_79 data[4U]; } Eurydice_arr_7c0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $34size_t
*/
typedef struct Eurydice_arr_31_s { uint8_t data[34U]; } Eurydice_arr_31;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_56_s { Eurydice_arr_31 data[4U]; } Eurydice_arr_56;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1600size_t
*/
typedef struct Eurydice_arr_14_s { uint8_t data[1600U]; } Eurydice_arr_14;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1600
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_720(const Eurydice_arr_14 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_b50(const Eurydice_arr_d1 *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1568
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_d9(const Eurydice_arr_d1 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f5(Eurydice_arr_14 *a, size_t r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1600
*/
Eurydice_arr_14 libcrux_ml_kem_utils_into_padded_array_49(Eurydice_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f4(const Eurydice_arr_d1 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d48(const Eurydice_arr_d1 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 3168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_68(const Eurydice_arr_a8 *a);

typedef struct Eurydice_borrow_slice_u8_x4_s
{
  Eurydice_borrow_slice_u8 fst;
  Eurydice_borrow_slice_u8 snd;
  Eurydice_borrow_slice_u8 thd;
  Eurydice_borrow_slice_u8 f3;
}
Eurydice_borrow_slice_u8_x4;

typedef struct Eurydice_borrow_slice_u8_x2_s
{
  Eurydice_borrow_slice_u8 fst;
  Eurydice_borrow_slice_u8 snd;
}
Eurydice_borrow_slice_u8_x2;

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_borrow_slice_u8 private_key);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_default_d3_79(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f3(const Eurydice_arr_5f *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_211(const Eurydice_arr_5f *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d47(const Eurydice_arr_7d *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f libcrux_ml_kem_types_from_51_3d(Eurydice_arr_5f value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_types_from_17_bc(Eurydice_arr_7d sk, Eurydice_arr_5f pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_from_b2_79(Eurydice_arr_7d value);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1152size_t
*/
typedef struct Eurydice_arr_0e_s { uint8_t data[1152U]; } Eurydice_arr_0e;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_f4(const Eurydice_arr_0e *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d416(Eurydice_arr_7d *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f4(Eurydice_arr_0e *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f4(Eurydice_arr_5f *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d415(Eurydice_arr_5f *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b libcrux_ml_kem_types_from_19_52(Eurydice_arr_2b value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1184
*/
const Eurydice_arr_5f *libcrux_ml_kem_types_as_slice_e6_3d(const Eurydice_arr_5f *self);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ff(const Eurydice_arr_5f *a);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1088
*/
const Eurydice_arr_2b *libcrux_ml_kem_types_as_slice_a9_52(const Eurydice_arr_2b *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f3(Eurydice_arr_2b *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d414(Eurydice_arr_2b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_58_s { Eurydice_arr_89 data[3U]; } Eurydice_arr_58;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_801_s { Eurydice_arr_fa data[3U]; } Eurydice_arr_801;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 3
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_78(Eurydice_arr_801 *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_2c_s { Eurydice_arr_c5 data[3U]; } Eurydice_arr_2c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_b1_s { Eurydice_arr_5b data[3U]; } Eurydice_arr_b1;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_eb0_s { size_t data[3U]; } Eurydice_arr_eb0;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_7e_s { Eurydice_arr_79 data[3U]; } Eurydice_arr_7e;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_81_s { Eurydice_arr_31 data[3U]; } Eurydice_arr_81;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1120size_t
*/
typedef struct Eurydice_arr_af_s { uint8_t data[1120U]; } Eurydice_arr_af;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1120
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_81(const Eurydice_arr_af *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_06(const Eurydice_arr_2b *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1088
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_52(const Eurydice_arr_2b *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f2(Eurydice_arr_af *a, size_t r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1120
*/
Eurydice_arr_af libcrux_ml_kem_utils_into_padded_array_66(Eurydice_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f2(const Eurydice_arr_2b *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d46(const Eurydice_arr_2b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2400
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_51(const Eurydice_arr_7d *a);

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_64(Eurydice_borrow_slice_u8 private_key);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d44(Eurydice_arr_ec *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 32
*/
Eurydice_arr_ec libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_borrow_slice_u8 slice);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_default_d3_be(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f1(const Eurydice_arr_03 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_210(const Eurydice_arr_03 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d45(const Eurydice_arr_ab0 *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 800
*/
Eurydice_arr_03 libcrux_ml_kem_types_from_51_df(Eurydice_arr_03 value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_types_from_17_d6(Eurydice_arr_ab0 sk, Eurydice_arr_03 pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_from_b2_be(Eurydice_arr_ab0 value);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d412(Eurydice_arr_ab0 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_27(Eurydice_arr_d2 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 24
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ed(const Eurydice_arr_94 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $384size_t
*/
typedef struct Eurydice_arr_b20_s { uint8_t data[384U]; } Eurydice_arr_b20;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d411(Eurydice_arr_b20 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 384
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_a9(const Eurydice_arr_b20 *a);

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_07_tags;

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_ec, core_array_TryFromSliceError

*/
typedef struct core_result_Result_07_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_ec case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_07;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$32size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_ec core_result_unwrap_26_39(core_result_Result_07 self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f0(const Eurydice_arr_c7 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d44(const Eurydice_arr_c7 *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 libcrux_ml_kem_types_from_19_80(Eurydice_arr_d2 value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 800
*/
const Eurydice_arr_03 *libcrux_ml_kem_types_as_slice_e6_df(const Eurydice_arr_03 *self);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 768
*/
const Eurydice_arr_d2 *libcrux_ml_kem_types_as_slice_a9_80(const Eurydice_arr_d2 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f1(Eurydice_arr_d2 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 10
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_30(const Eurydice_arr_6d *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d410(Eurydice_arr_d2 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 22
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_98(const Eurydice_arr_80 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 20
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_8f(const Eurydice_arr_fc *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $320size_t
*/
typedef struct Eurydice_arr_b0_s { uint8_t data[320U]; } Eurydice_arr_b0;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d49(Eurydice_arr_b0 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 320
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_56(const Eurydice_arr_b0 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 128
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_78(const Eurydice_arr_89 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_f3_s { Eurydice_arr_89 data[2U]; } Eurydice_arr_f3;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_78(Eurydice_arr_89 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $192size_t
*/
typedef struct Eurydice_arr_1c_s { uint8_t data[192U]; } Eurydice_arr_1c;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 192
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d9(const Eurydice_arr_1c *a);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_04_s { int16_t data[256U]; } Eurydice_arr_04;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int16_t
with const generics
- N= 256
*/
Eurydice_borrow_slice_i16 Eurydice_array_to_slice_shared_990(const Eurydice_arr_04 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_1c
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_eb_s { Eurydice_arr_1c data[2U]; } Eurydice_arr_eb;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 192
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d9(Eurydice_arr_1c *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 33
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_b5(const Eurydice_arr_fa *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_4d_s { Eurydice_arr_fa data[2U]; } Eurydice_arr_4d;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 2
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_af(Eurydice_arr_4d *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d48(Eurydice_arr_fa *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 33
*/
Eurydice_arr_fa libcrux_ml_kem_utils_into_padded_array_29(Eurydice_borrow_slice_u8 slice);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 34
*/
Eurydice_arr_31 libcrux_ml_kem_utils_into_padded_array_de(Eurydice_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_borrow_slice_i16
Eurydice_array_to_subslice_shared_e70(const Eurydice_arr_5b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d43(const Eurydice_arr_c5 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_5b0_s { Eurydice_arr_c5 data[2U]; } Eurydice_arr_5b0;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2c(Eurydice_arr_c5 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_800_s { Eurydice_arr_5b data[2U]; } Eurydice_arr_800;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_85_s { size_t data[2U]; } Eurydice_arr_85;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e7(Eurydice_arr_5b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 504
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d42(const Eurydice_arr_79 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_b8_s { Eurydice_arr_79 data[2U]; } Eurydice_arr_b8;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_48(Eurydice_arr_79 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_bf_s { Eurydice_arr_31 data[2U]; } Eurydice_arr_bf;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 34
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e9(const Eurydice_arr_31 *a);

/**
A monomorphic instance of Eurydice.slice_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_from_shared_6d(Eurydice_borrow_slice_u8 s, size_t r);

/**
A monomorphic instance of Eurydice.slice_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_to_shared_72(Eurydice_borrow_slice_u8 s, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_3b(const Eurydice_arr_03 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_27(const Eurydice_arr_d2 *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 768
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_80(const Eurydice_arr_d2 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f0(Eurydice_arr_03 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d46(Eurydice_arr_03 *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 800
*/
Eurydice_arr_03 libcrux_ml_kem_utils_into_padded_array_df(Eurydice_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_17(const Eurydice_arr_c7 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f(Eurydice_arr_c7 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_01(const Eurydice_arr_ec *a);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 64
*/
Eurydice_arr_c7 libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_82(const Eurydice_array_u8x2 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f(const Eurydice_arr_d2 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d41(const Eurydice_arr_d2 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1632
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_99(const Eurydice_arr_ab0 *a);

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_borrow_slice_u8 private_key);

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_mut_borrow_slice_i16
Eurydice_slice_subslice_mut_a6(Eurydice_mut_borrow_slice_i16 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_29(const Eurydice_arr_b2 *a);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_94, core_array_TryFromSliceError

*/
typedef struct core_result_Result_57_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_94 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_57;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$24size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_94 core_result_unwrap_26_78(core_result_Result_57 self);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int16_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_i16 Eurydice_array_to_slice_shared_8a(const Eurydice_arr_d6 *a);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_fc, core_array_TryFromSliceError

*/
typedef struct core_result_Result_83_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_fc case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_83;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$20size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_fc core_result_unwrap_26_7d(core_result_Result_83 self);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_6d, core_array_TryFromSliceError

*/
typedef struct core_result_Result_80_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_6d case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_80;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$10size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_6d core_result_unwrap_26_63(core_result_Result_80 self);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d40(const Eurydice_arr_b2 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_29(Eurydice_arr_b2 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_8a(Eurydice_arr_d6 *a);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$24size_t]]

*/
Eurydice_arr_94 libcrux_secrets_int_public_integers_declassify_d8_40(Eurydice_arr_94 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$20size_t]]

*/
Eurydice_arr_fc libcrux_secrets_int_public_integers_declassify_d8_2b(Eurydice_arr_fc self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$10size_t]]

*/
Eurydice_arr_6d libcrux_secrets_int_public_integers_declassify_d8_37(Eurydice_arr_6d self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$8size_t]]

*/
Eurydice_array_u8x8
libcrux_secrets_int_public_integers_declassify_d8_52(Eurydice_array_u8x8 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$2size_t]]

*/
Eurydice_array_u8x2
libcrux_secrets_int_public_integers_declassify_d8_75(Eurydice_array_u8x2 self);

/**
 Classify a mutable slice (identity)
 We define a separate function for this because hax has limited support for &mut-returning functions
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_mut_slice
with types Eurydice_dst_ref_mut uint8_t size_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_public_integers_classify_mut_slice_75(Eurydice_mut_borrow_slice_u8 x);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_classify_27_4b(Eurydice_arr_d6 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_declassify_d8_4b(Eurydice_arr_d6 self);

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types uint8_t

*/
Eurydice_borrow_slice_u8
libcrux_secrets_int_classify_public_classify_ref_6d_90(Eurydice_borrow_slice_u8 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$22size_t]]

*/
Eurydice_arr_80 libcrux_secrets_int_public_integers_declassify_d8_0b(Eurydice_arr_80 self);

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_i16
Eurydice_array_to_subslice_shared_e7(const Eurydice_arr_d6 *a, core_ops_range_Range_87 r);

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types int16_t

*/
Eurydice_borrow_slice_i16
libcrux_secrets_int_classify_public_classify_ref_6d_39(Eurydice_borrow_slice_i16 self);

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_borrow_slice_i16
Eurydice_slice_subslice_shared_a6(Eurydice_borrow_slice_i16 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_d6, core_array_TryFromSliceError

*/
typedef struct core_result_Result_ec_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_d6 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_ec;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr int16_t[[$16size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_d6 core_result_unwrap_26_d3(core_result_Result_ec self);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $128size_t
*/
typedef struct Eurydice_arr_34_s { int16_t data[128U]; } Eurydice_arr_34;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_9c_s { Eurydice_arr_c5 data[4U]; } Eurydice_arr_9c;

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d4(const Eurydice_arr_ec *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ff
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_dc0_s { Eurydice_arr_ff data[4U]; } Eurydice_arr_dc0;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_borrow_slice_u8
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_68_s { Eurydice_borrow_slice_u8 data[4U]; } Eurydice_arr_68;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_17(Eurydice_arr_c7 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_9f(Eurydice_arr_65 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_01(Eurydice_arr_ec *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5e(Eurydice_arr_a2 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $104size_t
*/
typedef struct Eurydice_arr_c4_s { uint8_t data[104U]; } Eurydice_arr_c4;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 104
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_72(const Eurydice_arr_c4 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d43(Eurydice_arr_c4 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $144size_t
*/
typedef struct Eurydice_arr_f4_s { uint8_t data[144U]; } Eurydice_arr_f4;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 144
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_38(const Eurydice_arr_f4 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d42(Eurydice_arr_f4 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_2c(const Eurydice_arr_c5 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d41(Eurydice_arr_c5 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_58(const Eurydice_arr_ff *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d40(Eurydice_arr_ff *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_21(const Eurydice_array_u8x8 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_6e(const Eurydice_array_u8x8 *a);

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_c8(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $72size_t
*/
typedef struct Eurydice_arr_ab_s { uint8_t data[72U]; } Eurydice_arr_ab;

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 72
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e2(const Eurydice_arr_ab *a);

/**
A monomorphic instance of core.result.Result
with types Eurydice_array_u8x8, core_array_TryFromSliceError

*/
typedef struct core_result_Result_8e_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_array_u8x8 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_8e;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_e0(core_result_Result_8e self);

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_shared_c8(Eurydice_borrow_slice_u8 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d4(Eurydice_arr_ab *a, core_ops_range_Range_87 r);

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair768_s
{
  Eurydice_arr_0e fst;
  Eurydice_arr_5f snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair768;

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair512_s
{
  Eurydice_arr_d2 fst;
  Eurydice_arr_03 snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair512;

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair1024_s
{
  Eurydice_arr_df fst;
  Eurydice_arr_d1 snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair1024;

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_core_H_DEFINED
#endif /* internal_libcrux_core_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem1024_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem1024_avx2_H
#define internal_libcrux_mlkem1024_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem1024_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_d1 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem1024_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem1024_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem1024_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem1024_portable_H
#define internal_libcrux_mlkem1024_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem1024_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_d1 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem1024_portable_H_DEFINED
#endif /* internal_libcrux_mlkem1024_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem512_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem512_avx2_H
#define internal_libcrux_mlkem512_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem512_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_03 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem512_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem512_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem512_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem512_portable_H
#define internal_libcrux_mlkem512_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem512_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_03 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem512_portable_H_DEFINED
#endif /* internal_libcrux_mlkem512_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem768_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem768_avx2_H
#define internal_libcrux_mlkem768_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem768_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_public_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *pk
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem768_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem768_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem768_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem768_portable_H
#define internal_libcrux_mlkem768_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem768_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_public_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *pk
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem768_portable_H_DEFINED
#endif /* internal_libcrux_mlkem768_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem_avx2_H
#define internal_libcrux_mlkem_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"
#include "../libcrux_mlkem_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_13_s { __m256i data[16U]; } Eurydice_arr_13;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_60_s { Eurydice_arr_13 data[3U]; } Eurydice_arr_60;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_60
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_ea_s { Eurydice_arr_60 data[3U]; } Eurydice_arr_ea;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef_s
{
  Eurydice_arr_60 t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_ea A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef_s
{
  Eurydice_arr_60 ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef;

typedef struct libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef public_key;
}
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
const
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_default_30_e3(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_e3(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_79(const Eurydice_arr_5f *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_a4(const Eurydice_arr_7d *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d50(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db1(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_a11(
  const Eurydice_arr_5f *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_661(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_3b_s { Eurydice_arr_13 data[4U]; } Eurydice_arr_3b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_3b
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cd_s { Eurydice_arr_3b data[4U]; } Eurydice_arr_cd;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4_s
{
  Eurydice_arr_3b t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_cd A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4_s
{
  Eurydice_arr_3b ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4;

typedef struct libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 public_key;
}
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_ind_cca_unpacked_default_30_5b(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_5b(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_74(const Eurydice_arr_d1 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_f8(const Eurydice_arr_a8 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_b3(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db0(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_a10(
  const Eurydice_arr_d1 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_660(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_ee_s { Eurydice_arr_13 data[2U]; } Eurydice_arr_ee;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ee
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_e2_s { Eurydice_arr_ee data[2U]; } Eurydice_arr_e2;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7_s
{
  Eurydice_arr_ee t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_e2 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7_s
{
  Eurydice_arr_ee ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7;

typedef struct libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 public_key;
}
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_ind_cca_unpacked_default_30_16(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_16(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_ce(const Eurydice_arr_03 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_37(const Eurydice_arr_ab0 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_85(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_db(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_a1(
  const Eurydice_arr_03 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_66(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_mlkem_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem_portable_H
#define internal_libcrux_mlkem_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_core.h"
#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem_portable.h"

int16_t libcrux_ml_kem_polynomial_zeta(size_t i);

#define LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT ((size_t)16U)

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_9e_s { Eurydice_arr_d6 data[16U]; } Eurydice_arr_9e;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_d20_s { Eurydice_arr_9e data[4U]; } Eurydice_arr_d20;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_d20
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_600_s { Eurydice_arr_d20 data[4U]; } Eurydice_arr_600;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94_s
{
  Eurydice_arr_d20 t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_600 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 4
*/
Eurydice_arr_4a
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(
  const Eurydice_arr_56 *input
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 4
*/
Eurydice_arr_7c0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(
  Eurydice_arr_4a *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 4
*/
Eurydice_arr_9c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(Eurydice_arr_4a *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94_s
{
  Eurydice_arr_d20 ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94;

typedef struct libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 public_key;
}
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_ind_cca_unpacked_default_30_ee(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_ee(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_1c(const Eurydice_arr_d1 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_4c(const Eurydice_arr_a8 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_79(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b81(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_991(
  const Eurydice_arr_d1 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd1(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_1e_s { Eurydice_arr_9e data[2U]; } Eurydice_arr_1e;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_1e
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_df0_s { Eurydice_arr_1e data[2U]; } Eurydice_arr_df0;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b_s
{
  Eurydice_arr_1e t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_df0 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 2
*/
Eurydice_arr_e3
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(
  const Eurydice_arr_bf *input
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 2
*/
Eurydice_arr_b8
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(
  Eurydice_arr_e3 *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 2
*/
Eurydice_arr_5b0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(Eurydice_arr_e3 *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b_s
{
  Eurydice_arr_1e ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b;

typedef struct libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b public_key;
}
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_ind_cca_unpacked_default_30_66(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_66(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_53(const Eurydice_arr_03 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_e2(const Eurydice_arr_ab0 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d5(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_b80(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_990(
  const Eurydice_arr_03 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd0(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_bb_s { Eurydice_arr_9e data[3U]; } Eurydice_arr_bb;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_bb
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_1d_s { Eurydice_arr_bb data[3U]; } Eurydice_arr_1d;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51_s
{
  Eurydice_arr_bb t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_1d A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 3
*/
Eurydice_arr_1b
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(
  const Eurydice_arr_81 *input
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 3
*/
Eurydice_arr_7e
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(
  Eurydice_arr_1b *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 3
*/
Eurydice_arr_2c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(Eurydice_arr_1b *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51_s
{
  Eurydice_arr_bb ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51;

typedef struct libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 public_key;
}
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
const
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_default_30_68(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_68(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  const Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_b6(const Eurydice_arr_5f *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_52(const Eurydice_arr_7d *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_ba(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b8(const Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_99(
  const Eurydice_arr_5f *public_key,
  const Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem_portable_H_DEFINED
#endif /* internal_libcrux_mlkem_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/internal/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_sha3_internal_H
#define internal_libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"
#include "../libcrux_sha3_internal.h"

typedef Eurydice_arr_60 libcrux_sha3_Sha3_256Digest;

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_sha3_internal_H_DEFINED
#endif /* internal_libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_core.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_core.h"

/**
 Return 1 if `value` is not zero and 0 otherwise.
*/
static KRML_NOINLINE uint8_t inz(uint8_t value)
{
  uint16_t value0 = (uint16_t)value;
  uint8_t result = (uint8_t)((uint32_t)core_num__u16__wrapping_add(~value0, 1U) >> 8U);
  return (uint32_t)result & 1U;
}

static KRML_NOINLINE uint8_t is_non_zero(uint8_t value)
{
  return inz(value);
}

/**
 Return 1 if the bytes of `lhs` and `rhs` do not exactly
 match and 0 otherwise.
*/
static KRML_NOINLINE uint8_t
compare(Eurydice_borrow_slice_u8 lhs, Eurydice_borrow_slice_u8 rhs)
{
  uint8_t r = 0U;
  for (size_t i = (size_t)0U; i < lhs.meta; i++)
  {
    size_t i0 = i;
    uint8_t nr = (uint32_t)r | ((uint32_t)lhs.ptr[i0] ^ (uint32_t)rhs.ptr[i0]);
    r = nr;
  }
  return is_non_zero(r);
}

KRML_NOINLINE uint8_t
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(
  Eurydice_borrow_slice_u8 lhs,
  Eurydice_borrow_slice_u8 rhs
)
{
  return compare(lhs, rhs);
}

/**
 If `selector` is not zero, return the bytes in `rhs`; return the bytes in
 `lhs` otherwise.
*/
static KRML_NOINLINE Eurydice_arr_ec
select_ct(Eurydice_borrow_slice_u8 lhs, Eurydice_borrow_slice_u8 rhs, uint8_t selector)
{
  uint8_t mask = core_num__u8__wrapping_sub(is_non_zero(selector), 1U);
  Eurydice_arr_ec out = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE; i++)
  {
    size_t i0 = i;
    uint8_t
    outi =
      ((uint32_t)lhs.ptr[i0] & (uint32_t)mask) | ((uint32_t)rhs.ptr[i0] & (~(uint32_t)mask & 0xFFU));
    out.data[i0] = outi;
  }
  return out;
}

KRML_NOINLINE Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(
  Eurydice_borrow_slice_u8 lhs,
  Eurydice_borrow_slice_u8 rhs,
  uint8_t selector
)
{
  return select_ct(lhs, rhs, selector);
}

KRML_NOINLINE Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(
  Eurydice_borrow_slice_u8 lhs_c,
  Eurydice_borrow_slice_u8 rhs_c,
  Eurydice_borrow_slice_u8 lhs_s,
  Eurydice_borrow_slice_u8 rhs_s
)
{
  uint8_t
  selector = libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(lhs_c, rhs_c);
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(lhs_s,
      rhs_s,
      selector);
}

/**
 K * BITS_PER_RING_ELEMENT / 8

 [eurydice] Note that we can't use const generics here because that breaks
            C extraction with eurydice.
*/
size_t libcrux_ml_kem_constants_ranked_bytes_per_ring_element(size_t rank)
{
  return rank * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U;
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint8_t

*/
static KRML_MUSTINLINE uint8_t classify_27_90(uint8_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_declassify_d8_39(int16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint8_t libcrux_secrets_int_as_u8_f5(int16_t self)
{
  return classify_27_90((uint8_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_classify_27_39(int16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint8_t

*/
static KRML_MUSTINLINE uint8_t declassify_d8_90(uint8_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u8}
*/
int16_t libcrux_secrets_int_as_i16_59(uint8_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_90(self));
}

/**
 Construct a public integer (identity)
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.secret
with types int16_t

*/
static KRML_MUSTINLINE int16_t secret_39(int16_t x)
{
  return x;
}

int16_t libcrux_secrets_int_I16(int16_t v)
{
  return secret_39(v);
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int32_t

*/
static KRML_MUSTINLINE int32_t classify_27_a8(int32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int32_t libcrux_secrets_int_as_i32_f5(int16_t self)
{
  return classify_27_a8((int32_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int32_t

*/
static KRML_MUSTINLINE int32_t declassify_d8_a8(int32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i32}
*/
int16_t libcrux_secrets_int_as_i16_36(int32_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_a8(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint32_t

*/
static KRML_MUSTINLINE uint32_t declassify_d8_df(uint32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int32_t libcrux_secrets_int_as_i32_b8(uint32_t self)
{
  return classify_27_a8((int32_t)declassify_d8_df(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint16_t

*/
static KRML_MUSTINLINE uint16_t classify_27_de(uint16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint16_t libcrux_secrets_int_as_u16_f5(int16_t self)
{
  return classify_27_de((uint16_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint16_t

*/
static KRML_MUSTINLINE uint16_t declassify_d8_de(uint16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
int16_t libcrux_secrets_int_as_i16_ca(uint16_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_de(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint64_t

*/
static KRML_MUSTINLINE uint64_t classify_27_49(uint64_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
uint64_t libcrux_secrets_int_as_u64_ca(uint16_t self)
{
  return classify_27_49((uint64_t)declassify_d8_de(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint32_t

*/
uint32_t libcrux_secrets_int_public_integers_classify_27_df(uint32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint64_t

*/
static KRML_MUSTINLINE uint64_t declassify_d8_49(uint64_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u64}
*/
uint32_t libcrux_secrets_int_as_u32_a3(uint64_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_df((uint32_t)declassify_d8_49(self));
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int16_t libcrux_secrets_int_as_i16_b8(uint32_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_df(self));
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int16_t libcrux_secrets_int_as_i16_f5(int16_t self)
{
  return
    libcrux_secrets_int_public_integers_classify_27_39(libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_default_d3_0e(void)
{
  return (KRML_CLITERAL(Eurydice_arr_a8){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_212(const Eurydice_arr_d1 *a, size_t r)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d49(const Eurydice_arr_a8 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_51_d9(Eurydice_arr_d1 value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_types_from_17_70(Eurydice_arr_a8 sk, Eurydice_arr_d1 pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_mlkem1024_MlKem1024KeyPair){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_from_b2_0e(Eurydice_arr_a8 value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_2f(const Eurydice_arr_df *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1536U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d420(Eurydice_arr_a8 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2f(Eurydice_arr_df *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1536U;
  return lit;
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_19_d9(Eurydice_arr_d1 value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1568
*/
const Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_e6_d9(const Eurydice_arr_d1 *self)
{
  return self;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1568
*/
const Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_a9_d9(const Eurydice_arr_d1 *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f6(Eurydice_arr_d1 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1568U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d419(Eurydice_arr_d1 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d418(Eurydice_arr_e7 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 352
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_25(const Eurydice_arr_e7 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)352U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 4
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_23(Eurydice_arr_890 *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1600
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_720(const Eurydice_arr_14 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1600U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_b50(const Eurydice_arr_d1 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1568U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1568
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_d9(const Eurydice_arr_d1 *self)
{
  return Eurydice_array_to_slice_shared_b50(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f5(Eurydice_arr_14 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1600U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d417(Eurydice_arr_14 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1600
*/
Eurydice_arr_14 libcrux_ml_kem_utils_into_padded_array_49(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_14 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d417(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f4(const Eurydice_arr_d1 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1568U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d48(const Eurydice_arr_d1 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 3168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_68(const Eurydice_arr_a8 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)3168U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_borrow_slice_u8 private_key)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)1536U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)1568U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_default_d3_79(void)
{
  return (KRML_CLITERAL(Eurydice_arr_7d){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f3(const Eurydice_arr_5f *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1184U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_211(const Eurydice_arr_5f *a, size_t r)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d47(const Eurydice_arr_7d *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f libcrux_ml_kem_types_from_51_3d(Eurydice_arr_5f value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_types_from_17_bc(Eurydice_arr_7d sk, Eurydice_arr_5f pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_mlkem768_MlKem768KeyPair){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_from_b2_79(Eurydice_arr_7d value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_f4(const Eurydice_arr_0e *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1152U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d416(Eurydice_arr_7d *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f4(Eurydice_arr_0e *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1152U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f4(Eurydice_arr_5f *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1184U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d415(Eurydice_arr_5f *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b libcrux_ml_kem_types_from_19_52(Eurydice_arr_2b value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1184
*/
const Eurydice_arr_5f *libcrux_ml_kem_types_as_slice_e6_3d(const Eurydice_arr_5f *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1184
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ff(const Eurydice_arr_5f *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1184U;
  return lit;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1088
*/
const Eurydice_arr_2b *libcrux_ml_kem_types_as_slice_a9_52(const Eurydice_arr_2b *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f3(Eurydice_arr_2b *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1088U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d414(Eurydice_arr_2b *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 3
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_78(Eurydice_arr_801 *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1120
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_81(const Eurydice_arr_af *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1120U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_06(const Eurydice_arr_2b *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1088U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1088
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_52(const Eurydice_arr_2b *self)
{
  return Eurydice_array_to_slice_shared_06(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f2(Eurydice_arr_af *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1120U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d413(Eurydice_arr_af *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1120
*/
Eurydice_arr_af libcrux_ml_kem_utils_into_padded_array_66(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_af out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d413(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f2(const Eurydice_arr_2b *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1088U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d46(const Eurydice_arr_2b *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2400
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_51(const Eurydice_arr_7d *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2400U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_64(Eurydice_borrow_slice_u8 private_key)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)1152U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)1184U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d44(Eurydice_arr_ec *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 32
*/
Eurydice_arr_ec libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_default_d3_be(void)
{
  return (KRML_CLITERAL(Eurydice_arr_ab0){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f1(const Eurydice_arr_03 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)800U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_210(const Eurydice_arr_03 *a, size_t r)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d45(const Eurydice_arr_ab0 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 800
*/
Eurydice_arr_03 libcrux_ml_kem_types_from_51_df(Eurydice_arr_03 value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_types_from_17_d6(Eurydice_arr_ab0 sk, Eurydice_arr_03 pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_types_MlKemKeyPair_0d){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_from_b2_be(Eurydice_arr_ab0 value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d412(Eurydice_arr_ab0 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_27(Eurydice_arr_d2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)768U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 24
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_ed(const Eurydice_arr_94 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)24U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d411(Eurydice_arr_b20 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 384
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_a9(const Eurydice_arr_b20 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)384U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$32size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_ec core_result_unwrap_26_39(core_result_Result_07 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f0(const Eurydice_arr_c7 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)64U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d44(const Eurydice_arr_c7 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 libcrux_ml_kem_types_from_19_80(Eurydice_arr_d2 value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 800
*/
const Eurydice_arr_03 *libcrux_ml_kem_types_as_slice_e6_df(const Eurydice_arr_03 *self)
{
  return self;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 768
*/
const Eurydice_arr_d2 *libcrux_ml_kem_types_as_slice_a9_80(const Eurydice_arr_d2 *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f1(Eurydice_arr_d2 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)768U - r });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 10
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_30(const Eurydice_arr_6d *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)10U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d410(Eurydice_arr_d2 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 22
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_98(const Eurydice_arr_80 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)22U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 20
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_8f(const Eurydice_arr_fc *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)20U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d49(Eurydice_arr_b0 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 320
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_56(const Eurydice_arr_b0 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)320U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 128
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_78(const Eurydice_arr_89 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)128U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_78(Eurydice_arr_89 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)128U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 192
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_d9(const Eurydice_arr_1c *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)192U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int16_t
with const generics
- N= 256
*/
Eurydice_borrow_slice_i16 Eurydice_array_to_slice_shared_990(const Eurydice_arr_04 *a)
{
  Eurydice_borrow_slice_i16 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)256U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 192
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d9(Eurydice_arr_1c *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)192U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 33
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_b5(const Eurydice_arr_fa *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)33U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 2
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_af(Eurydice_arr_4d *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d48(Eurydice_arr_fa *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 33
*/
Eurydice_arr_fa libcrux_ml_kem_utils_into_padded_array_29(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_fa out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 34
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d47(Eurydice_arr_31 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 34
*/
Eurydice_arr_31 libcrux_ml_kem_utils_into_padded_array_de(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_31 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d47(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_borrow_slice_i16
Eurydice_array_to_subslice_shared_e70(const Eurydice_arr_5b *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_i16){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d43(const Eurydice_arr_c5 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2c(Eurydice_arr_c5 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)168U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e7(Eurydice_arr_5b *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_i16){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 504
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d42(const Eurydice_arr_79 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_48(Eurydice_arr_79 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)504U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 34
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e9(const Eurydice_arr_31 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)34U;
  return lit;
}

/**
A monomorphic instance of Eurydice.slice_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_from_shared_6d(Eurydice_borrow_slice_u8 s, size_t r)
{
  return (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = s.ptr + r, .meta = s.meta - r });
}

/**
A monomorphic instance of Eurydice.slice_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_to_shared_72(Eurydice_borrow_slice_u8 s, size_t r)
{
  return (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = s.ptr, .meta = r });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 800
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_3b(const Eurydice_arr_03 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)800U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_27(const Eurydice_arr_d2 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)768U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 768
*/
Eurydice_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_80(const Eurydice_arr_d2 *self)
{
  return Eurydice_array_to_slice_shared_27(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f0(Eurydice_arr_03 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)800U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d46(Eurydice_arr_03 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 800
*/
Eurydice_arr_03 libcrux_ml_kem_utils_into_padded_array_df(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_03 out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d46(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 64
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_17(const Eurydice_arr_c7 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)64U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f(Eurydice_arr_c7 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)64U - r });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_01(const Eurydice_arr_ec *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)32U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d45(Eurydice_arr_c7 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 64
*/
Eurydice_arr_c7 libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_borrow_slice_u8 slice)
{
  Eurydice_arr_c7 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d45(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 2
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_82(const Eurydice_array_u8x2 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_shared
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_from_shared_5f(const Eurydice_arr_d2 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)768U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d41(const Eurydice_arr_d2 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 1632
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_99(const Eurydice_arr_ab0 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1632U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_borrow_slice_u8 private_key)
{
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)768U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)800U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_mut_borrow_slice_i16
Eurydice_slice_subslice_mut_a6(Eurydice_mut_borrow_slice_i16 s, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_i16){
        .ptr = s.ptr + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_29(const Eurydice_arr_b2 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$24size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_94 core_result_unwrap_26_78(core_result_Result_57 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int16_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_i16 Eurydice_array_to_slice_shared_8a(const Eurydice_arr_d6 *a)
{
  Eurydice_borrow_slice_i16 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$20size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_fc core_result_unwrap_26_7d(core_result_Result_83 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$10size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_6d core_result_unwrap_26_63(core_result_Result_80 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d40(const Eurydice_arr_b2 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_29(Eurydice_arr_b2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_8a(Eurydice_arr_d6 *a)
{
  Eurydice_mut_borrow_slice_i16 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$24size_t]]

*/
Eurydice_arr_94 libcrux_secrets_int_public_integers_declassify_d8_40(Eurydice_arr_94 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$20size_t]]

*/
Eurydice_arr_fc libcrux_secrets_int_public_integers_declassify_d8_2b(Eurydice_arr_fc self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$10size_t]]

*/
Eurydice_arr_6d libcrux_secrets_int_public_integers_declassify_d8_37(Eurydice_arr_6d self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$8size_t]]

*/
Eurydice_array_u8x8
libcrux_secrets_int_public_integers_declassify_d8_52(Eurydice_array_u8x8 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$2size_t]]

*/
Eurydice_array_u8x2
libcrux_secrets_int_public_integers_declassify_d8_75(Eurydice_array_u8x2 self)
{
  return self;
}

/**
 Classify a mutable slice (identity)
 We define a separate function for this because hax has limited support for &mut-returning functions
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_mut_slice
with types Eurydice_dst_ref_mut uint8_t size_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_public_integers_classify_mut_slice_75(Eurydice_mut_borrow_slice_u8 x)
{
  return x;
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_classify_27_4b(Eurydice_arr_d6 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_declassify_d8_4b(Eurydice_arr_d6 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types uint8_t

*/
Eurydice_borrow_slice_u8
libcrux_secrets_int_classify_public_classify_ref_6d_90(Eurydice_borrow_slice_u8 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$22size_t]]

*/
Eurydice_arr_80 libcrux_secrets_int_public_integers_declassify_d8_0b(Eurydice_arr_80 self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 16
*/
Eurydice_borrow_slice_i16
Eurydice_array_to_subslice_shared_e7(const Eurydice_arr_d6 *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_i16){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types int16_t

*/
Eurydice_borrow_slice_i16
libcrux_secrets_int_classify_public_classify_ref_6d_39(Eurydice_borrow_slice_i16 self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_borrow_slice_i16
Eurydice_slice_subslice_shared_a6(Eurydice_borrow_slice_i16 s, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_i16){ .ptr = s.ptr + r.start, .meta = r.end - r.start });
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr int16_t[[$16size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_d6 core_result_unwrap_26_d3(core_result_Result_ec self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_shared_d4(const Eurydice_arr_ec *a, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = a->data + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_17(Eurydice_arr_c7 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)64U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_9f(Eurydice_arr_65 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)48U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_01(Eurydice_arr_ec *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)32U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5e(Eurydice_arr_a2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)28U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 104
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_72(const Eurydice_arr_c4 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)104U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d43(Eurydice_arr_c4 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 144
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_38(const Eurydice_arr_f4 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)144U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d42(Eurydice_arr_f4 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 168
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_2c(const Eurydice_arr_c5 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)168U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d41(Eurydice_arr_c5 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 136
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_58(const Eurydice_arr_ff *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)136U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d40(Eurydice_arr_ff *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_shared
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8
Eurydice_array_to_subslice_to_shared_21(const Eurydice_array_u8x8 *a, size_t r)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 8
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_6e(const Eurydice_array_u8x8 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_c8(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 72
*/
Eurydice_borrow_slice_u8 Eurydice_array_to_slice_shared_e2(const Eurydice_arr_ab *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)72U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_e0(core_result_Result_8e self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.slice_subslice_shared
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_borrow_slice_u8
Eurydice_slice_subslice_shared_c8(Eurydice_borrow_slice_u8 s, core_ops_range_Range_87 r)
{
  return
    (KRML_CLITERAL(Eurydice_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d4(Eurydice_arr_ab *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_core_H
#define libcrux_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE ((size_t)32U)

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_ec_s { uint8_t data[32U]; } Eurydice_arr_ec;

#define LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT ((size_t)12U)

#define LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT ((size_t)256U)

#define LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)12U)

#define LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE ((size_t)32U)

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $3168size_t
*/
typedef struct Eurydice_arr_a8_s { uint8_t data[3168U]; } Eurydice_arr_a8;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1568size_t
*/
typedef struct Eurydice_arr_d1_s { uint8_t data[1568U]; } Eurydice_arr_d1;

typedef struct libcrux_ml_kem_mlkem1024_MlKem1024KeyPair_s
{
  Eurydice_arr_a8 sk;
  Eurydice_arr_d1 pk;
}
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_mlkem1024_MlKem1024Ciphertext, Eurydice_arr_ec

*/
typedef struct tuple_25_s
{
  Eurydice_arr_d1 fst;
  Eurydice_arr_ec snd;
}
tuple_25;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $2400size_t
*/
typedef struct Eurydice_arr_7d_s { uint8_t data[2400U]; } Eurydice_arr_7d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1184size_t
*/
typedef struct Eurydice_arr_5f_s { uint8_t data[1184U]; } Eurydice_arr_5f;

typedef struct libcrux_ml_kem_mlkem768_MlKem768KeyPair_s
{
  Eurydice_arr_7d sk;
  Eurydice_arr_5f pk;
}
libcrux_ml_kem_mlkem768_MlKem768KeyPair;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1088size_t
*/
typedef struct Eurydice_arr_2b_s { uint8_t data[1088U]; } Eurydice_arr_2b;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_mlkem768_MlKem768Ciphertext, Eurydice_arr_ec

*/
typedef struct tuple_f4_s
{
  Eurydice_arr_2b fst;
  Eurydice_arr_ec snd;
}
tuple_f4;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $168size_t
*/
typedef struct Eurydice_arr_c5_s { uint8_t data[168U]; } Eurydice_arr_c5;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1632size_t
*/
typedef struct Eurydice_arr_ab0_s { uint8_t data[1632U]; } Eurydice_arr_ab0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $800size_t
*/
typedef struct Eurydice_arr_03_s { uint8_t data[800U]; } Eurydice_arr_03;

/**
A monomorphic instance of libcrux_ml_kem.types.MlKemKeyPair
with const generics
- $1632size_t
- $800size_t
*/
typedef struct libcrux_ml_kem_types_MlKemKeyPair_0d_s
{
  Eurydice_arr_ab0 sk;
  Eurydice_arr_03 pk;
}
libcrux_ml_kem_types_MlKemKeyPair_0d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $768size_t
*/
typedef struct Eurydice_arr_d2_s { uint8_t data[768U]; } Eurydice_arr_d2;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_94_s { uint8_t data[24U]; } Eurydice_arr_94;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $64size_t
*/
typedef struct Eurydice_arr_c7_s { uint8_t data[64U]; } Eurydice_arr_c7;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_types_MlKemCiphertext_6e, Eurydice_arr_ec

*/
typedef struct tuple_ab_s
{
  Eurydice_arr_d2 fst;
  Eurydice_arr_ec snd;
}
tuple_ab;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $10size_t
*/
typedef struct Eurydice_arr_6d_s { uint8_t data[10U]; } Eurydice_arr_6d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $22size_t
*/
typedef struct Eurydice_arr_80_s { uint8_t data[22U]; } Eurydice_arr_80;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $20size_t
*/
typedef struct Eurydice_arr_fc_s { uint8_t data[20U]; } Eurydice_arr_fc;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_b2_s { uint8_t data[16U]; } Eurydice_arr_b2;

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_d6_s { int16_t data[16U]; } Eurydice_arr_d6;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_b2
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_87_s { Eurydice_arr_b2 data[256U]; } Eurydice_arr_87;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $136size_t
*/
typedef struct Eurydice_arr_ff_s { uint8_t data[136U]; } Eurydice_arr_ff;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ff
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_0b_s { Eurydice_arr_ff data[1U]; } Eurydice_arr_0b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_88_s { Eurydice_arr_c5 data[1U]; } Eurydice_arr_88;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $48size_t
*/
typedef struct Eurydice_arr_65_s { uint8_t data[48U]; } Eurydice_arr_65;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $28size_t
*/
typedef struct Eurydice_arr_a2_s { uint8_t data[28U]; } Eurydice_arr_a2;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_84_s { uint64_t data[5U]; } Eurydice_arr_84;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_borrow_slice_u8
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_dc_s { Eurydice_borrow_slice_u8 data[1U]; } Eurydice_arr_dc;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_7c_s { uint64_t data[25U]; } Eurydice_arr_7c;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_22_s { uint64_t data[24U]; } Eurydice_arr_22;

#if defined(__cplusplus)
}
#endif

#define libcrux_core_H_DEFINED
#endif /* libcrux_core_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem1024.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_H
#define libcrux_mlkem1024_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM1024_VECTOR_U_COMPRESSION_FACTOR ((size_t)11U)

#define LIBCRUX_ML_KEM_MLKEM1024_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM1024_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_RANK ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM1024_C1_SIZE (LIBCRUX_ML_KEM_MLKEM1024_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM1024_RANK)

#define LIBCRUX_ML_KEM_MLKEM1024_VECTOR_V_COMPRESSION_FACTOR ((size_t)5U)

#define LIBCRUX_ML_KEM_MLKEM1024_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM1024_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM1024_C1_SIZE + LIBCRUX_ML_KEM_MLKEM1024_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM1024_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA1 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM1024_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM1024_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM1024_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_a8 libcrux_ml_kem_mlkem1024_MlKem1024PrivateKey;

typedef Eurydice_arr_d1 libcrux_ml_kem_mlkem1024_MlKem1024PublicKey;

#define LIBCRUX_ML_KEM_MLKEM1024_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_H_DEFINED
#endif /* libcrux_mlkem1024_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem1024_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem1024_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_avx2_85(const Eurydice_arr_a8 *private_key, const Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_660(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_85(const Eurydice_arr_a8 *private_key, const Eurydice_arr_d1 *ciphertext)
{
  return decapsulate_avx2_85(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_decapsulate(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_avx2_07(const Eurydice_arr_d1 *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a10(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_07(const Eurydice_arr_d1 *public_key, const Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_07(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_encapsulate(
  const Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_07(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_avx2_b3(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db0(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_b3(const Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_b3(randomness);
}

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b3(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static bool
validate_private_key_avx2_43(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_b3(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static bool
validate_private_key_43(const Eurydice_arr_a8 *private_key, const Eurydice_arr_d1 *ciphertext)
{
  return validate_private_key_avx2_43(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return validate_private_key_43(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
static KRML_MUSTINLINE bool validate_private_key_only_f5(const Eurydice_arr_a8 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_f8(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key_only(const Eurydice_arr_a8 *private_key)
{
  return validate_private_key_only_f5(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static bool validate_public_key_avx2_f5(const Eurydice_arr_d1 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_74(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static bool validate_public_key_f5(const Eurydice_arr_d1 *public_key)
{
  return validate_public_key_avx2_f5(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_public_key(const Eurydice_arr_d1 *public_key)
{
  return validate_public_key_f5(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_avx2_850(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_850(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_avx2_850(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_850(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_avx2_070(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_070(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_070(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_070(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_avx2_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  generate_keypair_avx2_b30(randomness, out);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  generate_keypair_b30(randomness, key_pair);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_5b();
  libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_5b();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_5b();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
keypair_from_private_key_39(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_39(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static void
unpack_public_key_avx2_43(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static void
unpack_public_key_43(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  unpack_public_key_avx2_43(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  unpack_public_key_43(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem1024_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_avx2_H
#define libcrux_mlkem1024_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_decapsulate(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_encapsulate(
  const Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key_only(const Eurydice_arr_a8 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_public_key(const Eurydice_arr_d1 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_avx2_H_DEFINED
#endif /* libcrux_mlkem1024_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem1024_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem1024_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_85(const Eurydice_arr_a8 *private_key, const Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd1(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_decapsulate(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_07(const Eurydice_arr_d1 *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_991(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_encapsulate(
  const Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_07(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_b3(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b81(randomness);
}

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b3(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE bool
validate_private_key_43(const Eurydice_arr_a8 *private_key, const Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_79(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return validate_private_key_43(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
static KRML_MUSTINLINE bool validate_private_key_only_f5(const Eurydice_arr_a8 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_4c(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key_only(const Eurydice_arr_a8 *private_key)
{
  return validate_private_key_only_f5(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE bool validate_public_key_f5(const Eurydice_arr_d1 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_1c(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_public_key(const Eurydice_arr_d1 *public_key)
{
  return validate_public_key_f5(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_850(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_850(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_25
encapsulate_070(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_070(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(randomness, out);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  generate_keypair_b30(randomness, key_pair);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_ee();
  libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_ee();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_ee();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
keypair_from_private_key_39(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_39(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
unpack_public_key_43(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  unpack_public_key_43(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem1024_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_portable_H
#define libcrux_mlkem1024_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_decapsulate(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_encapsulate(
  const Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key_only(const Eurydice_arr_a8 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_public_key(const Eurydice_arr_d1 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_portable_H_DEFINED
#endif /* libcrux_mlkem1024_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem512.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_H
#define libcrux_mlkem512_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM512_VECTOR_U_COMPRESSION_FACTOR ((size_t)10U)

#define LIBCRUX_ML_KEM_MLKEM512_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM512_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_RANK ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM512_C1_SIZE (LIBCRUX_ML_KEM_MLKEM512_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM512_RANK)

#define LIBCRUX_ML_KEM_MLKEM512_VECTOR_V_COMPRESSION_FACTOR ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM512_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM512_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM512_C1_SIZE + LIBCRUX_ML_KEM_MLKEM512_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM512_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA1 ((size_t)3U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM512_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM512_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM512_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_d2 libcrux_ml_kem_mlkem512_MlKem512Ciphertext;

typedef libcrux_ml_kem_types_MlKemKeyPair_0d libcrux_ml_kem_mlkem512_MlKem512KeyPair;

typedef Eurydice_arr_ab0 libcrux_ml_kem_mlkem512_MlKem512PrivateKey;

typedef Eurydice_arr_03 libcrux_ml_kem_mlkem512_MlKem512PublicKey;

#define LIBCRUX_ML_KEM_MLKEM512_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_H_DEFINED
#endif /* libcrux_mlkem512_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem512_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem512_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_avx2_37(const Eurydice_arr_ab0 *private_key, const Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_66(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_37(const Eurydice_arr_ab0 *private_key, const Eurydice_arr_d2 *ciphertext)
{
  return decapsulate_avx2_37(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_decapsulate(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_37(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_avx2_80(const Eurydice_arr_03 *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a1(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_80(const Eurydice_arr_03 *public_key, const Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_80(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_encapsulate(
  const Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_80(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d
generate_keypair_avx2_b8(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d
generate_keypair_b8(const Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_b8(randomness);
}

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b8(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static bool
validate_private_key_avx2_25(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static bool
validate_private_key_25(const Eurydice_arr_ab0 *private_key, const Eurydice_arr_d2 *ciphertext)
{
  return validate_private_key_avx2_25(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return validate_private_key_25(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
static KRML_MUSTINLINE bool validate_private_key_only_d5(const Eurydice_arr_ab0 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_37(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key_only(const Eurydice_arr_ab0 *private_key)
{
  return validate_private_key_only_d5(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static bool validate_public_key_avx2_d5(const Eurydice_arr_03 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_ce(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static bool validate_public_key_d5(const Eurydice_arr_03 *public_key)
{
  return validate_public_key_avx2_d5(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_public_key(const Eurydice_arr_03 *public_key)
{
  return validate_public_key_d5(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_avx2_370(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_370(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_avx2_370(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_370(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_avx2_800(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_800(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_800(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_800(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static void
generate_keypair_avx2_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static void
generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  generate_keypair_avx2_b80(randomness, out);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  generate_keypair_b80(randomness, key_pair);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_16();
  libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_16();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_16();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
keypair_from_private_key_c3(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_c3(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static void
unpack_public_key_avx2_25(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static void
unpack_public_key_25(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  unpack_public_key_avx2_25(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  unpack_public_key_25(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem512_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_avx2_H
#define libcrux_mlkem512_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_decapsulate(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_encapsulate(
  const Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key_only(const Eurydice_arr_ab0 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_public_key(const Eurydice_arr_03 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_avx2_H_DEFINED
#endif /* libcrux_mlkem512_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem512_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem512_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_37(const Eurydice_arr_ab0 *private_key, const Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd0(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_decapsulate(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_37(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_80(const Eurydice_arr_03 *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_990(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_encapsulate(
  const Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_80(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d
generate_keypair_b8(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b80(randomness);
}

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b8(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE bool
validate_private_key_25(const Eurydice_arr_ab0 *private_key, const Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_d5(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return validate_private_key_25(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
static KRML_MUSTINLINE bool validate_private_key_only_d5(const Eurydice_arr_ab0 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_e2(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key_only(const Eurydice_arr_ab0 *private_key)
{
  return validate_private_key_only_d5(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE bool validate_public_key_d5(const Eurydice_arr_03 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_53(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_public_key(const Eurydice_arr_03 *public_key)
{
  return validate_public_key_d5(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_370(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_370(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_ab
encapsulate_800(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_800(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(randomness, out);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  generate_keypair_b80(randomness, key_pair);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_66();
  libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_66();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_66();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
keypair_from_private_key_c3(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_c3(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
unpack_public_key_25(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  unpack_public_key_25(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem512_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_portable_H
#define libcrux_mlkem512_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_decapsulate(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_encapsulate(
  const Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key_only(const Eurydice_arr_ab0 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_public_key(const Eurydice_arr_03 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_portable_H_DEFINED
#endif /* libcrux_mlkem512_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem768.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_H
#define libcrux_mlkem768_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM768_VECTOR_U_COMPRESSION_FACTOR ((size_t)10U)

#define LIBCRUX_ML_KEM_MLKEM768_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM768_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_RANK ((size_t)3U)

#define LIBCRUX_ML_KEM_MLKEM768_C1_SIZE (LIBCRUX_ML_KEM_MLKEM768_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM768_RANK)

#define LIBCRUX_ML_KEM_MLKEM768_VECTOR_V_COMPRESSION_FACTOR ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM768_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM768_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM768_C1_SIZE + LIBCRUX_ML_KEM_MLKEM768_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM768_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA1 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM768_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM768_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM768_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_7d libcrux_ml_kem_mlkem768_MlKem768PrivateKey;

typedef Eurydice_arr_5f libcrux_ml_kem_mlkem768_MlKem768PublicKey;

#define LIBCRUX_ML_KEM_MLKEM768_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_H_DEFINED
#endif /* libcrux_mlkem768_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem768_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem768_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_avx2_19(const Eurydice_arr_7d *private_key, const Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_661(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_19(const Eurydice_arr_7d *private_key, const Eurydice_arr_2b *ciphertext)
{
  return decapsulate_avx2_19(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_decapsulate(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_19(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_avx2_26(const Eurydice_arr_5f *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a11(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_26(const Eurydice_arr_5f *public_key, const Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_26(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_encapsulate(
  const Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_26(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair
generate_keypair_avx2_e9(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db1(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair
generate_keypair_e9(const Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_e9(randomness);
}

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_e9(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static bool
validate_private_key_avx2_d3(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_d50(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static bool
validate_private_key_d3(const Eurydice_arr_7d *private_key, const Eurydice_arr_2b *ciphertext)
{
  return validate_private_key_avx2_d3(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_avx2_validate_private_key(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return validate_private_key_d3(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
static KRML_MUSTINLINE bool validate_private_key_only_3b(const Eurydice_arr_7d *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_a4(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_private_key_only(const Eurydice_arr_7d *private_key)
{
  return validate_private_key_only_3b(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static bool validate_public_key_avx2_3b(const Eurydice_arr_5f *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_79(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static bool validate_public_key_3b(const Eurydice_arr_5f *public_key)
{
  return validate_public_key_avx2_3b(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_public_key(const Eurydice_arr_5f *public_key)
{
  return validate_public_key_3b(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_avx2_190(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_190(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_avx2_190(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_190(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_avx2_260(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_260(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_260(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_260(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_avx2_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  generate_keypair_avx2_e90(randomness, out);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  generate_keypair_e90(randomness, key_pair);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_e3();
  libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_e3();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_e3();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
keypair_from_private_key_71(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_71(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(key_pair, serialized);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_public_key(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *pk
)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
  uu____0 =
    libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(key_pair));
  pk[0U] = uu____0;
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static void
unpack_public_key_avx2_d3(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static void
unpack_public_key_d3(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  unpack_public_key_avx2_d3(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_unpacked_public_key(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  unpack_public_key_d3(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem768_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_avx2_H
#define libcrux_mlkem768_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_decapsulate(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_encapsulate(
  const Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_avx2_validate_private_key(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_avx2_validate_private_key_only(const Eurydice_arr_7d *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_public_key(const Eurydice_arr_5f *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_avx2_H_DEFINED
#endif /* libcrux_mlkem768_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem768_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem768_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_19(const Eurydice_arr_7d *private_key, const Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_decapsulate(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_19(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_26(const Eurydice_arr_5f *public_key, const Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_99(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_encapsulate(
  const Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_26(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair
generate_keypair_e9(const Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b8(randomness);
}

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_e9(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE bool
validate_private_key_d3(const Eurydice_arr_7d *private_key, const Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_ba(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return validate_private_key_d3(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
static KRML_MUSTINLINE bool validate_private_key_only_3b(const Eurydice_arr_7d *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_52(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key_only(const Eurydice_arr_7d *private_key)
{
  return validate_private_key_only_3b(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE bool validate_public_key_3b(const Eurydice_arr_5f *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_b6(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_public_key(const Eurydice_arr_5f *public_key)
{
  return validate_public_key_3b(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_190(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_unpacked_decapsulate(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_190(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_f4
encapsulate_260(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_unpacked_encapsulate(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_260(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(randomness, out);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  generate_keypair_e90(randomness, key_pair);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_68();
  libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_68();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_68();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
keypair_from_private_key_71(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_from_private_mut(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_71(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key_mut(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key_mut(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(key_pair, serialized);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_public_key(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *pk
)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
  uu____0 =
    libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(key_pair));
  pk[0U] = uu____0;
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_serialized_public_key(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
unpack_public_key_d3(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_unpacked_public_key(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  unpack_public_key_d3(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem768_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_portable_H
#define libcrux_mlkem768_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_decapsulate(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_encapsulate(
  const Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key_only(const Eurydice_arr_7d *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_public_key(const Eurydice_arr_5f *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_portable_H_DEFINED
#endif /* libcrux_mlkem768_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem_avx2.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_sha3_avx2.h"
#include "libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"
#include "internal/libcrux_core.h"

KRML_MUSTINLINE Eurydice_arr_c7
libcrux_ml_kem_hash_functions_avx2_G(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_c7 digest = { .data = { 0U } };
  libcrux_sha3_portable_sha512(Eurydice_array_to_slice_mut_17(&digest), input);
  return digest;
}

KRML_MUSTINLINE Eurydice_arr_ec
libcrux_ml_kem_hash_functions_avx2_H(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_sha256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_vec_zero(void)
{
  return mm256_setzero_si256();
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_ZERO_f5(void)
{
  return libcrux_ml_kem_vector_avx2_vec_zero();
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_vec_from_i16_array(Eurydice_borrow_slice_i16 array)
{
  return mm256_loadu_si256_i16(array);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_borrow_slice_i16 array)
{
  return libcrux_ml_kem_vector_avx2_vec_from_i16_array(array);
}

KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_vec_to_i16_array(__m256i v)
{
  Eurydice_arr_d6 output = { .data = { 0U } };
  mm256_storeu_si256_i16(Eurydice_array_to_slice_mut_8a(&output), v);
  return output;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_to_i16_array_f5(__m256i x)
{
  return libcrux_ml_kem_vector_avx2_vec_to_i16_array(x);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_from_bytes(Eurydice_borrow_slice_u8 array)
{
  return
    mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(array,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)32U })));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_from_bytes_f5(Eurydice_borrow_slice_u8 array)
{
  return libcrux_ml_kem_vector_avx2_from_bytes(array);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_avx2_to_bytes(__m256i x, Eurydice_mut_borrow_slice_u8 bytes)
{
  mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)32U })),
    x);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE void
libcrux_ml_kem_vector_avx2_to_bytes_f5(__m256i x, Eurydice_mut_borrow_slice_u8 bytes)
{
  libcrux_ml_kem_vector_avx2_to_bytes(x, bytes);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_add(__m256i lhs, __m256i rhs)
{
  return mm256_add_epi16(lhs, rhs);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_add_f5(__m256i lhs, const __m256i *rhs)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_add(lhs, rhs[0U]);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_sub(__m256i lhs, __m256i rhs)
{
  return mm256_sub_epi16(lhs, rhs);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_sub_f5(__m256i lhs, const __m256i *rhs)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_sub(lhs, rhs[0U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(__m256i vector, int16_t constant)
{
  __m256i cv = mm256_set1_epi16(constant);
  return mm256_mullo_epi16(vector, cv);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(__m256i vec, int16_t c)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(vec, c);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i v_minus_field_modulus = mm256_sub_epi16(vector, field_modulus);
  __m256i sign_mask = mm256_srai_epi16(15, v_minus_field_modulus, __m256i);
  __m256i conditional_add_field_modulus = mm256_and_si256(sign_mask, field_modulus);
  return mm256_add_epi16(v_minus_field_modulus, conditional_add_field_modulus);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_cond_subtract_3329(vector);
}

/**
 See Section 3.2 of the implementation notes document for an explanation
 of this code.
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(__m256i vector)
{
  __m256i
  t0 =
    mm256_mulhi_epi16(vector,
      mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_AVX2_ARITHMETIC_BARRETT_MULTIPLIER));
  __m256i t512 = mm256_set1_epi16(512);
  __m256i t1 = mm256_add_epi16(t0, t512);
  __m256i quotient = mm256_srai_epi16(10, t1, __m256i);
  __m256i
  quotient_times_field_modulus =
    mm256_mullo_epi16(quotient,
      mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  return mm256_sub_epi16(vector, quotient_times_field_modulus);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_barrett_reduce_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i vector,
  int16_t constant
)
{
  __m256i vec_constant = mm256_set1_epi16(constant);
  __m256i value_low = mm256_mullo_epi16(vector, vec_constant);
  __m256i
  k =
    mm256_mullo_epi16(value_low,
      mm256_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i k_times_modulus = mm256_mulhi_epi16(k, modulus);
  __m256i value_high = mm256_mulhi_epi16(vector, vec_constant);
  return mm256_sub_epi16(value_high, k_times_modulus);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(__m256i vector, int16_t constant)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(vector, constant);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(
  __m256i vector,
  int16_t constant
)
{
  __m256i cv = mm256_set1_epi16(constant);
  return mm256_and_si256(vector, cv);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.arithmetic.shift_right
with const generics
- SHIFT_BY= 15
*/
static KRML_MUSTINLINE __m256i shift_right_ef(__m256i vector)
{
  return mm256_srai_epi16(15, vector, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(__m256i a)
{
  __m256i t = shift_right_ef(a);
  __m256i
  fm =
    libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(t,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  return libcrux_ml_kem_vector_avx2_arithmetic_add(a, fm);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(a);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(__m256i vector)
{
  __m256i
  field_modulus_halved = mm256_set1_epi16((LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i
  field_modulus_quartered =
    mm256_set1_epi16((LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 4);
  __m256i shifted = mm256_sub_epi16(field_modulus_halved, vector);
  __m256i mask = mm256_srai_epi16(15, shifted, __m256i);
  __m256i shifted_to_positive = mm256_xor_si256(mask, shifted);
  __m256i
  shifted_to_positive_in_range = mm256_sub_epi16(shifted_to_positive, field_modulus_quartered);
  return mm256_srli_epi16(15, shifted_to_positive_in_range, __m256i);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_1(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_1_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_compress_1(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(__m256i lhs, __m256i rhs)
{
  __m256i prod02 = mm256_mul_epu32(lhs, rhs);
  __m256i
  prod13 =
    mm256_mul_epu32(mm256_shuffle_epi32(245, lhs, __m256i),
      mm256_shuffle_epi32(245, rhs, __m256i));
  return
    mm256_unpackhi_epi64(mm256_unpacklo_epi32(prod02, prod13),
      mm256_unpackhi_epi32(prod02, prod13));
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_decompress_1(__m256i a)
{
  __m256i z = mm256_setzero_si256();
  __m256i s = libcrux_ml_kem_vector_avx2_arithmetic_sub(z, a);
  return libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(s, 1665);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_decompress_1_f5(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_compress_decompress_1(a);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(
  __m256i vec,
  __m256i constants
)
{
  __m256i value_low = mm256_mullo_epi16(vec, constants);
  __m256i
  k =
    mm256_mullo_epi16(value_low,
      mm256_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i k_times_modulus = mm256_mulhi_epi16(k, modulus);
  __m256i value_high = mm256_mulhi_epi16(vec, constants);
  return mm256_sub_epi16(value_high, k_times_modulus);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i
  zetas =
    mm256_set_epi16(-zeta3,
      -zeta3,
      zeta3,
      zeta3,
      -zeta2,
      -zeta2,
      zeta2,
      zeta2,
      -zeta1,
      -zeta1,
      zeta1,
      zeta1,
      -zeta0,
      -zeta0,
      zeta0,
      zeta0);
  __m256i rhs = mm256_shuffle_epi32(245, vector, __m256i);
  __m256i
  rhs0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(rhs, zetas);
  __m256i lhs = mm256_shuffle_epi32(160, vector, __m256i);
  return mm256_add_epi16(lhs, rhs0);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  __m256i
  zetas =
    mm256_set_epi16(-zeta1,
      -zeta1,
      -zeta1,
      -zeta1,
      zeta1,
      zeta1,
      zeta1,
      zeta1,
      -zeta0,
      -zeta0,
      -zeta0,
      -zeta0,
      zeta0,
      zeta0,
      zeta0,
      zeta0);
  __m256i rhs = mm256_shuffle_epi32(238, vector, __m256i);
  __m256i
  rhs0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(rhs, zetas);
  __m256i lhs = mm256_shuffle_epi32(68, vector, __m256i);
  return mm256_add_epi16(lhs, rhs0);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(vector, zeta0, zeta1);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_2_step(vector, zeta0, zeta1);
}

KRML_MUSTINLINE __m128i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(
  __m128i vec,
  __m128i constants
)
{
  __m128i value_low = mm_mullo_epi16(vec, constants);
  __m128i
  k =
    mm_mullo_epi16(value_low,
      mm_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m128i modulus = mm_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m128i k_times_modulus = mm_mulhi_epi16(k, modulus);
  __m128i value_high = mm_mulhi_epi16(vec, constants);
  return mm_sub_epi16(value_high, k_times_modulus);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  __m128i rhs = mm256_extracti128_si256(1, vector, __m128i);
  __m128i
  rhs0 =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(rhs,
      mm_set1_epi16(zeta));
  __m128i lhs = mm256_castsi256_si128(vector);
  __m128i lower_coefficients = mm_add_epi16(lhs, rhs0);
  __m128i upper_coefficients = mm_sub_epi16(lhs, rhs0);
  __m256i combined = mm256_castsi128_si256(lower_coefficients);
  return mm256_inserti128_si256(1, combined, upper_coefficients, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(vector, zeta);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_3_step(vector, zeta);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i lhs = mm256_shuffle_epi32(245, vector, __m256i);
  __m256i rhs = mm256_shuffle_epi32(160, vector, __m256i);
  __m256i
  rhs0 =
    mm256_mullo_epi16(rhs,
      mm256_set_epi16(-1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1));
  __m256i sum0 = mm256_add_epi16(lhs, rhs0);
  __m256i
  sum_times_zetas =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(sum0,
      mm256_set_epi16(zeta3,
        zeta3,
        0,
        0,
        zeta2,
        zeta2,
        0,
        0,
        zeta1,
        zeta1,
        0,
        0,
        zeta0,
        zeta0,
        0,
        0));
  __m256i sum = libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(sum0);
  return mm256_blend_epi16(204, sum, sum_times_zetas, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
)
{
  __m256i lhs = mm256_permute4x64_epi64(245, vector, __m256i);
  __m256i rhs = mm256_permute4x64_epi64(160, vector, __m256i);
  __m256i
  rhs0 =
    mm256_mullo_epi16(rhs,
      mm256_set_epi16(-1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1));
  __m256i sum = mm256_add_epi16(lhs, rhs0);
  __m256i
  sum_times_zetas =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(sum,
      mm256_set_epi16(zeta1,
        zeta1,
        zeta1,
        zeta1,
        0,
        0,
        0,
        0,
        zeta0,
        zeta0,
        zeta0,
        zeta0,
        0,
        0,
        0,
        0));
  return mm256_blend_epi16(240, sum, sum_times_zetas, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(vector, zeta0, zeta1);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(vector, zeta0, zeta1);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  __m128i lhs = mm256_extracti128_si256(1, vector, __m128i);
  __m128i rhs = mm256_castsi256_si128(vector);
  __m128i lower_coefficients = mm_add_epi16(lhs, rhs);
  __m128i upper_coefficients = mm_sub_epi16(lhs, rhs);
  __m128i
  upper_coefficients0 =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(upper_coefficients,
      mm_set1_epi16(zeta));
  __m256i combined = mm256_castsi128_si256(lower_coefficients);
  return mm256_inserti128_si256(1, combined, upper_coefficients0, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(vector, zeta);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(vector, zeta);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(__m256i vec)
{
  __m256i
  k =
    mm256_mullo_epi16(vec,
      mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i
  k_times_modulus =
    mm256_mulhi_epi16(k,
      mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  __m256i value_high = mm256_srli_epi32(16, vec, __m256i);
  __m256i result = mm256_sub_epi16(value_high, k_times_modulus);
  __m256i result0 = mm256_slli_epi32(16, result, __m256i);
  return mm256_srai_epi32(16, result0, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(
  __m256i lhs,
  __m256i rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i
  shuffle_with =
    mm256_set_epi8(15,
      14,
      11,
      10,
      7,
      6,
      3,
      2,
      13,
      12,
      9,
      8,
      5,
      4,
      1,
      0,
      15,
      14,
      11,
      10,
      7,
      6,
      3,
      2,
      13,
      12,
      9,
      8,
      5,
      4,
      1,
      0);
  __m256i lhs_shuffled = mm256_shuffle_epi8(lhs, shuffle_with);
  __m256i lhs_shuffled0 = mm256_permute4x64_epi64(216, lhs_shuffled, __m256i);
  __m128i lhs_evens = mm256_castsi256_si128(lhs_shuffled0);
  __m256i lhs_evens0 = mm256_cvtepi16_epi32(lhs_evens);
  __m128i lhs_odds = mm256_extracti128_si256(1, lhs_shuffled0, __m128i);
  __m256i lhs_odds0 = mm256_cvtepi16_epi32(lhs_odds);
  __m256i rhs_shuffled = mm256_shuffle_epi8(rhs, shuffle_with);
  __m256i rhs_shuffled0 = mm256_permute4x64_epi64(216, rhs_shuffled, __m256i);
  __m128i rhs_evens = mm256_castsi256_si128(rhs_shuffled0);
  __m256i rhs_evens0 = mm256_cvtepi16_epi32(rhs_evens);
  __m128i rhs_odds = mm256_extracti128_si256(1, rhs_shuffled0, __m128i);
  __m256i rhs_odds0 = mm256_cvtepi16_epi32(rhs_odds);
  __m256i left = mm256_mullo_epi32(lhs_evens0, rhs_evens0);
  __m256i right = mm256_mullo_epi32(lhs_odds0, rhs_odds0);
  __m256i right0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(right);
  __m256i
  right1 =
    mm256_mullo_epi32(right0,
      mm256_set_epi32(-(int32_t)zeta3,
        (int32_t)zeta3,
        -(int32_t)zeta2,
        (int32_t)zeta2,
        -(int32_t)zeta1,
        (int32_t)zeta1,
        -(int32_t)zeta0,
        (int32_t)zeta0));
  __m256i products_left = mm256_add_epi32(left, right1);
  __m256i
  products_left0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(products_left);
  __m256i
  rhs_adjacent_swapped =
    mm256_shuffle_epi8(rhs,
      mm256_set_epi8(13,
        12,
        15,
        14,
        9,
        8,
        11,
        10,
        5,
        4,
        7,
        6,
        1,
        0,
        3,
        2,
        13,
        12,
        15,
        14,
        9,
        8,
        11,
        10,
        5,
        4,
        7,
        6,
        1,
        0,
        3,
        2));
  __m256i products_right = mm256_madd_epi16(lhs, rhs_adjacent_swapped);
  __m256i
  products_right0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(products_right);
  __m256i products_right1 = mm256_slli_epi32(16, products_right0, __m256i);
  return mm256_blend_epi16(170, products_left0, products_right1, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_multiply(
  const __m256i *lhs,
  const __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return
    libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(lhs[0U],
      rhs[0U],
      zeta0,
      zeta1,
      zeta2,
      zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_multiply_f5(
  const __m256i *lhs,
  const __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_multiply(lhs, rhs, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_array_u8x2
libcrux_ml_kem_vector_avx2_serialize_serialize_1(__m256i vector)
{
  __m256i lsb_to_msb = mm256_slli_epi16(15, vector, __m256i);
  __m128i low_msbs = mm256_castsi256_si128(lsb_to_msb);
  __m128i high_msbs = mm256_extracti128_si256(1, lsb_to_msb, __m128i);
  __m128i msbs = mm_packs_epi16(low_msbs, high_msbs);
  int32_t bits_packed = mm_movemask_epi8(msbs);
  Eurydice_array_u8x2
  result = { .data = { (uint8_t)bits_packed, (uint8_t)(bits_packed >> 8U) } };
  return result;
}

KRML_MUSTINLINE Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_1(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_1(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s(int16_t a, int16_t b)
{
  __m256i coefficients = mm256_set_epi16(b, b, b, b, b, b, b, b, a, a, a, a, a, a, a, a);
  __m256i
  coefficients_in_msb =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 8U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 10U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 12U),
        (int16_t)((uint32_t)1 << 13U),
        (int16_t)((uint32_t)1 << 14U),
        -32768,
        (int16_t)((uint32_t)1 << 8U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 10U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 12U),
        (int16_t)((uint32_t)1 << 13U),
        (int16_t)((uint32_t)1 << 14U),
        -32768));
  return mm256_srli_epi16(15, coefficients_in_msb, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(uint8_t a, uint8_t b)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s((int16_t)a,
      (int16_t)b);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1(Eurydice_borrow_slice_u8 bytes)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(bytes.ptr[0U],
      bytes.ptr[1U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_1(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_1(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_1(bytes);
}

/**
 `mm256_concat_pairs_n(n, x)` is then a sequence of 32 bits packets
 of the shape `0b0…0b₁…bₙa₁…aₙ`, if `x` is a sequence of pairs of
 16 bits, of the shape `(0b0…0a₁…aₙ, 0b0…0b₁…bₙ)` (where the last
 `n` bits are non-zero).
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(uint8_t n, __m256i x)
{
  int16_t n0 = (int16_t)((uint32_t)1 << (uint32_t)n);
  return
    mm256_madd_epi16(x,
      mm256_set_epi16(n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1));
}

KRML_MUSTINLINE Eurydice_array_u8x8
libcrux_ml_kem_vector_avx2_serialize_serialize_4(__m256i vector)
{
  Eurydice_arr_b2 serialized = { .data = { 0U } };
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(4U, vector);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_2_combined,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        8,
        4,
        0,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        8,
        4,
        0));
  __m256i
  combined =
    mm256_permutevar8x32_epi32(adjacent_8_combined,
      mm256_set_epi32(0, 0, 0, 0, 0, 0, 4, 0));
  __m128i combined0 = mm256_castsi256_si128(combined);
  mm_storeu_bytes_si128(Eurydice_array_to_slice_mut_29(&serialized), combined0);
  Eurydice_array_u8x8 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_d40(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })).ptr,
    (size_t)8U * sizeof (uint8_t));
  return
    core_result_unwrap_26_e0((
        KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_4(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s(
  int16_t b0,
  int16_t b1,
  int16_t b2,
  int16_t b3,
  int16_t b4,
  int16_t b5,
  int16_t b6,
  int16_t b7
)
{
  __m256i
  coefficients = mm256_set_epi16(b7, b7, b6, b6, b5, b5, b4, b4, b3, b3, b2, b2, b1, b1, b0, b0);
  __m256i
  coefficients_in_msb =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U)));
  __m256i coefficients_in_lsb = mm256_srli_epi16(4, coefficients_in_msb, __m256i);
  return
    mm256_and_si256(coefficients_in_lsb,
      mm256_set1_epi16((int16_t)((uint32_t)1 << 4U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(
  uint8_t b0,
  uint8_t b1,
  uint8_t b2,
  uint8_t b3,
  uint8_t b4,
  uint8_t b5,
  uint8_t b6,
  uint8_t b7
)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s((int16_t)b0,
      (int16_t)b1,
      (int16_t)b2,
      (int16_t)b3,
      (int16_t)b4,
      (int16_t)b5,
      (int16_t)b6,
      (int16_t)b7);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4(Eurydice_borrow_slice_u8 bytes)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(bytes.ptr[0U],
      bytes.ptr[1U],
      bytes.ptr[2U],
      bytes.ptr[3U],
      bytes.ptr[4U],
      bytes.ptr[5U],
      bytes.ptr[6U],
      bytes.ptr[7U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_4(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_4(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_4_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_4(bytes);
}

KRML_MUSTINLINE Eurydice_arr_6d
libcrux_ml_kem_vector_avx2_serialize_serialize_5(__m256i vector)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  __m256i
  adjacent_2_combined =
    mm256_madd_epi16(vector,
      mm256_set_epi16((int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1));
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 22, 0, 22, 0, 22, 0, 22));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(22, adjacent_4_combined, __m256i);
  __m256i adjacent_8_combined = mm256_shuffle_epi32(8, adjacent_4_combined0, __m256i);
  __m256i
  adjacent_8_combined0 =
    mm256_sllv_epi32(adjacent_8_combined,
      mm256_set_epi32(0, 0, 0, 12, 0, 0, 0, 12));
  __m256i adjacent_8_combined1 = mm256_srli_epi64(12, adjacent_8_combined0, __m256i);
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined1);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined1, __m128i);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)5U, .end = (size_t)21U })),
    upper_8);
  Eurydice_arr_6d arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_d4(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)10U })).ptr,
    (size_t)10U * sizeof (uint8_t));
  return
    core_result_unwrap_26_63((
        KRML_CLITERAL(core_result_Result_80){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_5_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_5(vector);
}

/**
 We cannot model `mm256_inserti128_si256` on its own: it produces a
 Vec256 where the upper 128 bits are undefined. Thus
 `mm256_inserti128_si256` is not pure.

 Luckily, we always call `mm256_castsi128_si256` right after
 `mm256_inserti128_si256`: this composition sets the upper bits,
 making the whole computation pure again.
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(__m128i lower, __m128i upper)
{
  return mm256_inserti128_si256(1, mm256_castsi128_si256(lower), upper, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_5(Eurydice_borrow_slice_u8 bytes)
{
  __m128i
  coefficients =
    mm_set_epi8((int8_t)bytes.ptr[9U],
      (int8_t)bytes.ptr[8U],
      (int8_t)bytes.ptr[8U],
      (int8_t)bytes.ptr[7U],
      (int8_t)bytes.ptr[7U],
      (int8_t)bytes.ptr[6U],
      (int8_t)bytes.ptr[6U],
      (int8_t)bytes.ptr[5U],
      (int8_t)bytes.ptr[4U],
      (int8_t)bytes.ptr[3U],
      (int8_t)bytes.ptr[3U],
      (int8_t)bytes.ptr[2U],
      (int8_t)bytes.ptr[2U],
      (int8_t)bytes.ptr[1U],
      (int8_t)bytes.ptr[1U],
      (int8_t)bytes.ptr[0U]);
  __m256i
  coefficients_loaded =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(coefficients,
      coefficients);
  __m256i
  coefficients0 =
    mm256_shuffle_epi8(coefficients_loaded,
      mm256_set_epi8(15,
        14,
        15,
        14,
        13,
        12,
        13,
        12,
        11,
        10,
        11,
        10,
        9,
        8,
        9,
        8,
        7,
        6,
        7,
        6,
        5,
        4,
        5,
        4,
        3,
        2,
        3,
        2,
        1,
        0,
        1,
        0));
  __m256i
  coefficients1 =
    mm256_mullo_epi16(coefficients0,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 5U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 7U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 5U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 7U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 11U)));
  return mm256_srli_epi16(11, coefficients1, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_5_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_5(bytes);
}

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(__m256i vector)
{
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(10U, vector);
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 12, 0, 12, 0, 12, 0, 12));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(12, adjacent_4_combined, __m256i);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_4_combined0,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        11,
        10,
        9,
        8,
        4,
        3,
        2,
        1,
        0,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        11,
        10,
        9,
        8,
        4,
        3,
        2,
        1,
        0));
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined, __m128i);
  return (KRML_CLITERAL(core_core_arch_x86___m128i_x2){ .fst = lower_8, .snd = upper_8 });
}

KRML_MUSTINLINE Eurydice_arr_fc
libcrux_ml_kem_vector_avx2_serialize_serialize_10(__m256i vector)
{
  core_core_arch_x86___m128i_x2
  uu____0 = libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(vector);
  __m128i lower_8 = uu____0.fst;
  __m128i upper_8 = uu____0.snd;
  Eurydice_arr_ec serialized = { .data = { 0U } };
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)26U })),
    upper_8);
  Eurydice_arr_fc arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_d4(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)20U })).ptr,
    (size_t)20U * sizeof (uint8_t));
  return
    core_result_unwrap_26_7d((
        KRML_CLITERAL(core_result_Result_83){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_10(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_10(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
)
{
  __m128i
  lower_coefficients =
    mm_shuffle_epi8(lower_coefficients0,
      mm_set_epi8(9, 8, 8, 7, 7, 6, 6, 5, 4, 3, 3, 2, 2, 1, 1, 0));
  __m128i
  upper_coefficients =
    mm_shuffle_epi8(upper_coefficients0,
      mm_set_epi8(15, 14, 14, 13, 13, 12, 12, 11, 10, 9, 9, 8, 8, 7, 7, 6));
  __m256i
  coefficients =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(lower_coefficients,
      upper_coefficients);
  __m256i
  coefficients0 =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U)));
  __m256i coefficients1 = mm256_srli_epi16(6, coefficients0, __m256i);
  return mm256_and_si256(coefficients1, mm256_set1_epi16((int16_t)((uint32_t)1 << 10U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10(Eurydice_borrow_slice_u8 bytes)
{
  Eurydice_borrow_slice_u8
  lower_coefficients =
    Eurydice_slice_subslice_shared_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U }));
  Eurydice_borrow_slice_u8
  upper_coefficients =
    Eurydice_slice_subslice_shared_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)20U }));
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(mm_loadu_si128(lower_coefficients),
      mm_loadu_si128(upper_coefficients));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_10(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_10(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_10_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_10(bytes);
}

KRML_MUSTINLINE Eurydice_arr_80
libcrux_ml_kem_vector_avx2_serialize_serialize_11(__m256i vector)
{
  Eurydice_arr_d6 array = { .data = { 0U } };
  mm256_storeu_si256_i16(Eurydice_array_to_slice_mut_8a(&array), vector);
  Eurydice_arr_d6
  input =
    libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_array_to_slice_shared_8a(&array));
  return libcrux_ml_kem_vector_portable_serialize_11_b8(input);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_11_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_11(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_11(Eurydice_borrow_slice_u8 bytes)
{
  Eurydice_arr_d6 output = libcrux_ml_kem_vector_portable_deserialize_11_b8(bytes);
  Eurydice_arr_d6 array = libcrux_ml_kem_vector_portable_to_i16_array_b8(output);
  return mm256_loadu_si256_i16(Eurydice_array_to_slice_shared_8a(&array));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_11_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_11(bytes);
}

KRML_MUSTINLINE core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(__m256i vector)
{
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(12U, vector);
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 8, 0, 8, 0, 8, 0, 8));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(8, adjacent_4_combined, __m256i);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_4_combined0,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        13,
        12,
        11,
        10,
        9,
        8,
        5,
        4,
        3,
        2,
        1,
        0,
        -1,
        -1,
        -1,
        -1,
        13,
        12,
        11,
        10,
        9,
        8,
        5,
        4,
        3,
        2,
        1,
        0));
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined, __m128i);
  return (KRML_CLITERAL(core_core_arch_x86___m128i_x2){ .fst = lower_8, .snd = upper_8 });
}

KRML_MUSTINLINE Eurydice_arr_94
libcrux_ml_kem_vector_avx2_serialize_serialize_12(__m256i vector)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  core_core_arch_x86___m128i_x2
  uu____0 = libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(vector);
  __m128i lower_8 = uu____0.fst;
  __m128i upper_8 = uu____0.snd;
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)28U })),
    upper_8);
  Eurydice_arr_94 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_shared_d4(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)24U })).ptr,
    (size_t)24U * sizeof (uint8_t));
  return
    core_result_unwrap_26_78((
        KRML_CLITERAL(core_result_Result_57){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_12(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_12(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
)
{
  __m128i
  lower_coefficients =
    mm_shuffle_epi8(lower_coefficients0,
      mm_set_epi8(11, 10, 10, 9, 8, 7, 7, 6, 5, 4, 4, 3, 2, 1, 1, 0));
  __m128i
  upper_coefficients =
    mm_shuffle_epi8(upper_coefficients0,
      mm_set_epi8(15, 14, 14, 13, 12, 11, 11, 10, 9, 8, 8, 7, 6, 5, 5, 4));
  __m256i
  coefficients =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(lower_coefficients,
      upper_coefficients);
  __m256i
  coefficients0 =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U)));
  __m256i coefficients1 = mm256_srli_epi16(4, coefficients0, __m256i);
  return mm256_and_si256(coefficients1, mm256_set1_epi16((int16_t)((uint32_t)1 << 12U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12(Eurydice_borrow_slice_u8 bytes)
{
  __m128i
  lower_coefficients =
    mm_loadu_si128(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })));
  __m128i
  upper_coefficients =
    mm_loadu_si128(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)24U })));
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(lower_coefficients,
      upper_coefficients);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_12(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_12(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_12_f5(Eurydice_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_12(bytes);
}

KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_avx2_sampling_rejection_sample(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
)
{
  __m256i field_modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i potential_coefficients = libcrux_ml_kem_vector_avx2_serialize_deserialize_12(input);
  __m256i compare_with_field_modulus = mm256_cmpgt_epi16(field_modulus, potential_coefficients);
  Eurydice_array_u8x2
  good = libcrux_ml_kem_vector_avx2_serialize_serialize_1(compare_with_field_modulus);
  Eurydice_arr_b2
  lower_shuffles =
    LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE.data[(size_t)good.data[0U]];
  __m128i lower_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_29(&lower_shuffles));
  __m128i lower_coefficients = mm256_castsi256_si128(potential_coefficients);
  __m128i lower_coefficients0 = mm_shuffle_epi8(lower_coefficients, lower_shuffles0);
  mm_storeu_si128(output, lower_coefficients0);
  size_t sampled_count = (size_t)core_num__u8__count_ones(good.data[0U]);
  Eurydice_arr_b2
  upper_shuffles =
    LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE.data[(size_t)good.data[1U]];
  __m128i upper_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_shared_29(&upper_shuffles));
  __m128i upper_coefficients = mm256_extracti128_si256(1, potential_coefficients, __m128i);
  __m128i upper_coefficients0 = mm_shuffle_epi8(upper_coefficients, upper_shuffles0);
  mm_storeu_si128(Eurydice_slice_subslice_mut_a6(output,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = sampled_count,
          .end = sampled_count + (size_t)8U
        }
      )),
    upper_coefficients0);
  size_t uu____0 = sampled_count;
  return uu____0 + (size_t)core_num__u8__count_ones(good.data[1U]);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_avx2_rej_sample_f5(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
)
{
  return libcrux_ml_kem_vector_avx2_sampling_rejection_sample(input, output);
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
inline __m256i libcrux_ml_kem_vector_avx2_clone_fd(const __m256i *self)
{
  return self[0U];
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static Eurydice_arr_13 ZERO_d6_84(void)
{
  Eurydice_arr_13 lit;
  __m256i repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_avx2_ZERO_f5(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (__m256i));
  return lit;
}

/**
 Only use with public values.

 This MUST NOT be used with secret inputs, like its caller `deserialize_ring_elements_reduced`.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_reduced_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_to_reduced_ring_element_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_12_f5(bytes);
    re.data[i0] = libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(coefficient);
  }
  return re;
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_e3(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_60 *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_78(const Eurydice_arr_81 *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_shared_e9(input->data),
    Eurydice_array_to_slice_shared_e9(&input->data[1U]),
    Eurydice_array_to_slice_shared_e9(&input->data[2U]),
    Eurydice_array_to_slice_shared_e9(input->data));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_78(const Eurydice_arr_81 *input)
{
  return shake128_init_absorb_final_78(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_7e
shake128_squeeze_first_three_blocks_78(Eurydice_arr_c40 *st)
{
  Eurydice_arr_7e
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_7e
shake128_squeeze_first_three_blocks_41_78(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_79(
  const Eurydice_arr_7e *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_2c shake128_squeeze_next_block_78(Eurydice_arr_c40 *st)
{
  Eurydice_arr_2c
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_2c
shake128_squeeze_next_block_41_78(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_790(
  const Eurydice_arr_2c *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static Eurydice_arr_13 ZERO_84(void)
{
  Eurydice_arr_13 lit;
  __m256i repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_avx2_ZERO_f5(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (__m256i));
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13 from_i16_array_84(Eurydice_borrow_slice_i16 a)
{
  Eurydice_arr_13 result = ZERO_84();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    result.data[i0] =
      libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_slice_subslice_shared_a6(a,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * (size_t)16U,
              .end = (i0 + (size_t)1U) * (size_t)16U
            }
          )));
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13 from_i16_array_d6_84(Eurydice_borrow_slice_i16 a)
{
  return from_i16_array_84(a);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0a_281(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60 sample_from_xof_281(const Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_78(seeds);
  Eurydice_arr_7e randomness0 = shake128_squeeze_first_three_blocks_41_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_79(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c randomness = shake128_squeeze_next_block_41_78(&xof_state);
      done = sample_from_uniform_distribution_next_790(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_60 arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_281(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_281(Eurydice_arr_ea *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_60 sampled = sample_from_xof_281(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_78(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_211(public_key, (size_t)1152U);
  deserialize_ring_elements_reduced_e3(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f3(public_key,
        (size_t)1152U));
  Eurydice_arr_ea *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f3(public_key,
        (size_t)1152U));
  sample_matrix_A_281(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_78(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
const
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return &self->public_key;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.clone_91
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static inline libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
clone_91_e3(const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *self)
{
  Eurydice_arr_60
  uu____0 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
      &self->t_as_ntt,
      Eurydice_arr_13,
      Eurydice_arr_60);
  Eurydice_arr_ec
  uu____1 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
      &self->seed_for_A,
      uint8_t,
      Eurydice_arr_ec);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef){
        .t_as_ntt = uu____0,
        .seed_for_A = uu____1,
        .A = core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
          &self->A,
          Eurydice_arr_60,
          Eurydice_arr_ea)
      }
    );
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  uu____0 = clone_91_e3(&self->ind_cpa_public_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef){
        .ind_cpa_public_key = uu____0,
        .public_key_hash = core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
          &self->public_key_hash,
          uint8_t,
          Eurydice_arr_ec)
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.to_unsigned_field_modulus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE __m256i to_unsigned_field_modulus_84(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.serialize_uncompressed_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_b20
serialize_uncompressed_ring_element_84(const Eurydice_arr_13 *re)
{
  Eurydice_arr_b20 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = to_unsigned_field_modulus_84(re->data[i0]);
    Eurydice_arr_94 bytes = libcrux_ml_kem_vector_avx2_serialize_12_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)24U * i0,
            .end = (size_t)24U * i0 + (size_t)24U
          }
        )),
      Eurydice_array_to_slice_shared_ed(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
serialize_vector_e3(const Eurydice_arr_60 *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_79(
  const Eurydice_arr_60 *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_5f *serialized
)
{
  serialize_vector_e3(t_as_ntt,
    Eurydice_array_to_subslice_mut_d415(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f4(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self,
  Eurydice_arr_5f *serialized
)
{
  serialize_public_key_mut_79(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialize_public_key_79(const Eurydice_arr_60 *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_5f public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_79(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialized_dd_79(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self)
{
  return
    libcrux_ml_kem_types_from_51_3d(serialize_public_key_79(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return serialized_dd_79(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair768
serialize_unpacked_secret_key_15(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_60 *private_key
)
{
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_79(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_0e secret_key_serialized = { .data = { 0U } };
  serialize_vector_e3(private_key, Eurydice_array_to_slice_mut_f4(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair768){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 =
    serialize_unpacked_secret_key_15(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(Eurydice_array_to_slice_shared_f4(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_ff(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  Eurydice_arr_7d sk = libcrux_ml_kem_types_default_d3_79();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(self, &sk);
  return sk;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_uncompressed_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_to_uncompressed_ring_element_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_avx2_deserialize_12_f5(bytes);
  }
  return re;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_vector_e3(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_60 *secret_as_ntt)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0a_7e1(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60 sample_from_xof_7e1(const Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1b
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(seeds);
  Eurydice_arr_7e
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_79(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(&xof_state);
      done = sample_from_uniform_distribution_next_790(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_60 arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e1(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e1(Eurydice_arr_ea *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_60 sampled = sample_from_xof_7e1(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_101(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_e3(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1152U);
  Eurydice_arr_ea *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e1(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_shared_51(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_e3(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_101(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)1152U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_60 default_70_e3(void)
{
  Eurydice_arr_60 lit;
  Eurydice_arr_13 repeat_expression[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef default_8b_e3(void)
{
  Eurydice_arr_60 uu____0;
  Eurydice_arr_13 repeat_expression0[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)3U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_60 repeat_expression1[3U];
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    Eurydice_arr_60 lit;
    Eurydice_arr_13 repeat_expression[3U];
    KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)3U * sizeof (Eurydice_arr_60));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_default_30_e3(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef){
        .ind_cpa_public_key = default_8b_e3(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_e3(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef
  uu____0 =
    { .ind_cpa_private_key = default_70_e3(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_e3()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_78(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_b6(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)3U;
  return G_41_78(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_58 PRFxN_3b(const Eurydice_arr_801 *input)
{
  Eurydice_arr_58
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(&input->data[1U]),
    Eurydice_array_to_slice_shared_b5(&input->data[2U]),
    Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_58 PRFxN_41_3b(const Eurydice_arr_801 *input)
{
  return PRFxN_3b(input);
}

/**
 Given a series of uniformly random bytes in `randomness`, for some number `eta`,
 the `sample_from_binomial_distribution_{eta}` functions sample
 a ring element from a binomial distribution centered at 0 that uses two sets
 of `eta` coin flips. If, for example,
 `eta = ETA`, each ring coefficient is a value `v` such
 such that `v ∈ {-ETA, -ETA + 1, ..., 0, ..., ETA + 1, ETA}` and:

 ```plaintext
 - If v < 0, Pr[v] = Pr[-v]
 - If v >= 0, Pr[v] = BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2 ^ (2 * ETA)
 ```

 The values `v < 0` are mapped to the appropriate `KyberFieldElement`.

 The expected value is:

 ```plaintext
 E[X] = (-ETA)Pr[-ETA] + (-(ETA - 1))Pr[-(ETA - 1)] + ... + (ETA - 1)Pr[ETA - 1] + (ETA)Pr[ETA]
      = 0 since Pr[-v] = Pr[v] when v < 0.
 ```

 And the variance is:

 ```plaintext
 Var(X) = E[(X - E[X])^2]
        = E[X^2]
        = sum_(v=-ETA to ETA)v^2 * (BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2^(2 * ETA))
        = ETA / 2
 ```

 This function implements <strong>Algorithm 7</strong> of the NIST FIPS 203 standard, which is
 reproduced below:

 ```plaintext
 Input: byte array B ∈ 𝔹^{64η}.
 Output: array f ∈ ℤ₂₅₆.

 b ← BytesToBits(B)
 for (i ← 0; i < 256; i++)
     x ← ∑(j=0 to η - 1) b[2iη + j]
     y ← ∑(j=0 to η - 1) b[2iη + η + j]
     f[i] ← x−y mod q
 end for
 return f
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_2_84(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)4U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_shared_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)4U,
            .end = chunk_number * (size_t)4U + (size_t)4U
          }
        ));
    uint32_t
    random_bits_as_u32 =
      (((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U)
      | (uint32_t)byte_chunk.ptr[3U] << 24U;
    uint32_t even_bits = random_bits_as_u32 & 1431655765U;
    uint32_t odd_bits = random_bits_as_u32 >> 1U & 1431655765U;
    uint32_t coin_toss_outcomes = even_bits + odd_bits;
    for (uint32_t i = 0U; i < 32U / 4U; i++)
    {
      uint32_t outcome_set = i;
      uint32_t outcome_set0 = outcome_set * 4U;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 3U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 2U) & 3U);
      size_t offset = (size_t)(outcome_set0 >> 2U);
      sampled_i16s.data[(size_t)8U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_84(Eurydice_array_to_slice_shared_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_3_84(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)3U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_shared_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)3U,
            .end = chunk_number * (size_t)3U + (size_t)3U
          }
        ));
    uint32_t
    random_bits_as_u24 =
      ((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U;
    uint32_t first_bits = random_bits_as_u24 & 2396745U;
    uint32_t second_bits = random_bits_as_u24 >> 1U & 2396745U;
    uint32_t third_bits = random_bits_as_u24 >> 2U & 2396745U;
    uint32_t coin_toss_outcomes = first_bits + second_bits + third_bits;
    for (int32_t i = 0; i < 24 / 6; i++)
    {
      int32_t outcome_set = i;
      int32_t outcome_set0 = outcome_set * 6;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 7U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 3) & 7U);
      size_t offset = (size_t)(outcome_set0 / 6);
      sampled_i16s.data[(size_t)4U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_84(Eurydice_array_to_slice_shared_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- ETA= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_16(Eurydice_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_2_84(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_7_84(Eurydice_arr_13 *re)
{
  size_t step = LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT / (size_t)2U;
  for (size_t i = (size_t)0U; i < step; i++)
  {
    size_t j = i;
    __m256i t = libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(re->data[j + step], -1600);
    re->data[j + step] = libcrux_ml_kem_vector_avx2_sub_f5(re->data[j], &t);
    re->data[j] = libcrux_ml_kem_vector_avx2_add_f5(re->data[j], &t);
  }
}

typedef struct libcrux_ml_kem_vector_avx2_SIMD256Vector_x2_s
{
  __m256i fst;
  __m256i snd;
}
libcrux_ml_kem_vector_avx2_SIMD256Vector_x2;

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_layer_int_vec_step
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
ntt_layer_int_vec_step_84(__m256i a, __m256i b, int16_t zeta_r)
{
  __m256i t = libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(b, zeta_r);
  b = libcrux_ml_kem_vector_avx2_sub_f5(a, &t);
  a = libcrux_ml_kem_vector_avx2_add_f5(a, &t);
  return (KRML_CLITERAL(libcrux_ml_kem_vector_avx2_SIMD256Vector_x2){ .fst = a, .snd = b });
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
ntt_at_layer_4_plus_84(size_t *zeta_i, Eurydice_arr_13 *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]++;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / (size_t)16U;
    size_t step_vec = step / (size_t)16U;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
      uu____0 =
        ntt_layer_int_vec_step_84(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      __m256i x = uu____0.fst;
      __m256i y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_3_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U])););
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_2_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U));
    zeta_i[0U]++;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_1_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)3U));
    zeta_i[0U] += (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_84(Eurydice_arr_13 *myself)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(myself->data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_d6_84(Eurydice_arr_13 *self)
{
  poly_barrett_reduce_84(self);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_binomially_sampled_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_binomially_sampled_ring_element_84(Eurydice_arr_13 *re)
{
  ntt_at_layer_7_84(re);
  size_t zeta_i = (size_t)1U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d61(
  Eurydice_arr_60 *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_41_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_73_ab1(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two `KyberPolynomialRingElement`s in their NTT representations,
 compute their product. Given two polynomials in the NTT domain `f^` and `ĵ`,
 the `iᵗʰ` coefficient of the product `k̂` is determined by the calculation:

 ```plaintext
 ĥ[2·i] + ĥ[2·i + 1]X = (f^[2·i] + f^[2·i + 1]X)·(ĝ[2·i] + ĝ[2·i + 1]X) mod (X² - ζ^(2·BitRev₇(i) + 1))
 ```

 This function almost implements <strong>Algorithm 10</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input: Two arrays fˆ ∈ ℤ₂₅₆ and ĝ ∈ ℤ₂₅₆.
 Output: An array ĥ ∈ ℤq.

 for(i ← 0; i < 128; i++)
     (ĥ[2i], ĥ[2i+1]) ← BaseCaseMultiply(fˆ[2i], fˆ[2i+1], ĝ[2i], ĝ[2i+1], ζ^(2·BitRev₇(i) + 1))
 end for
 return ĥ
 ```
 We say "almost" because the coefficients of the ring element output by
 this function are in the Montgomery domain.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
ntt_multiply_84(const Eurydice_arr_13 *myself, const Eurydice_arr_13 *rhs)
{
  Eurydice_arr_13 out = ZERO_84();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    out.data[i0] =
      libcrux_ml_kem_vector_avx2_ntt_multiply_f5(&myself->data[i0],
        &rhs->data[i0],
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)3U));
  }
  return out;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
ntt_multiply_d6_84(const Eurydice_arr_13 *self, const Eurydice_arr_13 *rhs)
{
  return ntt_multiply_84(self, rhs);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_e3(Eurydice_arr_13 *myself, const Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_e3(Eurydice_arr_13 *self, const Eurydice_arr_13 *rhs)
{
  add_to_ring_element_e3(self, rhs);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.to_standard_domain
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE __m256i to_standard_domain_84(__m256i vector)
{
  return
    libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(vector,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_84(Eurydice_arr_13 *myself, const Eurydice_arr_13 *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    __m256i coefficient_normal_form = to_standard_domain_84(myself->data[j]);
    __m256i sum = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &error->data[j]);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_d6_84(Eurydice_arr_13 *self, const Eurydice_arr_13 *error)
{
  add_standard_error_reduce_84(self, error);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
compute_As_plus_e_e3(
  Eurydice_arr_60 *t_as_ntt,
  const Eurydice_arr_ea *matrix_A,
  const Eurydice_arr_60 *s_as_ntt,
  const Eurydice_arr_60 *error_as_ntt
)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_60 *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR3(i1,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_e3(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab1(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_60 *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_b6(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_ea *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_281(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d61(private_key, &prf_input, 0U);
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab1(&lvalue););
  Eurydice_arr_60 error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d61(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_e3(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_b4_e3(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_60 call_mut_22_e3(void **_)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_e3(&lvalue););
  return arr_struct;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.clone_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static inline Eurydice_arr_13 clone_c1_84(const Eurydice_arr_13 *self)
{
  return
    core_array__core__clone__Clone_for__T__N___clone((size_t)16U,
      self,
      __m256i,
      Eurydice_arr_13);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_ea transpose_a_e3(Eurydice_arr_ea ind_cpa_a)
{
  Eurydice_arr_ea arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_e3(&lvalue););
  Eurydice_arr_ea A = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab1(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_ea A = transpose_a_e3(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_5f
  pk_serialized =
    serialize_public_key_79(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_78(Eurydice_array_to_slice_shared_ff(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static Eurydice_arr_c7
encaps_prepare_b6(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_78(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_60, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_7f_s
{
  Eurydice_arr_60 fst;
  Eurydice_arr_13 snd;
}
tuple_7f;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_781(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_781(void **_)
{
  return ZERO_d6_84();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d61(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_60 *error_1
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_41_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF
with const generics
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_ec(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_89 digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_3b0(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_a8_e3(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_1_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)3U));
    zeta_i[0U] -= (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_2_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U));
    zeta_i[0U]--;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_3_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U])););
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.inv_ntt_layer_int_vec_step_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
inv_ntt_layer_int_vec_step_reduce_84(__m256i a, __m256i b, int16_t zeta_r)
{
  __m256i a_minus_b = libcrux_ml_kem_vector_avx2_sub_f5(b, &a);
  a = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(libcrux_ml_kem_vector_avx2_add_f5(a, &b));
  b = libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(a_minus_b, zeta_r);
  return (KRML_CLITERAL(libcrux_ml_kem_vector_avx2_SIMD256Vector_x2){ .fst = a, .snd = b });
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
invert_ntt_at_layer_4_plus_84(size_t *zeta_i, Eurydice_arr_13 *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]--;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    size_t step_vec = step / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
      uu____0 =
        inv_ntt_layer_int_vec_step_reduce_84(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      __m256i x = uu____0.fst;
      __m256i y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_e3(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_84(Eurydice_arr_13 *myself, const Eurydice_arr_13 *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(myself->data[j],
        1441);
    __m256i sum = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &error->data[j]);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_d6_84(Eurydice_arr_13 *self, const Eurydice_arr_13 *error)
{
  add_error_reduce_84(self, error);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60
compute_vector_u_e3(
  const Eurydice_arr_ea *a_as_ntt,
  const Eurydice_arr_60 *r_as_ntt,
  const Eurydice_arr_60 *error_1
)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_e3(&lvalue););
  Eurydice_arr_60 result = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_60 *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_e3(&result.data[i1], &product););
    invert_ntt_montgomery_e3(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_ef(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)10) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(10, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(10, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_ef(__m256i vector)
{
  return compress_ciphertext_coefficient_ef(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_f5_ef(__m256i vector)
{
  return compress_ef(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_10
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0 compress_then_serialize_10_03(const Eurydice_arr_13 *re)
{
  Eurydice_arr_b0 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = compress_f5_ef(to_unsigned_field_modulus_84(re->data[i0]));
    Eurydice_arr_fc bytes = libcrux_ml_kem_vector_avx2_serialize_10_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d49(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)20U * i0,
            .end = (size_t)20U * i0 + (size_t)20U
          }
        )),
      Eurydice_array_to_slice_shared_8f(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_c4(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)11) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(11, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(11, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_c4(__m256i vector)
{
  return compress_ciphertext_coefficient_c4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_f5_c4(__m256i vector)
{
  return compress_c4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 10
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0
compress_then_serialize_ring_element_u_81(const Eurydice_arr_13 *re)
{
  return compress_then_serialize_10_03(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- OUT_LEN= 960
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_d4(Eurydice_arr_60 input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)960U / (size_t)3U),
            .end = (i0 + (size_t)1U) * ((size_t)960U / (size_t)3U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_81(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_7f
encrypt_c1_781(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_ea *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_60 arr_struct0;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_781(&lvalue););
  Eurydice_arr_60 r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d61(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_781(&lvalue););
  Eurydice_arr_60 error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_d61(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_3b0(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_60 u = compute_vector_u_e3(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_d4(u, ciphertext);
  return (KRML_CLITERAL(tuple_7f){ .fst = r_as_ntt, .snd = error_2 });
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_message_84(const Eurydice_arr_ec *serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    __m256i
    coefficient_compressed =
      libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_array_to_subslice_shared_d4(serialized,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = (size_t)2U * i0,
              .end = (size_t)2U * i0 + (size_t)2U
            }
          )));
    re.data[i0] = libcrux_ml_kem_vector_avx2_decompress_1_f5(coefficient_compressed););
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
add_message_error_reduce_84(
  const Eurydice_arr_13 *myself,
  const Eurydice_arr_13 *message,
  Eurydice_arr_13 result
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(result.data[i0],
        1441);
    __m256i sum1 = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &message->data[i0]);
    __m256i sum2 = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &sum1);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum2);
    result.data[i0] = red;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
add_message_error_reduce_d6_84(
  const Eurydice_arr_13 *self,
  const Eurydice_arr_13 *message,
  Eurydice_arr_13 result
)
{
  return add_message_error_reduce_84(self, message, result);
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_e3(
  const Eurydice_arr_60 *t_as_ntt,
  const Eurydice_arr_60 *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_e3(&result, &product););
  invert_ntt_montgomery_e3(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_d1(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)4) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(4, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(4, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_d1(__m256i vector)
{
  return compress_ciphertext_coefficient_d1(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_f5_d1(__m256i vector)
{
  return compress_d1(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_4_84(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = compress_f5_d1(to_unsigned_field_modulus_84(re.data[i0]));
    Eurydice_array_u8x8 bytes = libcrux_ml_kem_vector_avx2_serialize_4_f5(coefficient);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)8U * i0,
            .end = (size_t)8U * i0 + (size_t)8U
          }
        )),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_f4(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)5) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(5, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(5, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_f4(__m256i vector)
{
  return compress_ciphertext_coefficient_f4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_f5_f4(__m256i vector)
{
  return compress_f4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_5
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_5_84(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficients =
      compress_f5_f4(libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(re.data[i0]));
    Eurydice_arr_6d bytes = libcrux_ml_kem_vector_avx2_serialize_5_f5(coefficients);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)10U * i0,
            .end = (size_t)10U * i0 + (size_t)10U
          }
        )),
      Eurydice_array_to_slice_shared_30(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_15(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_15(
  const Eurydice_arr_60 *t_as_ntt,
  const Eurydice_arr_60 *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_e3(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_15(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_unpacked_281(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_2b ciphertext = { .data = { 0U } };
  tuple_7f
  uu____0 =
    encrypt_c1_781(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d414(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)960U })));
  Eurydice_arr_60 r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_15(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f3(&ciphertext, (size_t)960U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_b6(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_unpacked_281(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_f4){
        .fst = libcrux_ml_kem_types_from_19_52(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_13 call_mut_35_15(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_ef(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)10));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(10, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(10, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_ef(__m256i vector)
{
  return decompress_ciphertext_coefficient_ef(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_10
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_10_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)20U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)20U,
            .end = i0 * (size_t)20U + (size_t)20U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_10_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_ef(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_c4(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)11));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(11, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(11, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_c4(__m256i vector)
{
  return decompress_ciphertext_coefficient_c4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_11_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)22U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)22U,
            .end = i0 * (size_t)22U + (size_t)22U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_11_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_c4(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_u_d0(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_10_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE void ntt_vector_u_d0(Eurydice_arr_13 *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_60
deserialize_then_decompress_u_15(const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_15(&lvalue););
  Eurydice_arr_60 u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1088U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d46(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_d0(u_bytes);
    ntt_vector_u_d0(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_d1(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)4));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(4, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(4, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_d1(__m256i vector)
{
  return decompress_ciphertext_coefficient_d1(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_4_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)8U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)8U,
            .end = i0 * (size_t)8U + (size_t)8U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_4_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_d1(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f4(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)5));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(5, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(5, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_f4(__m256i vector)
{
  return decompress_ciphertext_coefficient_f4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_5
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_5_84(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)10U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)10U,
            .end = i0 * (size_t)10U + (size_t)10U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_avx2_deserialize_5_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_f4(re.data[i0]);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_79(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
subtract_reduce_84(const Eurydice_arr_13 *myself, Eurydice_arr_13 b)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(b.data[i0],
        1441);
    __m256i diff = libcrux_ml_kem_vector_avx2_sub_f5(myself->data[i0], &coefficient_normal_form);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(diff);
    b.data[i0] = red;
  }
  return b;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
subtract_reduce_d6_84(const Eurydice_arr_13 *self, Eurydice_arr_13 b)
{
  return subtract_reduce_84(self, b);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_e3(
  const Eurydice_arr_13 *v,
  const Eurydice_arr_60 *secret_as_ntt,
  const Eurydice_arr_60 *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_e3(&result, &product););
  invert_ntt_montgomery_e3(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_ec compress_then_serialize_message_84(Eurydice_arr_13 re)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    __m256i coefficient = to_unsigned_field_modulus_84(re.data[i0]);
    __m256i coefficient_compressed = libcrux_ml_kem_vector_avx2_compress_1_f5(coefficient);
    Eurydice_array_u8x2 bytes = libcrux_ml_kem_vector_avx2_serialize_1_f5(coefficient_compressed);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)2U * i0,
            .end = (size_t)2U * i0 + (size_t)2U
          }
        )),
      Eurydice_array_to_slice_shared_82(&bytes),
      uint8_t););
  return serialized;
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_3e(const Eurydice_arr_60 *secret_key, const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 u_as_ntt = deserialize_then_decompress_u_15(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_79(Eurydice_array_to_subslice_from_shared_5f2(ciphertext,
        (size_t)960U));
  Eurydice_arr_13 message = compute_message_e3(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF
with const generics
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_ce(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 3
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_3b(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(
  const libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_3e(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_66(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f2(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_3b(Eurydice_array_to_slice_shared_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext =
    encrypt_unpacked_281(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_06(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0b_e3(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60
deserialize_ring_elements_reduced_out_e3(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_e3(&lvalue););
  Eurydice_arr_60 deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_e3(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_79(const Eurydice_arr_5f *public_key)
{
  Eurydice_arr_60
  deserialized_pk =
    deserialize_ring_elements_reduced_out_e3(Eurydice_array_to_subslice_to_shared_211(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_79(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f3(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  return Eurydice_array_eq((size_t)1184U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_a4(const Eurydice_arr_7d *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_78(Eurydice_array_to_subslice_shared_d47(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)3U,
            .end = (size_t)768U * (size_t)3U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d47(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)3U + (size_t)32U,
          .end = (size_t)768U * (size_t)3U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d50(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_a4(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair768
generate_keypair_cc1(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_60 private_key = default_70_e3();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef public_key = default_8b_e3();
  generate_keypair_unpacked_ab1(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_15(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_a4(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_78(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE Eurydice_arr_7d
serialize_kem_secret_key_a4(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_7d out = { .data = { 0U } };
  serialize_kem_secret_key_mut_a4(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db1(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 = generate_keypair_cc1(ind_cpa_keypair_randomness);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f public_key = uu____0.snd;
  Eurydice_arr_7d
  secret_key_serialized =
    serialize_kem_secret_key_a4(Eurydice_array_to_slice_shared_f4(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_ff(&public_key),
      implicit_rejection_value);
  Eurydice_arr_7d private_key = libcrux_ml_kem_types_from_b2_79(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_bc(private_key,
      libcrux_ml_kem_types_from_51_3d(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_b6(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_911(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_e3(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1152U);
  Eurydice_arr_ea *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_281(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
build_unpacked_public_key_911(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  unpacked_public_key = default_8b_e3();
  build_unpacked_public_key_mut_911(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_281(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  unpacked_public_key = build_unpacked_public_key_911(public_key);
  return encrypt_unpacked_281(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_a4(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_a11(
  const Eurydice_arr_5f *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_b6(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_78(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_281(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_2b uu____2 = libcrux_ml_kem_types_from_19_52(ciphertext);
  return (KRML_CLITERAL(tuple_f4){ .fst = uu____2, .snd = kdf_39_a4(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_13 call_mut_0b_3e(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_3e(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_3e(&lvalue););
  Eurydice_arr_60 secret_key_unpacked = arr_struct;
  deserialize_vector_e3(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_3e(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_661(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_shared_51(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_3e(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af to_hash = libcrux_ml_kem_utils_into_padded_array_66(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f2(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_3b(Eurydice_array_to_slice_shared_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext = encrypt_281(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_a4(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_a4(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_06(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_5b(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_3b *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_23(const Eurydice_arr_56 *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_shared_e9(input->data),
    Eurydice_array_to_slice_shared_e9(&input->data[1U]),
    Eurydice_array_to_slice_shared_e9(&input->data[2U]),
    Eurydice_array_to_slice_shared_e9(&input->data[3U]));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_23(const Eurydice_arr_56 *input)
{
  return shake128_init_absorb_final_23(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_7c0
shake128_squeeze_first_three_blocks_23(Eurydice_arr_c40 *st)
{
  Eurydice_arr_7c0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_7c0
shake128_squeeze_first_three_blocks_41_23(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_74(
  const Eurydice_arr_7c0 *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9c shake128_squeeze_next_block_23(Eurydice_arr_c40 *st)
{
  Eurydice_arr_9c
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9c
shake128_squeeze_next_block_41_23(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_740(
  const Eurydice_arr_9c *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0a_280(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b sample_from_xof_280(const Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_23(seeds);
  Eurydice_arr_7c0 randomness0 = shake128_squeeze_first_three_blocks_41_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_74(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c randomness = shake128_squeeze_next_block_41_23(&xof_state);
      done = sample_from_uniform_distribution_next_740(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_3b arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_280(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_280(Eurydice_arr_cd *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_3b sampled = sample_from_xof_280(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_23(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_212(public_key, (size_t)1536U);
  deserialize_ring_elements_reduced_5b(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f4(public_key,
        (size_t)1536U));
  Eurydice_arr_cd *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f4(public_key,
        (size_t)1536U));
  sample_matrix_A_280(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_23(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
serialize_vector_5b(const Eurydice_arr_3b *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_74(
  const Eurydice_arr_3b *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_d1 *serialized
)
{
  serialize_vector_5b(t_as_ntt,
    Eurydice_array_to_subslice_mut_d419(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f6(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self,
  Eurydice_arr_d1 *serialized
)
{
  serialize_public_key_mut_74(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialize_public_key_74(const Eurydice_arr_3b *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_d1 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_74(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialized_dd_74(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self)
{
  return
    libcrux_ml_kem_types_from_51_d9(serialize_public_key_74(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  return serialized_dd_74(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair1024
serialize_unpacked_secret_key_72(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_3b *private_key
)
{
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_74(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_df secret_key_serialized = { .data = { 0U } };
  serialize_vector_5b(private_key, Eurydice_array_to_slice_mut_2f(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair1024){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 =
    serialize_unpacked_secret_key_72(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(Eurydice_array_to_slice_shared_2f(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_b50(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  Eurydice_arr_a8 sk = libcrux_ml_kem_types_default_d3_0e();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_vector_5b(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_3b *secret_as_ntt)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0a_7e0(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b sample_from_xof_7e0(const Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_4a
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(seeds);
  Eurydice_arr_7c0
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_74(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(&xof_state);
      done = sample_from_uniform_distribution_next_740(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_3b arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e0(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e0(Eurydice_arr_cd *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_3b sampled = sample_from_xof_7e0(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_100(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_5b(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1536U);
  Eurydice_arr_cd *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e0(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_shared_68(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_5b(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_100(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)1536U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_3b default_70_5b(void)
{
  Eurydice_arr_3b lit;
  Eurydice_arr_13 repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 default_8b_5b(void)
{
  Eurydice_arr_3b uu____0;
  Eurydice_arr_13 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_3b repeat_expression1[4U];
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    Eurydice_arr_3b lit;
    Eurydice_arr_13 repeat_expression[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_3b));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_ind_cca_unpacked_default_30_5b(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4){
        .ind_cpa_public_key = default_8b_5b(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_5b(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4
  uu____0 =
    { .ind_cpa_private_key = default_70_5b(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_5b()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_23(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_39(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)4U;
  return G_41_23(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_3b0 PRFxN_f5(const Eurydice_arr_890 *input)
{
  Eurydice_arr_3b0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(&input->data[1U]),
    Eurydice_array_to_slice_shared_b5(&input->data[2U]),
    Eurydice_array_to_slice_shared_b5(&input->data[3U]),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_3b0 PRFxN_41_f5(const Eurydice_arr_890 *input)
{
  return PRFxN_f5(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d60(
  Eurydice_arr_3b *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_41_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_73_ab0(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_5b(Eurydice_arr_13 *myself, const Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_5b(Eurydice_arr_13 *self, const Eurydice_arr_13 *rhs)
{
  add_to_ring_element_5b(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
compute_As_plus_e_5b(
  Eurydice_arr_3b *t_as_ntt,
  const Eurydice_arr_cd *matrix_A,
  const Eurydice_arr_3b *s_as_ntt,
  const Eurydice_arr_3b *error_as_ntt
)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_3b *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR4(i1,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_5b(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab0(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_3b *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_39(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_cd *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_280(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d60(private_key, &prf_input, 0U);
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab0(&lvalue););
  Eurydice_arr_3b error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d60(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_5b(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_b4_5b(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_3b call_mut_22_5b(void **_)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_5b(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_cd transpose_a_5b(Eurydice_arr_cd ind_cpa_a)
{
  Eurydice_arr_cd arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_5b(&lvalue););
  Eurydice_arr_cd A = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab0(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_cd A = transpose_a_5b(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_d1
  pk_serialized =
    serialize_public_key_74(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_23(Eurydice_array_to_slice_shared_b50(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static Eurydice_arr_c7
encaps_prepare_39(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_23(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_3b, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_03_s
{
  Eurydice_arr_3b fst;
  Eurydice_arr_13 snd;
}
tuple_03;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_780(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_780(void **_)
{
  return ZERO_d6_84();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d60(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_3b *error_1
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_41_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_f50(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_a8_5b(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_5b(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b
compute_vector_u_5b(
  const Eurydice_arr_cd *a_as_ntt,
  const Eurydice_arr_3b *r_as_ntt,
  const Eurydice_arr_3b *error_1
)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_5b(&lvalue););
  Eurydice_arr_3b result = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_3b *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_5b(&result.data[i1], &product););
    invert_ntt_montgomery_5b(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7 compress_then_serialize_11_fe(const Eurydice_arr_13 *re)
{
  Eurydice_arr_e7 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient =
      compress_f5_c4(libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(re->data[i0]));
    Eurydice_arr_80 bytes = libcrux_ml_kem_vector_avx2_serialize_11_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)22U * i0,
            .end = (size_t)22U * i0 + (size_t)22U
          }
        )),
      Eurydice_array_to_slice_shared_98(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 11
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7
compress_then_serialize_ring_element_u_d4(const Eurydice_arr_13 *re)
{
  return compress_then_serialize_11_fe(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- OUT_LEN= 1408
- COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_f8(Eurydice_arr_3b input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)1408U / (size_t)4U),
            .end = (i0 + (size_t)1U) * ((size_t)1408U / (size_t)4U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_e7 lvalue = compress_then_serialize_ring_element_u_d4(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_25(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_03
encrypt_c1_780(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_cd *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_3b arr_struct0;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_780(&lvalue););
  Eurydice_arr_3b r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d60(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_780(&lvalue););
  Eurydice_arr_3b error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_d60(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_f50(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_3b u = compute_vector_u_5b(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_f8(u, ciphertext);
  return (KRML_CLITERAL(tuple_03){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_5b(
  const Eurydice_arr_3b *t_as_ntt,
  const Eurydice_arr_3b *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_5b(&result, &product););
  invert_ntt_montgomery_5b(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
- OUT_LEN= 160
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_72(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_5_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- V_COMPRESSION_FACTOR= 5
- C2_LEN= 160
*/
static KRML_MUSTINLINE void
encrypt_c2_72(
  const Eurydice_arr_3b *t_as_ntt,
  const Eurydice_arr_3b *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_5b(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_72(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_unpacked_280(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d1 ciphertext = { .data = { 0U } };
  tuple_03
  uu____0 =
    encrypt_c1_780(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d419(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)1408U })));
  Eurydice_arr_3b r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_72(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f6(&ciphertext, (size_t)1408U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_39(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_unpacked_280(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_25){
        .fst = libcrux_ml_kem_types_from_19_d9(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static Eurydice_arr_13 call_mut_35_72(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_u_95(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_11_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE void ntt_vector_u_95(Eurydice_arr_13 *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_3b
deserialize_then_decompress_u_72(const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_72(&lvalue););
  Eurydice_arr_3b u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1568U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d48(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_95(u_bytes);
    ntt_vector_u_95(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_74(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_5_84(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_5b(
  const Eurydice_arr_13 *v,
  const Eurydice_arr_3b *secret_as_ntt,
  const Eurydice_arr_3b *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_5b(&result, &product););
  invert_ntt_montgomery_5b(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_b2(const Eurydice_arr_3b *secret_key, const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b u_as_ntt = deserialize_then_decompress_u_72(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_74(Eurydice_array_to_subslice_from_shared_5f4(ciphertext,
        (size_t)1408U));
  Eurydice_arr_13 message = compute_message_5b(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 4
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_f5(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(
  const libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_b2(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_49(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f5(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_f5(Eurydice_array_to_slice_shared_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext =
    encrypt_unpacked_280(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_b50(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0b_5b(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b
deserialize_ring_elements_reduced_out_5b(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_5b(&lvalue););
  Eurydice_arr_3b deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_5b(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_74(const Eurydice_arr_d1 *public_key)
{
  Eurydice_arr_3b
  deserialized_pk =
    deserialize_ring_elements_reduced_out_5b(Eurydice_array_to_subslice_to_shared_212(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_74(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f4(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  return Eurydice_array_eq((size_t)1568U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_f8(const Eurydice_arr_a8 *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_23(Eurydice_array_to_subslice_shared_d49(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)4U,
            .end = (size_t)768U * (size_t)4U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d49(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)4U + (size_t)32U,
          .end = (size_t)768U * (size_t)4U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_b3(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_f8(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair1024
generate_keypair_cc0(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_3b private_key = default_70_5b();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 public_key = default_8b_5b();
  generate_keypair_unpacked_ab0(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_72(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_f8(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_23(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE Eurydice_arr_a8
serialize_kem_secret_key_f8(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_a8 out = { .data = { 0U } };
  serialize_kem_secret_key_mut_f8(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db0(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 = generate_keypair_cc0(ind_cpa_keypair_randomness);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 public_key = uu____0.snd;
  Eurydice_arr_a8
  secret_key_serialized =
    serialize_kem_secret_key_f8(Eurydice_array_to_slice_shared_2f(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_b50(&public_key),
      implicit_rejection_value);
  Eurydice_arr_a8 private_key = libcrux_ml_kem_types_from_b2_0e(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_70(private_key,
      libcrux_ml_kem_types_from_51_d9(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_39(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_910(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_5b(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1536U);
  Eurydice_arr_cd *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_280(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
build_unpacked_public_key_910(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
  unpacked_public_key = default_8b_5b();
  build_unpacked_public_key_mut_910(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_280(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
  unpacked_public_key = build_unpacked_public_key_910(public_key);
  return encrypt_unpacked_280(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_f8(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_a10(
  const Eurydice_arr_d1 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_39(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_23(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_280(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d1 uu____2 = libcrux_ml_kem_types_from_19_d9(ciphertext);
  return (KRML_CLITERAL(tuple_25){ .fst = uu____2, .snd = kdf_39_f8(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static Eurydice_arr_13 call_mut_0b_b2(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_b2(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_b2(&lvalue););
  Eurydice_arr_3b secret_key_unpacked = arr_struct;
  deserialize_vector_5b(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_b2(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_660(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_shared_68(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_b2(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14 to_hash = libcrux_ml_kem_utils_into_padded_array_49(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f5(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_f5(Eurydice_array_to_slice_shared_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext = encrypt_280(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_f8(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_f8(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_b50(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_16(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_ee *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_af(const Eurydice_arr_bf *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_shared_e9(input->data),
    Eurydice_array_to_slice_shared_e9(&input->data[1U]),
    Eurydice_array_to_slice_shared_e9(input->data),
    Eurydice_array_to_slice_shared_e9(input->data));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_af(const Eurydice_arr_bf *input)
{
  return shake128_init_absorb_final_af(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_b8
shake128_squeeze_first_three_blocks_af(Eurydice_arr_c40 *st)
{
  Eurydice_arr_b8 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_b8
shake128_squeeze_first_three_blocks_41_af(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_ce(
  const Eurydice_arr_b8 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_5b0 shake128_squeeze_next_block_af(Eurydice_arr_c40 *st)
{
  Eurydice_arr_5b0 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_5b0
shake128_squeeze_next_block_41_af(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_ce0(
  const Eurydice_arr_5b0 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0a_28(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee sample_from_xof_28(const Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_af(seeds);
  Eurydice_arr_b8 randomness0 = shake128_squeeze_first_three_blocks_41_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_ce(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0 randomness = shake128_squeeze_next_block_41_af(&xof_state);
      done = sample_from_uniform_distribution_next_ce0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_ee arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_28(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_28(Eurydice_arr_e2 *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_ee sampled = sample_from_xof_28(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_af(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_210(public_key, (size_t)768U);
  deserialize_ring_elements_reduced_16(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f1(public_key,
        (size_t)768U));
  Eurydice_arr_e2 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f1(public_key,
        (size_t)768U));
  sample_matrix_A_28(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_af(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
serialize_vector_16(const Eurydice_arr_ee *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_ce(
  const Eurydice_arr_ee *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_03 *serialized
)
{
  serialize_vector_16(t_as_ntt,
    Eurydice_array_to_subslice_mut_d46(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self,
  Eurydice_arr_03 *serialized
)
{
  serialize_public_key_mut_ce(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialize_public_key_ce(const Eurydice_arr_ee *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_03 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_ce(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialized_dd_ce(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self)
{
  return
    libcrux_ml_kem_types_from_51_df(serialize_public_key_ce(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
)
{
  return serialized_dd_ce(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair512
serialize_unpacked_secret_key_e5(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ee *private_key
)
{
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_ce(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_d2 secret_key_serialized = { .data = { 0U } };
  serialize_vector_16(private_key, Eurydice_array_to_slice_mut_27(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair512){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 =
    serialize_unpacked_secret_key_e5(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(Eurydice_array_to_slice_shared_27(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_3b(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
)
{
  Eurydice_arr_ab0 sk = libcrux_ml_kem_types_default_d3_be();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_vector_16(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_ee *secret_as_ntt)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0a_7e(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee sample_from_xof_7e(const Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_e3
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(seeds);
  Eurydice_arr_b8
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_ce(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(&xof_state);
      done = sample_from_uniform_distribution_next_ce0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_ee arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e(Eurydice_arr_e2 *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_ee sampled = sample_from_xof_7e(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_10(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_16(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)768U);
  Eurydice_arr_e2 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_shared_99(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_16(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_10(ind_cpa_public_key, &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)768U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_ee default_70_16(void)
{
  Eurydice_arr_ee lit;
  Eurydice_arr_13 repeat_expression[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 default_8b_16(void)
{
  Eurydice_arr_ee uu____0;
  Eurydice_arr_13 repeat_expression0[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)2U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_ee repeat_expression1[2U];
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    Eurydice_arr_ee lit;
    Eurydice_arr_13 repeat_expression[2U];
    KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)2U * sizeof (Eurydice_arr_ee));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_ind_cca_unpacked_default_30_16(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7){
        .ind_cpa_public_key = default_8b_16(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_16(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7
  uu____0 =
    { .ind_cpa_private_key = default_70_16(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_16()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_af(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_b1(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)2U;
  return G_41_af(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 2
- LEN= 192
*/
static KRML_MUSTINLINE Eurydice_arr_eb PRFxN_d5(const Eurydice_arr_4d *input)
{
  Eurydice_arr_eb out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1c out0 = { .data = { 0U } };
  Eurydice_arr_1c out1 = { .data = { 0U } };
  Eurydice_arr_1c out2 = { .data = { 0U } };
  Eurydice_arr_1c out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(&input->data[1U]),
    Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_mut_d9(&out0),
    Eurydice_array_to_slice_mut_d9(&out1),
    Eurydice_array_to_slice_mut_d9(&out2),
    Eurydice_array_to_slice_mut_d9(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 2
- LEN= 192
*/
static KRML_MUSTINLINE Eurydice_arr_eb PRFxN_41_d5(const Eurydice_arr_4d *input)
{
  return PRFxN_d5(input);
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- ETA= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_e3(Eurydice_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_3_84(randomness);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- ETA= 3
- ETA_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d6(
  Eurydice_arr_ee *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_eb prf_outputs = PRFxN_41_d5(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_e3(Eurydice_array_to_slice_shared_d9(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static Eurydice_arr_13 call_mut_73_ab(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_16(Eurydice_arr_13 *myself, const Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_16(Eurydice_arr_13 *self, const Eurydice_arr_13 *rhs)
{
  add_to_ring_element_16(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
compute_As_plus_e_16(
  Eurydice_arr_ee *t_as_ntt,
  const Eurydice_arr_e2 *matrix_A,
  const Eurydice_arr_ee *s_as_ntt,
  const Eurydice_arr_ee *error_as_ntt
)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_ee *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR2(i1,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_16(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_ee *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_b1(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_e2 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_28(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d6(private_key, &prf_input, 0U);
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab(&lvalue););
  Eurydice_arr_ee error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d6(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_16(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_b4_16(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_ee call_mut_22_16(void **_)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_16(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_e2 transpose_a_16(Eurydice_arr_e2 ind_cpa_a)
{
  Eurydice_arr_e2 arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_16(&lvalue););
  Eurydice_arr_e2 A = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_e2 A = transpose_a_16(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_03
  pk_serialized =
    serialize_public_key_ce(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_af(Eurydice_array_to_slice_shared_3b(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static Eurydice_arr_c7
encaps_prepare_b1(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_af(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_ee, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_91_s
{
  Eurydice_arr_ee fst;
  Eurydice_arr_13 snd;
}
tuple_91;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_78(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_78(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_f3 PRFxN_d50(const Eurydice_arr_4d *input)
{
  Eurydice_arr_f3 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(&input->data[1U]),
    Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_shared_b5(input->data),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_f3 PRFxN_41_d50(const Eurydice_arr_4d *input)
{
  return PRFxN_d50(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d6(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_ee *error_1
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_f3 prf_outputs = PRFxN_41_d50(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_d50(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_a8_16(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_16(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee
compute_vector_u_16(
  const Eurydice_arr_e2 *a_as_ntt,
  const Eurydice_arr_ee *r_as_ntt,
  const Eurydice_arr_ee *error_1
)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_16(&lvalue););
  Eurydice_arr_ee result = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_ee *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_16(&result.data[i1], &product););
    invert_ntt_montgomery_16(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- OUT_LEN= 640
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_4e(Eurydice_arr_ee input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)640U / (size_t)2U),
            .end = (i0 + (size_t)1U) * ((size_t)640U / (size_t)2U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_81(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_91
encrypt_c1_78(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_e2 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_ee arr_struct0;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_78(&lvalue););
  Eurydice_arr_ee r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d6(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_78(&lvalue););
  Eurydice_arr_ee error_1 = arr_struct;
  uint8_t domain_separator = sample_ring_element_cbd_d6(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_d50(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_ee u = compute_vector_u_16(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_4e(u, ciphertext);
  return (KRML_CLITERAL(tuple_91){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_16(
  const Eurydice_arr_ee *t_as_ntt,
  const Eurydice_arr_ee *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_16(&result, &product););
  invert_ntt_montgomery_16(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_e5(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_e5(
  const Eurydice_arr_ee *t_as_ntt,
  const Eurydice_arr_ee *r_as_ntt,
  const Eurydice_arr_13 *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_16(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_e5(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_unpacked_28(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d2 ciphertext = { .data = { 0U } };
  tuple_91
  uu____0 =
    encrypt_c1_78(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d410(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)640U })));
  Eurydice_arr_ee r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_e5(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f1(&ciphertext, (size_t)640U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_b1(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d2
  ciphertext = encrypt_unpacked_28(&public_key->ind_cpa_public_key, randomness, pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_ab){
        .fst = libcrux_ml_kem_types_from_19_80(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_13 call_mut_35_e5(void **_)
{
  return ZERO_d6_84();
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_ee
deserialize_then_decompress_u_e5(const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_e5(&lvalue););
  Eurydice_arr_ee u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)768U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d41(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_d0(u_bytes);
    ntt_vector_u_d0(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_ce(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_84(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_16(
  const Eurydice_arr_13 *v,
  const Eurydice_arr_ee *secret_as_ntt,
  const Eurydice_arr_ee *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_16(&result, &product););
  invert_ntt_montgomery_16(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_a4(const Eurydice_arr_ee *secret_key, const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee u_as_ntt = deserialize_then_decompress_u_e5(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_ce(Eurydice_array_to_subslice_from_shared_5f(ciphertext,
        (size_t)640U));
  Eurydice_arr_13 message = compute_message_16(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 2
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_d5(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(
  const libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_a4(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_df(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_d5(Eurydice_array_to_slice_shared_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext =
    encrypt_unpacked_28(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_27(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0b_16(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee
deserialize_ring_elements_reduced_out_16(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_16(&lvalue););
  Eurydice_arr_ee deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_16(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_ce(const Eurydice_arr_03 *public_key)
{
  Eurydice_arr_ee
  deserialized_pk =
    deserialize_ring_elements_reduced_out_16(Eurydice_array_to_subslice_to_shared_210(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_ce(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f1(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  return Eurydice_array_eq((size_t)800U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_37(const Eurydice_arr_ab0 *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_af(Eurydice_array_to_subslice_shared_d45(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)2U,
            .end = (size_t)768U * (size_t)2U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d45(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)2U + (size_t)32U,
          .end = (size_t)768U * (size_t)2U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_85(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_37(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair512
generate_keypair_cc(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_ee private_key = default_70_16();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 public_key = default_8b_16();
  generate_keypair_unpacked_ab(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_e5(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_37(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_af(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE Eurydice_arr_ab0
serialize_kem_secret_key_37(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_ab0 out = { .data = { 0U } };
  serialize_kem_secret_key_mut_37(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_db(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 = generate_keypair_cc(ind_cpa_keypair_randomness);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 public_key = uu____0.snd;
  Eurydice_arr_ab0
  secret_key_serialized =
    serialize_kem_secret_key_37(Eurydice_array_to_slice_shared_27(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_3b(&public_key),
      implicit_rejection_value);
  Eurydice_arr_ab0 private_key = libcrux_ml_kem_types_from_b2_be(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_d6(private_key,
      libcrux_ml_kem_types_from_51_df(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_b1(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_91(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_16(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)768U);
  Eurydice_arr_e2 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_28(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
build_unpacked_public_key_91(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
  unpacked_public_key = default_8b_16();
  build_unpacked_public_key_mut_91(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_28(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
  unpacked_public_key = build_unpacked_public_key_91(public_key);
  return encrypt_unpacked_28(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_37(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_a1(
  const Eurydice_arr_03 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_b1(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_af(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_28(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d2 uu____2 = libcrux_ml_kem_types_from_19_80(ciphertext);
  return (KRML_CLITERAL(tuple_ab){ .fst = uu____2, .snd = kdf_39_37(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_13 call_mut_0b_a4(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_a4(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_a4(&lvalue););
  Eurydice_arr_ee secret_key_unpacked = arr_struct;
  deserialize_vector_16(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_a4(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_66(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_shared_99(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_a4(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03 to_hash = libcrux_ml_kem_utils_into_padded_array_df(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_d5(Eurydice_array_to_slice_shared_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext = encrypt_28(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_37(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_37(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_27(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem_avx2_H
#define libcrux_mlkem_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_sha3_avx2.h"
#include "libcrux_core.h"

Eurydice_arr_c7 libcrux_ml_kem_hash_functions_avx2_G(Eurydice_borrow_slice_u8 input);

Eurydice_arr_ec libcrux_ml_kem_hash_functions_avx2_H(Eurydice_borrow_slice_u8 input);

typedef libcrux_sha3_avx2_x4_incremental_KeccakState
libcrux_ml_kem_hash_functions_avx2_Simd256Hash;

typedef __m256i libcrux_ml_kem_vector_avx2_SIMD256Vector;

__m256i libcrux_ml_kem_vector_avx2_vec_zero(void);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_ZERO_f5(void);

__m256i libcrux_ml_kem_vector_avx2_vec_from_i16_array(Eurydice_borrow_slice_i16 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_borrow_slice_i16 array);

Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_vec_to_i16_array(__m256i v);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_to_i16_array_f5(__m256i x);

__m256i libcrux_ml_kem_vector_avx2_from_bytes(Eurydice_borrow_slice_u8 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_from_bytes_f5(Eurydice_borrow_slice_u8 array);

void libcrux_ml_kem_vector_avx2_to_bytes(__m256i x, Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
void libcrux_ml_kem_vector_avx2_to_bytes_f5(__m256i x, Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_add(__m256i lhs, __m256i rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_add_f5(__m256i lhs, const __m256i *rhs);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_sub(__m256i lhs, __m256i rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_sub_f5(__m256i lhs, const __m256i *rhs);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(__m256i vector, int16_t constant);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(__m256i vec, int16_t c);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(__m256i vector);

#define LIBCRUX_ML_KEM_VECTOR_AVX2_ARITHMETIC_BARRETT_MULTIPLIER (20159)

/**
 See Section 3.2 of the implementation notes document for an explanation
 of this code.
*/
__m256i libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_barrett_reduce_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i vector,
  int16_t constant
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(__m256i vector, int16_t constant);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(
  __m256i vector,
  int16_t constant
);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(__m256i a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(__m256i a);

__m256i libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_compress_1(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_compress_1_f5(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(__m256i lhs, __m256i rhs);

__m256i libcrux_ml_kem_vector_avx2_compress_decompress_1(__m256i a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_decompress_1_f5(__m256i a);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(
  __m256i vec,
  __m256i constants
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(__m256i vector, int16_t zeta0, int16_t zeta1);

__m128i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(
  __m128i vec,
  __m128i constants
);

__m256i libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_ntt_layer_3_step(__m256i vector, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(__m256i vector, int16_t zeta);

__m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
);

__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
);

__m256i libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(__m256i vector, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(__m256i vec);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(
  __m256i lhs,
  __m256i rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_multiply(
  const __m256i *lhs,
  const __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_multiply_f5(
  const __m256i *lhs,
  const __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_serialize_1(__m256i vector);

Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s(int16_t a, int16_t b);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(uint8_t a, uint8_t b);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_1(Eurydice_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_1(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_borrow_slice_u8 bytes);

/**
 `mm256_concat_pairs_n(n, x)` is then a sequence of 32 bits packets
 of the shape `0b0…0b₁…bₙa₁…aₙ`, if `x` is a sequence of pairs of
 16 bits, of the shape `(0b0…0a₁…aₙ, 0b0…0b₁…bₙ)` (where the last
 `n` bits are non-zero).
*/
__m256i libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(uint8_t n, __m256i x);

Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_serialize_4(__m256i vector);

Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s(
  int16_t b0,
  int16_t b1,
  int16_t b2,
  int16_t b3,
  int16_t b4,
  int16_t b5,
  int16_t b6,
  int16_t b7
);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(
  uint8_t b0,
  uint8_t b1,
  uint8_t b2,
  uint8_t b3,
  uint8_t b4,
  uint8_t b5,
  uint8_t b6,
  uint8_t b7
);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_4(Eurydice_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_4(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_4_f5(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_serialize_5(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_5_f5(__m256i vector);

/**
 We cannot model `mm256_inserti128_si256` on its own: it produces a
 Vec256 where the upper 128 bits are undefined. Thus
 `mm256_inserti128_si256` is not pure.

 Luckily, we always call `mm256_castsi128_si256` right after
 `mm256_inserti128_si256`: this composition sets the upper bits,
 making the whole computation pure again.
*/
__m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(__m128i lower, __m128i upper);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_5(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_5_f5(Eurydice_borrow_slice_u8 bytes);

typedef struct core_core_arch_x86___m128i_x2_s
{
  __m128i fst;
  __m128i snd;
}
core_core_arch_x86___m128i_x2;

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(__m256i vector);

Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_serialize_10(__m256i vector);

Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_10(Eurydice_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_10(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_10_f5(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_serialize_11(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_11_f5(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_11(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_11_f5(Eurydice_borrow_slice_u8 bytes);

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(__m256i vector);

Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_serialize_12(__m256i vector);

Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_12(Eurydice_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_12(Eurydice_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_12_f5(Eurydice_borrow_slice_u8 bytes);

size_t
libcrux_ml_kem_vector_avx2_sampling_rejection_sample(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
size_t
libcrux_ml_kem_vector_avx2_rej_sample_f5(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
);

#define LIBCRUX_ML_KEM_VECTOR_AVX2_NTT_NTT_MULTIPLY_PERMUTE_WITH (216)

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_clone_fd(const __m256i *self);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem_avx2_H_DEFINED
#endif /* libcrux_mlkem_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem_portable.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_core.h"

inline Eurydice_arr_c7 libcrux_ml_kem_hash_functions_portable_G(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_c7 digest = { .data = { 0U } };
  libcrux_sha3_portable_sha512(Eurydice_array_to_slice_mut_17(&digest), input);
  return digest;
}

inline Eurydice_arr_ec libcrux_ml_kem_hash_functions_portable_H(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_sha256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

#define ZETAS_TIMES_MONTGOMERY_R ((KRML_CLITERAL(Eurydice_arr_34){ .data = { -1044, -758, -359, -1517, 1493, 1422, 287, 202, -171, 622, 1577, 182, 962, -1202, -1474, 1468, 573, -1325, 264, 383, -829, 1458, -1602, -130, -681, 1017, 732, 608, -1542, 411, -205, -1571, 1223, 652, -552, 1015, -1293, 1491, -282, -1544, 516, -8, -320, -666, -1618, -1162, 126, 1469, -853, -90, -271, 830, 107, -1421, -247, -951, -398, 961, -1508, -725, 448, -1065, 677, -1275, -1103, 430, 555, 843, -1251, 871, 1550, 105, 422, 587, 177, -235, -291, -460, 1574, 1653, -246, 778, 1159, -147, -777, 1483, -602, 1119, -1590, 644, -872, 349, 418, 329, -156, -75, 817, 1097, 603, 610, 1322, -1285, -1465, 384, -1215, -136, 1218, -1335, -874, 220, -1187, -1659, -1185, -1530, -1278, 794, -1510, -854, -870, 478, -108, -308, 996, 991, 958, -1460, 1522, 1628 } }))

int16_t libcrux_ml_kem_polynomial_zeta(size_t i)
{
  return ZETAS_TIMES_MONTGOMERY_R.data[i];
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_i16_array(Eurydice_borrow_slice_i16 array)
{
  Eurydice_arr_d6 arr;
  memcpy(arr.data,
    Eurydice_slice_subslice_shared_a6(array,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })).ptr,
    (size_t)16U * sizeof (int16_t));
  return
    core_result_unwrap_26_d3((
        KRML_CLITERAL(core_result_Result_ec){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_borrow_slice_i16 array)
{
  return
    libcrux_ml_kem_vector_portable_vector_type_from_i16_array(libcrux_secrets_int_classify_public_classify_ref_6d_39(array));
}

KRML_MUSTINLINE uint8_t_x11
libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U]);
  uint8_t
  r1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] & 31) << 3U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U);
  uint8_t
  r2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] & 3) << 6U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 5U);
  uint8_t r3 = libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 2U & 255);
  uint8_t
  r4 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] & 127) << 1U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 10U);
  uint8_t
  r5 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U] & 15) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 7U);
  uint8_t
  r6 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U] & 1) << 7U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U] >> 4U);
  uint8_t r7 = libcrux_secrets_int_as_u8_f5(v.ptr[5U] >> 1U & 255);
  uint8_t
  r8 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U] & 63) << 2U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U] >> 9U);
  uint8_t
  r9 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[7U] & 7) << 5U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U] >> 6U);
  uint8_t r10 = libcrux_secrets_int_as_u8_f5(v.ptr[7U] >> 3U);
  return
    (
      KRML_CLITERAL(uint8_t_x11){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7,
        .f8 = r8,
        .f9 = r9,
        .f10 = r10
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_80
libcrux_ml_kem_vector_portable_serialize_serialize_11(Eurydice_arr_d6 v)
{
  uint8_t_x11
  r0_10 =
    libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x11
  r11_21 =
    libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_80){
        .data = {
          r0_10.fst, r0_10.snd, r0_10.thd, r0_10.f3, r0_10.f4, r0_10.f5, r0_10.f6, r0_10.f7,
          r0_10.f8, r0_10.f9, r0_10.f10, r11_21.fst, r11_21.snd, r11_21.thd, r11_21.f3, r11_21.f4,
          r11_21.f5, r11_21.f6, r11_21.f7, r11_21.f8, r11_21.f9, r11_21.f10
        }
      }
    );
}

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_0b(libcrux_ml_kem_vector_portable_serialize_serialize_11(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_11(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_borrow_slice_u8 bytes)
{
  int16_t
  r0 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) & 7) << 8U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[0U]);
  int16_t
  r1 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) & 63) << 5U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) >> 3U;
  int16_t
  r2 =
    ((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[4U]) & 1) << 10U) |
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[3U]) << 2U))
    | libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) >> 6U;
  int16_t
  r3 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) & 15) << 7U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[4U]) >> 1U;
  int16_t
  r4 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) & 127) << 4U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) >> 4U;
  int16_t
  r5 =
    ((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) & 3) << 9U) |
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[7U]) << 1U))
    | libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) >> 7U;
  int16_t
  r6 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[9U]) & 31) << 6U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) >> 2U;
  int16_t
  r7 =
    (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[10U]) << 3U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[9U]) >> 5U;
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_11(Eurydice_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)11U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)11U, .end = (size_t)22U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_11(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_11(a);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_to_i16_array(Eurydice_arr_d6 x)
{
  return x;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_i16_array_b8(Eurydice_arr_d6 x)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_4b(libcrux_ml_kem_vector_portable_vector_type_to_i16_array(x));
}

KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_zero(void)
{
  return
    libcrux_secrets_int_public_integers_classify_27_4b((
        KRML_CLITERAL(Eurydice_arr_d6){ .data = { 0U } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_ZERO_b8(void)
{
  return libcrux_ml_kem_vector_portable_vector_type_zero();
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_bytes(Eurydice_borrow_slice_u8 array)
{
  Eurydice_arr_d6 elements;
  int16_t repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_secrets_int_I16(0););
  memcpy(elements.data, repeat_expression, (size_t)16U * sizeof (int16_t));
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    elements.data[i0] =
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(array.ptr[(size_t)2U * i0 + (size_t)1U]) <<
        8U)
      | libcrux_secrets_int_as_i16_59(array.ptr[(size_t)2U * i0]);
  }
  return elements;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_from_bytes_b8(Eurydice_borrow_slice_u8 array)
{
  return
    libcrux_ml_kem_vector_portable_vector_type_from_bytes(libcrux_secrets_int_classify_public_classify_ref_6d_90(array));
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_vector_type_to_bytes(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    bytes.ptr[(size_t)2U * i0 + (size_t)1U] = libcrux_secrets_int_as_u8_f5(x.data[i0] >> 8U);
    bytes.ptr[(size_t)2U * i0] = libcrux_secrets_int_as_u8_f5(x.data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
void
libcrux_ml_kem_vector_portable_to_bytes_b8(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
)
{
  libcrux_ml_kem_vector_portable_vector_type_to_bytes(x,
    libcrux_secrets_int_public_integers_classify_mut_slice_75(bytes));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_add(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs.data[uu____0] += rhs->data[i0];
  }
  return lhs;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_add_b8(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs)
{
  return libcrux_ml_kem_vector_portable_arithmetic_add(lhs, rhs);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_sub(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs.data[uu____0] -= rhs->data[i0];
  }
  return lhs;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_sub_b8(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs)
{
  return libcrux_ml_kem_vector_portable_arithmetic_sub(lhs, rhs);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(Eurydice_arr_d6 vec, int16_t c)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    vec.data[uu____0] *= c;
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_multiply_by_constant_b8(Eurydice_arr_d6 vec, int16_t c)
{
  return libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(vec, c);
}

/**
 Note: This function is not secret independent
 Only use with public values.
*/
KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    if (libcrux_secrets_int_public_integers_declassify_d8_39(vec.data[i0]) >= 3329)
    {
      size_t uu____0 = i0;
      vec.data[uu____0] -= 3329;
    }
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(Eurydice_arr_d6 v)
{
  return libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(v);
}

/**
 Signed Barrett Reduction

 Given an input `value`, `barrett_reduce` outputs a representative `result`
 such that:

 - result ≡ value (mod FIELD_MODULUS)
 - the absolute value of `result` is bound as follows:

 `|result| ≤ FIELD_MODULUS / 2 · (|value|/BARRETT_R + 1)

 Note: The input bound is 28296 to prevent overflow in the multiplication of quotient by FIELD_MODULUS

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(int16_t value)
{
  int32_t
  t =
    libcrux_secrets_int_as_i32_f5(value) *
      LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_BARRETT_MULTIPLIER
    + (LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_R >> 1U);
  int16_t
  quotient =
    libcrux_secrets_int_as_i16_36(t >> (uint32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT);
  return value - quotient * LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t vi = libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(vec.data[i0]);
    vec.data[i0] = vi;
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_barrett_reduce_b8(Eurydice_arr_d6 vector)
{
  return libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(vector);
}

/**
 Signed Montgomery Reduction

 Given an input `value`, `montgomery_reduce` outputs a representative `o`
 such that:

 - o ≡ value · MONTGOMERY_R^(-1) (mod FIELD_MODULUS)
 - the absolute value of `o` is bound as follows:

 `|result| ≤ ceil(|value| / MONTGOMERY_R) + 1665

 In particular, if `|value| ≤ FIELD_MODULUS-1 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS-1`.
 And, if `|value| ≤ pow2 16 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS + 1664

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(int32_t value)
{
  int32_t
  k =
    libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_as_i16_36(value)) *
      libcrux_secrets_int_as_i32_b8(libcrux_secrets_int_public_integers_classify_27_df(LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  int32_t
  k_times_modulus =
    libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_as_i16_36(k)) *
      libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  int16_t
  c =
    libcrux_secrets_int_as_i16_36(k_times_modulus >>
        (uint32_t)LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT);
  int16_t
  value_high =
    libcrux_secrets_int_as_i16_36(value >>
        (uint32_t)LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT);
  return value_high - c;
}

/**
 If `fe` is some field element 'x' of the Kyber field and `fer` is congruent to
 `y · MONTGOMERY_R`, this procedure outputs a value that is congruent to
 `x · y`, as follows:

    `fe · fer ≡ x · y · MONTGOMERY_R (mod FIELD_MODULUS)`

 `montgomery_reduce` takes the value `x · y · MONTGOMERY_R` and outputs a representative
 `x · y · MONTGOMERY_R * MONTGOMERY_R^{-1} ≡ x · y (mod FIELD_MODULUS)`.
*/
KRML_MUSTINLINE int16_t
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(
  int16_t fe,
  int16_t fer
)
{
  int32_t product = libcrux_secrets_int_as_i32_f5(fe) * libcrux_secrets_int_as_i32_f5(fer);
  return libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(product);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(
  Eurydice_arr_d6 vec,
  int16_t c
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    vec.data[i0] =
      libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(vec.data[i0],
        c);
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(
  Eurydice_arr_d6 vector,
  int16_t constant
)
{
  return
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(vector,
      libcrux_secrets_int_public_integers_classify_27_39(constant));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(
  Eurydice_arr_d6 vec,
  int16_t c
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    vec.data[uu____0] &= c;
  }
  return vec;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.arithmetic.shift_right
with const generics
- SHIFT_BY= 15
*/
static KRML_MUSTINLINE Eurydice_arr_d6 shift_right_ef(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    vec.data[i0] >>= (uint32_t)15;
  }
  return vec;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(Eurydice_arr_d6 a)
{
  Eurydice_arr_d6 t = shift_right_ef(a);
  Eurydice_arr_d6
  fm =
    libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(t,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  return libcrux_ml_kem_vector_portable_arithmetic_add(a, &fm);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(a);
}

/**
 The `compress_*` functions implement the `Compress` function specified in the NIST FIPS
 203 standard (Page 18, Expression 4.5), which is defined as:

 ```plaintext
 Compress_d: ℤq -> ℤ_{2ᵈ}
 Compress_d(x) = ⌈(2ᵈ/q)·x⌋
 ```

 Since `⌈x⌋ = ⌊x + 1/2⌋` we have:

 ```plaintext
 Compress_d(x) = ⌊(2ᵈ/q)·x + 1/2⌋
               = ⌊(2^{d+1}·x + q) / 2q⌋
 ```

 For further information about the function implementations, consult the
 `implementation_notes.pdf` document in this directory.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
uint8_t libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(uint16_t fe)
{
  int16_t
  shifted =
    libcrux_secrets_int_public_integers_classify_27_39(1664) - libcrux_secrets_int_as_i16_ca(fe);
  int16_t mask = shifted >> 15U;
  int16_t shifted_to_positive = mask ^ shifted;
  int16_t shifted_positive_in_range = shifted_to_positive - 832;
  int16_t r0 = shifted_positive_in_range >> 15U;
  int16_t r1 = r0 & 1;
  return libcrux_secrets_int_as_u8_f5(r1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_compress_compress_1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    a.data[i0] =
      libcrux_secrets_int_as_i16_59(libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(libcrux_secrets_int_as_u16_f5(a.data[i0])));
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_compress_compress_1(a);
}

KRML_MUSTINLINE uint32_t
libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(
  uint8_t n,
  uint32_t value
)
{
  return value & ((1U << (uint32_t)n) - 1U);
}

int16_t
libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient(
  uint8_t coefficient_bits,
  uint16_t fe
)
{
  uint64_t compressed = libcrux_secrets_int_as_u64_ca(fe) << (uint32_t)coefficient_bits;
  compressed += 1664ULL;
  compressed *= 10321340ULL;
  compressed >>= 35U;
  return
    libcrux_secrets_int_as_i16_b8(libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(coefficient_bits,
        libcrux_secrets_int_as_u32_a3(compressed)));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_compress_decompress_1(Eurydice_arr_d6 a)
{
  Eurydice_arr_d6 z = libcrux_ml_kem_vector_portable_vector_type_zero();
  Eurydice_arr_d6 s = libcrux_ml_kem_vector_portable_arithmetic_sub(z, &a);
  Eurydice_arr_d6
  res = libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(s, 1665);
  return res;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_decompress_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_compress_decompress_1(a);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
)
{
  int16_t
  t =
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(vec->data[j],
      libcrux_secrets_int_public_integers_classify_27_39(zeta));
  int16_t a_minus_t = vec->data[i] - t;
  int16_t a_plus_t = vec->data[i] + t;
  vec->data[j] = a_minus_t;
  vec->data[i] = a_plus_t;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)0U, (size_t)2U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)1U, (size_t)3U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)4U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)5U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta2, (size_t)8U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta2, (size_t)9U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta3, (size_t)12U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta3, (size_t)13U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(a, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)0U, (size_t)4U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)1U, (size_t)5U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)2U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)3U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)8U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)9U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)10U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)11U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(a, zeta0, zeta1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)0U, (size_t)8U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)1U, (size_t)9U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)2U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)3U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)4U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)5U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)6U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)7U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(a, zeta);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
)
{
  int16_t a_minus_b = vec->data[j] - vec->data[i];
  int16_t a_plus_b = vec->data[j] + vec->data[i];
  int16_t o0 = libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(a_plus_b);
  int16_t
  o1 =
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(a_minus_b,
      libcrux_secrets_int_public_integers_classify_27_39(zeta));
  vec->data[i] = o0;
  vec->data[j] = o1;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)0U, (size_t)2U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)1U, (size_t)3U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)4U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)5U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta2, (size_t)8U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta2, (size_t)9U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta3, (size_t)12U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta3, (size_t)13U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(a, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)0U, (size_t)4U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)1U, (size_t)5U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)2U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)3U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)8U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)9U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)10U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)11U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(a, zeta0, zeta1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)0U, (size_t)8U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)1U, (size_t)9U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)2U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)3U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)4U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)5U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)6U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)7U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(a, zeta);
}

/**
 Compute the product of two Kyber binomials with respect to the
 modulus `X² - zeta`.

 This function almost implements <strong>Algorithm 11</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input:  a₀, a₁, b₀, b₁ ∈ ℤq.
 Input: γ ∈ ℤq.
 Output: c₀, c₁ ∈ ℤq.

 c₀ ← a₀·b₀ + a₁·b₁·γ
 c₁ ← a₀·b₁ + a₁·b₀
 return c₀, c₁
 ```
 We say "almost" because the coefficients output by this function are in
 the Montgomery domain (unlike in the specification).

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(
  const Eurydice_arr_d6 *a,
  const Eurydice_arr_d6 *b,
  int16_t zeta,
  size_t i,
  Eurydice_arr_d6 *out
)
{
  int16_t ai = a->data[(size_t)2U * i];
  int16_t bi = b->data[(size_t)2U * i];
  int16_t aj = a->data[(size_t)2U * i + (size_t)1U];
  int16_t bj = b->data[(size_t)2U * i + (size_t)1U];
  int32_t ai_bi = libcrux_secrets_int_as_i32_f5(ai) * libcrux_secrets_int_as_i32_f5(bi);
  int32_t aj_bj_ = libcrux_secrets_int_as_i32_f5(aj) * libcrux_secrets_int_as_i32_f5(bj);
  int16_t aj_bj = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(aj_bj_);
  int32_t
  aj_bj_zeta = libcrux_secrets_int_as_i32_f5(aj_bj) * libcrux_secrets_int_as_i32_f5(zeta);
  int32_t ai_bi_aj_bj = ai_bi + aj_bj_zeta;
  int16_t o0 = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(ai_bi_aj_bj);
  int32_t ai_bj = libcrux_secrets_int_as_i32_f5(ai) * libcrux_secrets_int_as_i32_f5(bj);
  int32_t aj_bi = libcrux_secrets_int_as_i32_f5(aj) * libcrux_secrets_int_as_i32_f5(bi);
  int32_t ai_bj_aj_bi = ai_bj + aj_bi;
  int16_t o1 = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(ai_bj_aj_bi);
  out->data[(size_t)2U * i] = o0;
  out->data[(size_t)2U * i + (size_t)1U] = o1;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_multiply(
  const Eurydice_arr_d6 *lhs,
  const Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  int16_t nzeta0 = -zeta0;
  int16_t nzeta1 = -zeta1;
  int16_t nzeta2 = -zeta2;
  int16_t nzeta3 = -zeta3;
  Eurydice_arr_d6 out = libcrux_ml_kem_vector_portable_vector_type_zero();
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta0),
    (size_t)0U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta0),
    (size_t)1U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta1),
    (size_t)2U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta1),
    (size_t)3U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta2),
    (size_t)4U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta2),
    (size_t)5U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta3),
    (size_t)6U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta3),
    (size_t)7U,
    &out);
  return out;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_multiply_b8(
  const Eurydice_arr_d6 *lhs,
  const Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_multiply(lhs, rhs, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_array_u8x2
libcrux_ml_kem_vector_portable_serialize_serialize_1(Eurydice_arr_d6 v)
{
  uint8_t
  result0 =
    (((((((uint32_t)libcrux_secrets_int_as_u8_f5(v.data[0U]) |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[1U]) << 1U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[2U]) << 2U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[3U]) << 3U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[4U]) << 4U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[5U]) << 5U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[6U]) << 6U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[7U]) << 7U;
  uint8_t
  result1 =
    (((((((uint32_t)libcrux_secrets_int_as_u8_f5(v.data[8U]) |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[9U]) << 1U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[10U]) << 2U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[11U]) << 3U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[12U]) << 4U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[13U]) << 5U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[14U]) << 6U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[15U]) << 7U;
  return (KRML_CLITERAL(Eurydice_array_u8x2){ .data = { result0, result1 } });
}

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_75(libcrux_ml_kem_vector_portable_serialize_serialize_1(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_1(a);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_1(Eurydice_borrow_slice_u8 v)
{
  int16_t result0 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] & 1U);
  int16_t result1 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 1U & 1U);
  int16_t result2 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 2U & 1U);
  int16_t result3 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 3U & 1U);
  int16_t result4 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 4U & 1U);
  int16_t result5 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 5U & 1U);
  int16_t result6 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 6U & 1U);
  int16_t result7 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 7U & 1U);
  int16_t result8 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] & 1U);
  int16_t result9 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 1U & 1U);
  int16_t result10 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 2U & 1U);
  int16_t result11 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 3U & 1U);
  int16_t result12 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 4U & 1U);
  int16_t result13 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 5U & 1U);
  int16_t result14 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 6U & 1U);
  int16_t result15 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 7U & 1U);
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          result0, result1, result2, result3, result4, result5, result6, result7, result8, result9,
          result10, result11, result12, result13, result14, result15
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_1(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_1(a);
}

KRML_MUSTINLINE uint8_t_x4
libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_borrow_slice_i16 v)
{
  uint8_t
  result0 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U]);
  uint8_t
  result1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U]);
  uint8_t
  result2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U]);
  uint8_t
  result3 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[7U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U]);
  return
    (KRML_CLITERAL(uint8_t_x4){ .fst = result0, .snd = result1, .thd = result2, .f3 = result3 });
}

KRML_MUSTINLINE Eurydice_array_u8x8
libcrux_ml_kem_vector_portable_serialize_serialize_4(Eurydice_arr_d6 v)
{
  uint8_t_x4
  result0_3 =
    libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x4
  result4_7 =
    libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_array_u8x8){
        .data = {
          result0_3.fst, result0_3.snd, result0_3.thd, result0_3.f3, result4_7.fst, result4_7.snd,
          result4_7.thd, result4_7.f3
        }
      }
    );
}

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_52(libcrux_ml_kem_vector_portable_serialize_serialize_4(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_4(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_borrow_slice_u8 bytes)
{
  int16_t v0 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] & 15U);
  int16_t v1 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] >> 4U & 15U);
  int16_t v2 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] & 15U);
  int16_t v3 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] >> 4U & 15U);
  int16_t v4 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[2U] & 15U);
  int16_t v5 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[2U] >> 4U & 15U);
  int16_t v6 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] & 15U);
  int16_t v7 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] >> 4U & 15U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = v0,
        .snd = v1,
        .thd = v2,
        .f3 = v3,
        .f4 = v4,
        .f5 = v5,
        .f6 = v6,
        .f7 = v7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_4(Eurydice_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)4U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)8U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_4(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_4(a);
}

KRML_MUSTINLINE uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] | (int16_t)((uint32_t)v.ptr[1U] << 5U));
  uint8_t
  r1 =
    libcrux_secrets_int_as_u8_f5((v.ptr[1U] >> 3U | (int16_t)((uint32_t)v.ptr[2U] << 2U)) |
        (int16_t)((uint32_t)v.ptr[3U] << 7U));
  uint8_t
  r2 = libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 1U | (int16_t)((uint32_t)v.ptr[4U] << 4U));
  uint8_t
  r3 =
    libcrux_secrets_int_as_u8_f5((v.ptr[4U] >> 4U | (int16_t)((uint32_t)v.ptr[5U] << 1U)) |
        (int16_t)((uint32_t)v.ptr[6U] << 6U));
  uint8_t
  r4 = libcrux_secrets_int_as_u8_f5(v.ptr[6U] >> 2U | (int16_t)((uint32_t)v.ptr[7U] << 3U));
  return (KRML_CLITERAL(uint8_t_x5){ .fst = r0, .snd = r1, .thd = r2, .f3 = r3, .f4 = r4 });
}

KRML_MUSTINLINE Eurydice_arr_6d
libcrux_ml_kem_vector_portable_serialize_serialize_5(Eurydice_arr_d6 v)
{
  uint8_t_x5
  r0_4 =
    libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x5
  r5_9 =
    libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_6d){
        .data = {
          r0_4.fst, r0_4.snd, r0_4.thd, r0_4.f3, r0_4.f4, r5_9.fst, r5_9.snd, r5_9.thd, r5_9.f3,
          r5_9.f4
        }
      }
    );
}

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_37(libcrux_ml_kem_vector_portable_serialize_serialize_5(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_5(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_borrow_slice_u8 bytes)
{
  int16_t v0 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] & 31U);
  int16_t
  v1 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[1U] & 3U) << 3U |
        (uint32_t)bytes.ptr[0U] >> 5U);
  int16_t v2 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] >> 2U & 31U);
  int16_t
  v3 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[2U] & 15U) << 1U |
        (uint32_t)bytes.ptr[1U] >> 7U);
  int16_t
  v4 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[3U] & 1U) << 4U |
        (uint32_t)bytes.ptr[2U] >> 4U);
  int16_t v5 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] >> 1U & 31U);
  int16_t
  v6 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[4U] & 7U) << 2U |
        (uint32_t)bytes.ptr[3U] >> 6U);
  int16_t v7 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[4U] >> 3U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = v0,
        .snd = v1,
        .thd = v2,
        .f3 = v3,
        .f4 = v4,
        .f5 = v5,
        .f6 = v6,
        .f7 = v7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_5(Eurydice_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)5U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)5U, .end = (size_t)10U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_5(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_5(a);
}

KRML_MUSTINLINE uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] & 255);
  uint8_t
  r1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] & 63) << 2U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U & 3);
  uint8_t
  r2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] & 15) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 6U & 15);
  uint8_t
  r3 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] & 3) << 6U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 4U & 63);
  uint8_t r4 = libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 2U & 255);
  return (KRML_CLITERAL(uint8_t_x5){ .fst = r0, .snd = r1, .thd = r2, .f3 = r3, .f4 = r4 });
}

KRML_MUSTINLINE Eurydice_arr_fc
libcrux_ml_kem_vector_portable_serialize_serialize_10(Eurydice_arr_d6 v)
{
  uint8_t_x5
  r0_4 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)4U })));
  uint8_t_x5
  r5_9 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)8U })));
  uint8_t_x5
  r10_14 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)12U })));
  uint8_t_x5
  r15_19 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_fc){
        .data = {
          r0_4.fst, r0_4.snd, r0_4.thd, r0_4.f3, r0_4.f4, r5_9.fst, r5_9.snd, r5_9.thd, r5_9.f3,
          r5_9.f4, r10_14.fst, r10_14.snd, r10_14.thd, r10_14.f3, r10_14.f4, r15_19.fst, r15_19.snd,
          r15_19.thd, r15_19.f3, r15_19.f4
        }
      }
    );
}

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_2b(libcrux_ml_kem_vector_portable_serialize_serialize_10(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_10(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_borrow_slice_u8 bytes)
{
  int16_t
  r0 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[1U])
      & 3)
      << 8U)
      | (libcrux_secrets_int_as_i16_59(bytes.ptr[0U]) & 255));
  int16_t
  r1 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[2U])
      & 15)
      << 6U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) >> 2U);
  int16_t
  r2 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[3U])
      & 63)
      << 4U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) >> 4U);
  int16_t
  r3 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[4U])
      << 2U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[3U]) >> 6U);
  int16_t
  r4 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[6U])
      & 3)
      << 8U)
      | (libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) & 255));
  int16_t
  r5 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[7U])
      & 15)
      << 6U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) >> 2U);
  int16_t
  r6 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[8U])
      & 63)
      << 4U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[7U]) >> 4U);
  int16_t
  r7 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[9U])
      << 2U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) >> 6U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_10(Eurydice_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)10U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)20U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_10(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_10(a);
}

KRML_MUSTINLINE uint8_t_x3
libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] & 255);
  uint8_t
  r1 =
    libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U | (int16_t)((uint32_t)(v.ptr[1U] & 15) << 4U));
  uint8_t r2 = libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 4U & 255);
  return (KRML_CLITERAL(uint8_t_x3){ .fst = r0, .snd = r1, .thd = r2 });
}

KRML_MUSTINLINE Eurydice_arr_94
libcrux_ml_kem_vector_portable_serialize_serialize_12(Eurydice_arr_d6 v)
{
  uint8_t_x3
  r0_2 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)2U })));
  uint8_t_x3
  r3_5 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)2U, .end = (size_t)4U })));
  uint8_t_x3
  r6_8 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)6U })));
  uint8_t_x3
  r9_11 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)6U, .end = (size_t)8U })));
  uint8_t_x3
  r12_14 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)10U })));
  uint8_t_x3
  r15_17 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)12U })));
  uint8_t_x3
  r18_20 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)14U })));
  uint8_t_x3
  r21_23 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_shared_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)14U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_94){
        .data = {
          r0_2.fst, r0_2.snd, r0_2.thd, r3_5.fst, r3_5.snd, r3_5.thd, r6_8.fst, r6_8.snd, r6_8.thd,
          r9_11.fst, r9_11.snd, r9_11.thd, r12_14.fst, r12_14.snd, r12_14.thd, r15_17.fst,
          r15_17.snd, r15_17.thd, r18_20.fst, r18_20.snd, r18_20.thd, r21_23.fst, r21_23.snd,
          r21_23.thd
        }
      }
    );
}

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_40(libcrux_ml_kem_vector_portable_serialize_serialize_12(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_12(a);
}

KRML_MUSTINLINE int16_t_x2
libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_borrow_slice_u8 bytes)
{
  int16_t byte0 = libcrux_secrets_int_as_i16_59(bytes.ptr[0U]);
  int16_t byte1 = libcrux_secrets_int_as_i16_59(bytes.ptr[1U]);
  int16_t byte2 = libcrux_secrets_int_as_i16_59(bytes.ptr[2U]);
  int16_t r0 = (int16_t)((uint32_t)(byte1 & 15) << 8U) | (byte0 & 255);
  int16_t r1 = (int16_t)((uint32_t)byte2 << 4U) | (byte1 >> 4U & 15);
  return (KRML_CLITERAL(int16_t_x2){ .fst = r0, .snd = r1 });
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_12(Eurydice_borrow_slice_u8 bytes)
{
  int16_t_x2
  v0_1 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)3U })));
  int16_t_x2
  v2_3 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)3U, .end = (size_t)6U })));
  int16_t_x2
  v4_5 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)6U, .end = (size_t)9U })));
  int16_t_x2
  v6_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)9U, .end = (size_t)12U })));
  int16_t_x2
  v8_9 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)15U })));
  int16_t_x2
  v10_11 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)15U, .end = (size_t)18U })));
  int16_t_x2
  v12_13 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)18U, .end = (size_t)21U })));
  int16_t_x2
  v14_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_shared_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)21U, .end = (size_t)24U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_1.fst, v0_1.snd, v2_3.fst, v2_3.snd, v4_5.fst, v4_5.snd, v6_7.fst, v6_7.snd, v8_9.fst,
          v8_9.snd, v10_11.fst, v10_11.snd, v12_13.fst, v12_13.snd, v14_15.fst, v14_15.snd
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12(Eurydice_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_12(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12_b8(Eurydice_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_12(a);
}

KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_portable_sampling_rej_sample(
  Eurydice_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 result
)
{
  size_t sampled = (size_t)0U;
  for (size_t i = (size_t)0U; i < a.meta / (size_t)3U; i++)
  {
    size_t i0 = i;
    int16_t b1 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)0U];
    int16_t b2 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)1U];
    int16_t b3 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)2U];
    int16_t d1 = (int16_t)((uint32_t)(b2 & 15) << 8U) | b1;
    int16_t d2 = (int16_t)((uint32_t)b3 << 4U) | b2 >> 4U;
    if (d1 < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS)
    {
      if (sampled < (size_t)16U)
      {
        result.ptr[sampled] = d1;
        sampled++;
      }
    }
    if (d2 < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS)
    {
      if (sampled < (size_t)16U)
      {
        result.ptr[sampled] = d2;
        sampled++;
      }
    }
  }
  return sampled;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
size_t
libcrux_ml_kem_vector_portable_rej_sample_b8(
  Eurydice_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 out
)
{
  return libcrux_ml_kem_vector_portable_sampling_rej_sample(a, out);
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
inline Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_clone_9c(const Eurydice_arr_d6 *self)
{
  return self[0U];
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static Eurydice_arr_9e ZERO_d6_ea(void)
{
  Eurydice_arr_9e lit;
  Eurydice_arr_d6 repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_portable_ZERO_b8(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_d6));
  return lit;
}

/**
 Only use with public values.

 This MUST NOT be used with secret inputs, like its caller `deserialize_ring_elements_reduced`.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_reduced_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_to_reduced_ring_element_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_12_b8(bytes);
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_ee(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_d20 *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 4
*/
static inline Eurydice_arr_4a shake128_init_absorb_final_23(const Eurydice_arr_56 *input)
{
  Eurydice_arr_4a shake128_state;
  Eurydice_arr_7c repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_shared_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 4
*/
Eurydice_arr_4a
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(
  const Eurydice_arr_56 *input
)
{
  return shake128_init_absorb_final_23(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 4
*/
static inline Eurydice_arr_7c0 shake128_squeeze_first_three_blocks_23(Eurydice_arr_4a *st)
{
  Eurydice_arr_7c0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 4
*/
Eurydice_arr_7c0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(
  Eurydice_arr_4a *self
)
{
  return shake128_squeeze_first_three_blocks_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_1c(
  const Eurydice_arr_7c0 *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 4
*/
static inline Eurydice_arr_9c shake128_squeeze_next_block_23(Eurydice_arr_4a *st)
{
  Eurydice_arr_9c
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 4
*/
Eurydice_arr_9c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(Eurydice_arr_4a *self)
{
  return shake128_squeeze_next_block_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_1c0(
  const Eurydice_arr_9c *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static Eurydice_arr_9e ZERO_ea(void)
{
  Eurydice_arr_9e lit;
  Eurydice_arr_d6 repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_portable_ZERO_b8(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_d6));
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e from_i16_array_ea(Eurydice_borrow_slice_i16 a)
{
  Eurydice_arr_9e result = ZERO_ea();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_slice_subslice_shared_a6(a,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * (size_t)16U,
              .end = (i0 + (size_t)1U) * (size_t)16U
            }
          )));
    result.data[i0] = uu____0;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e from_i16_array_d6_ea(Eurydice_borrow_slice_i16 a)
{
  return from_i16_array_ea(a);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_0a_911(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20 sample_from_xof_911(const Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_4a
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(seeds);
  Eurydice_arr_7c0
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_1c(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(&xof_state);
      done = sample_from_uniform_distribution_next_1c0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_d20 arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_911(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_911(Eurydice_arr_600 *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_d20 sampled = sample_from_xof_911(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 4
*/
static inline Eurydice_arr_ec H_4a_23(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(
  const Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_212(public_key, (size_t)1536U);
  deserialize_ring_elements_reduced_ee(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f4(public_key,
        (size_t)1536U));
  Eurydice_arr_600 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f4(public_key,
        (size_t)1536U));
  sample_matrix_A_911(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_23(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.to_unsigned_field_modulus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_d6 to_unsigned_field_modulus_ea(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.serialize_uncompressed_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_b20
serialize_uncompressed_ring_element_ea(const Eurydice_arr_9e *re)
{
  Eurydice_arr_b20 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = to_unsigned_field_modulus_ea(re->data[i0]);
    Eurydice_arr_94 bytes = libcrux_ml_kem_vector_portable_serialize_12_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)24U * i0,
            .end = (size_t)24U * i0 + (size_t)24U
          }
        )),
      Eurydice_array_to_slice_shared_ed(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
serialize_vector_ee(const Eurydice_arr_d20 *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_1c(
  const Eurydice_arr_d20 *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_d1 *serialized
)
{
  serialize_vector_ee(t_as_ntt,
    Eurydice_array_to_subslice_mut_d419(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f6(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self,
  Eurydice_arr_d1 *serialized
)
{
  serialize_public_key_mut_1c(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialize_public_key_1c(const Eurydice_arr_d20 *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_d1 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_1c(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialized_dd_1c(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self)
{
  return
    libcrux_ml_kem_types_from_51_d9(serialize_public_key_1c(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  return serialized_dd_1c(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair1024
serialize_unpacked_secret_key_1c(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key,
  const Eurydice_arr_d20 *private_key
)
{
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_1c(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_df secret_key_serialized = { .data = { 0U } };
  serialize_vector_ee(private_key, Eurydice_array_to_slice_mut_2f(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair1024){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_23(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d420(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 =
    serialize_unpacked_secret_key_1c(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(Eurydice_array_to_slice_shared_2f(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_b50(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  Eurydice_arr_a8 sk = libcrux_ml_kem_types_default_d3_0e();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(self, &sk);
  return sk;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_uncompressed_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_to_uncompressed_ring_element_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_deserialize_12_b8(bytes);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_vector_ee(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_d20 *secret_as_ntt)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_051(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_ee(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1536U);
  Eurydice_arr_600 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_911(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(
  const Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_shared_68(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_ee(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_051(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)1536U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_d20 default_70_ee(void)
{
  Eurydice_arr_d20 lit;
  Eurydice_arr_9e repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 default_8b_ee(void)
{
  Eurydice_arr_d20 uu____0;
  Eurydice_arr_9e repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_d20 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    Eurydice_arr_d20 lit;
    Eurydice_arr_9e repeat_expression[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_d20));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_ind_cca_unpacked_default_30_ee(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94){
        .ind_cpa_public_key = default_8b_ee(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_ee(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94
  uu____0 =
    { .ind_cpa_private_key = default_70_ee(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_ee()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 4
*/
static inline Eurydice_arr_c7 G_4a_23(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_fe(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)4U;
  return G_4a_23(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_3b0 PRFxN_f5(const Eurydice_arr_890 *input)
{
  Eurydice_arr_3b0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_shared_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_3b0 PRFxN_4a_f5(const Eurydice_arr_890 *input)
{
  return PRFxN_f5(input);
}

/**
 Given a series of uniformly random bytes in `randomness`, for some number `eta`,
 the `sample_from_binomial_distribution_{eta}` functions sample
 a ring element from a binomial distribution centered at 0 that uses two sets
 of `eta` coin flips. If, for example,
 `eta = ETA`, each ring coefficient is a value `v` such
 such that `v ∈ {-ETA, -ETA + 1, ..., 0, ..., ETA + 1, ETA}` and:

 ```plaintext
 - If v < 0, Pr[v] = Pr[-v]
 - If v >= 0, Pr[v] = BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2 ^ (2 * ETA)
 ```

 The values `v < 0` are mapped to the appropriate `KyberFieldElement`.

 The expected value is:

 ```plaintext
 E[X] = (-ETA)Pr[-ETA] + (-(ETA - 1))Pr[-(ETA - 1)] + ... + (ETA - 1)Pr[ETA - 1] + (ETA)Pr[ETA]
      = 0 since Pr[-v] = Pr[v] when v < 0.
 ```

 And the variance is:

 ```plaintext
 Var(X) = E[(X - E[X])^2]
        = E[X^2]
        = sum_(v=-ETA to ETA)v^2 * (BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2^(2 * ETA))
        = ETA / 2
 ```

 This function implements <strong>Algorithm 7</strong> of the NIST FIPS 203 standard, which is
 reproduced below:

 ```plaintext
 Input: byte array B ∈ 𝔹^{64η}.
 Output: array f ∈ ℤ₂₅₆.

 b ← BytesToBits(B)
 for (i ← 0; i < 256; i++)
     x ← ∑(j=0 to η - 1) b[2iη + j]
     y ← ∑(j=0 to η - 1) b[2iη + η + j]
     f[i] ← x−y mod q
 end for
 return f
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_2_ea(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)4U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_shared_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)4U,
            .end = chunk_number * (size_t)4U + (size_t)4U
          }
        ));
    uint32_t
    random_bits_as_u32 =
      (((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U)
      | (uint32_t)byte_chunk.ptr[3U] << 24U;
    uint32_t even_bits = random_bits_as_u32 & 1431655765U;
    uint32_t odd_bits = random_bits_as_u32 >> 1U & 1431655765U;
    uint32_t coin_toss_outcomes = even_bits + odd_bits;
    for (uint32_t i = 0U; i < 32U / 4U; i++)
    {
      uint32_t outcome_set = i;
      uint32_t outcome_set0 = outcome_set * 4U;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 3U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 2U) & 3U);
      size_t offset = (size_t)(outcome_set0 >> 2U);
      sampled_i16s.data[(size_t)8U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_ea(Eurydice_array_to_slice_shared_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_3_ea(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)3U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_shared_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)3U,
            .end = chunk_number * (size_t)3U + (size_t)3U
          }
        ));
    uint32_t
    random_bits_as_u24 =
      ((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U;
    uint32_t first_bits = random_bits_as_u24 & 2396745U;
    uint32_t second_bits = random_bits_as_u24 >> 1U & 2396745U;
    uint32_t third_bits = random_bits_as_u24 >> 2U & 2396745U;
    uint32_t coin_toss_outcomes = first_bits + second_bits + third_bits;
    for (int32_t i = 0; i < 24 / 6; i++)
    {
      int32_t outcome_set = i;
      int32_t outcome_set0 = outcome_set * 6;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 7U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 3) & 7U);
      size_t offset = (size_t)(outcome_set0 / 6);
      sampled_i16s.data[(size_t)4U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_ea(Eurydice_array_to_slice_shared_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- ETA= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_66(Eurydice_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_2_ea(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_7_ea(Eurydice_arr_9e *re)
{
  size_t step = LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT / (size_t)2U;
  for (size_t i = (size_t)0U; i < step; i++)
  {
    size_t j = i;
    Eurydice_arr_d6
    t = libcrux_ml_kem_vector_portable_multiply_by_constant_b8(re->data[j + step], -1600);
    re->data[j + step] = libcrux_ml_kem_vector_portable_sub_b8(re->data[j], &t);
    Eurydice_arr_d6 uu____1 = libcrux_ml_kem_vector_portable_add_b8(re->data[j], &t);
    re->data[j] = uu____1;
  }
}

typedef struct libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2_s
{
  Eurydice_arr_d6 fst;
  Eurydice_arr_d6 snd;
}
libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2;

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_layer_int_vec_step
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
ntt_layer_int_vec_step_ea(Eurydice_arr_d6 a, Eurydice_arr_d6 b, int16_t zeta_r)
{
  Eurydice_arr_d6
  t = libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(b, zeta_r);
  b = libcrux_ml_kem_vector_portable_sub_b8(a, &t);
  a = libcrux_ml_kem_vector_portable_add_b8(a, &t);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2){
        .fst = a,
        .snd = b
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
ntt_at_layer_4_plus_ea(size_t *zeta_i, Eurydice_arr_9e *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]++;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / (size_t)16U;
    size_t step_vec = step / (size_t)16U;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
      uu____0 =
        ntt_layer_int_vec_step_ea(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      Eurydice_arr_d6 x = uu____0.fst;
      Eurydice_arr_d6 y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_3_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
    re->data[round] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_2_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U));
    zeta_i[0U]++;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_1_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)3U));
    zeta_i[0U] += (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_ea(Eurydice_arr_9e *myself)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_barrett_reduce_b8(myself->data[i0]);
    myself->data[i0] = uu____0;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_d6_ea(Eurydice_arr_9e *self)
{
  poly_barrett_reduce_ea(self);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_binomially_sampled_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_binomially_sampled_ring_element_ea(Eurydice_arr_9e *re)
{
  ntt_at_layer_7_ea(re);
  size_t zeta_i = (size_t)1U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf1(
  Eurydice_arr_d20 *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_4a_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_73_391(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two `KyberPolynomialRingElement`s in their NTT representations,
 compute their product. Given two polynomials in the NTT domain `f^` and `ĵ`,
 the `iᵗʰ` coefficient of the product `k̂` is determined by the calculation:

 ```plaintext
 ĥ[2·i] + ĥ[2·i + 1]X = (f^[2·i] + f^[2·i + 1]X)·(ĝ[2·i] + ĝ[2·i + 1]X) mod (X² - ζ^(2·BitRev₇(i) + 1))
 ```

 This function almost implements <strong>Algorithm 10</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input: Two arrays fˆ ∈ ℤ₂₅₆ and ĝ ∈ ℤ₂₅₆.
 Output: An array ĥ ∈ ℤq.

 for(i ← 0; i < 128; i++)
     (ĥ[2i], ĥ[2i+1]) ← BaseCaseMultiply(fˆ[2i], fˆ[2i+1], ĝ[2i], ĝ[2i+1], ζ^(2·BitRev₇(i) + 1))
 end for
 return ĥ
 ```
 We say "almost" because the coefficients of the ring element output by
 this function are in the Montgomery domain.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
ntt_multiply_ea(const Eurydice_arr_9e *myself, const Eurydice_arr_9e *rhs)
{
  Eurydice_arr_9e out = ZERO_ea();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_ntt_multiply_b8(&myself->data[i0],
        &rhs->data[i0],
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)3U));
    out.data[i0] = uu____0;
  }
  return out;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
ntt_multiply_d6_ea(const Eurydice_arr_9e *self, const Eurydice_arr_9e *rhs)
{
  return ntt_multiply_ea(self, rhs);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_ee(Eurydice_arr_9e *myself, const Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_ee(Eurydice_arr_9e *self, const Eurydice_arr_9e *rhs)
{
  add_to_ring_element_ee(self, rhs);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.to_standard_domain
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_d6 to_standard_domain_ea(Eurydice_arr_d6 vector)
{
  return
    libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(vector,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_ea(Eurydice_arr_9e *myself, const Eurydice_arr_9e *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    Eurydice_arr_d6 coefficient_normal_form = to_standard_domain_ea(myself->data[j]);
    Eurydice_arr_d6
    sum = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &error->data[j]);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_d6_ea(Eurydice_arr_9e *self, const Eurydice_arr_9e *error)
{
  add_standard_error_reduce_ea(self, error);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
compute_As_plus_e_ee(
  Eurydice_arr_d20 *t_as_ntt,
  const Eurydice_arr_600 *matrix_A,
  const Eurydice_arr_d20 *s_as_ntt,
  const Eurydice_arr_d20 *error_as_ntt
)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_d20 *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR4(i1,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_ee(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_391(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_d20 *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_fe(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_600 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_911(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf1(private_key, &prf_input, 0U);
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_391(&lvalue););
  Eurydice_arr_d20 error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf1(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_ee(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_b4_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_d20 call_mut_22_ee(void **_)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_ee(&lvalue););
  return arr_struct;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.clone_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static inline Eurydice_arr_9e clone_c1_ea(const Eurydice_arr_9e *self)
{
  return
    core_array__core__clone__Clone_for__T__N___clone((size_t)16U,
      self,
      Eurydice_arr_d6,
      Eurydice_arr_9e);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_600 transpose_a_ee(Eurydice_arr_600 ind_cpa_a)
{
  Eurydice_arr_600 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_ee(&lvalue););
  Eurydice_arr_600 A = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_391(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_600 A = transpose_a_ee(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_d1
  pk_serialized =
    serialize_public_key_1c(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_23(Eurydice_array_to_slice_shared_b50(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_c7
encaps_prepare_fe(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_23(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_d20, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_12_s
{
  Eurydice_arr_d20 fst;
  Eurydice_arr_9e snd;
}
tuple_12;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_871(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_871(void **_)
{
  return ZERO_d6_ea();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf1(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_d20 *error_1
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_4a_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF
with const generics
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_ec(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_89 digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_f50(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_a8_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_1_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)3U));
    zeta_i[0U] -= (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_2_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U));
    zeta_i[0U]--;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_3_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
    re->data[round] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.inv_ntt_layer_int_vec_step_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
inv_ntt_layer_int_vec_step_reduce_ea(Eurydice_arr_d6 a, Eurydice_arr_d6 b, int16_t zeta_r)
{
  Eurydice_arr_d6 a_minus_b = libcrux_ml_kem_vector_portable_sub_b8(b, &a);
  a =
    libcrux_ml_kem_vector_portable_barrett_reduce_b8(libcrux_ml_kem_vector_portable_add_b8(a, &b));
  b = libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(a_minus_b, zeta_r);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2){
        .fst = a,
        .snd = b
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
invert_ntt_at_layer_4_plus_ea(size_t *zeta_i, Eurydice_arr_9e *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]--;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    size_t step_vec = step / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
      uu____0 =
        inv_ntt_layer_int_vec_step_reduce_ea(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      Eurydice_arr_d6 x = uu____0.fst;
      Eurydice_arr_d6 y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_ee(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_ea(Eurydice_arr_9e *myself, const Eurydice_arr_9e *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(myself->data[j],
        1441);
    Eurydice_arr_d6
    sum = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &error->data[j]);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_d6_ea(Eurydice_arr_9e *self, const Eurydice_arr_9e *error)
{
  add_error_reduce_ea(self, error);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20
compute_vector_u_ee(
  const Eurydice_arr_600 *a_as_ntt,
  const Eurydice_arr_d20 *r_as_ntt,
  const Eurydice_arr_d20 *error_1
)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_ee(&lvalue););
  Eurydice_arr_d20 result = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_d20 *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_ee(&result.data[i1], &product););
    invert_ntt_montgomery_ee(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_ef(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)10,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 10
*/
static Eurydice_arr_d6 compress_b8_ef(Eurydice_arr_d6 a)
{
  return compress_ef(a);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_c4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)11,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 11
*/
static Eurydice_arr_d6 compress_b8_c4(Eurydice_arr_d6 a)
{
  return compress_c4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7 compress_then_serialize_11_bd(const Eurydice_arr_9e *re)
{
  Eurydice_arr_e7 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient =
      compress_b8_c4(libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(re->data[i0]));
    Eurydice_arr_80 bytes = libcrux_ml_kem_vector_portable_serialize_11_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)22U * i0,
            .end = (size_t)22U * i0 + (size_t)22U
          }
        )),
      Eurydice_array_to_slice_shared_98(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 11
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7
compress_then_serialize_ring_element_u_86(const Eurydice_arr_9e *re)
{
  return compress_then_serialize_11_bd(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- OUT_LEN= 1408
- COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_2e(Eurydice_arr_d20 input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)1408U / (size_t)4U),
            .end = (i0 + (size_t)1U) * ((size_t)1408U / (size_t)4U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_e7 lvalue = compress_then_serialize_ring_element_u_86(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_25(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_12
encrypt_c1_871(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_600 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_d20 arr_struct0;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_871(&lvalue););
  Eurydice_arr_d20 r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf1(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_871(&lvalue););
  Eurydice_arr_d20 error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_bf1(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_f50(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_d20 u = compute_vector_u_ee(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_2e(u, ciphertext);
  return (KRML_CLITERAL(tuple_12){ .fst = r_as_ntt, .snd = error_2 });
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_message_ea(const Eurydice_arr_ec *serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_compressed =
      libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_array_to_subslice_shared_d4(serialized,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = (size_t)2U * i0,
              .end = (size_t)2U * i0 + (size_t)2U
            }
          )));
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_decompress_1_b8(coefficient_compressed);
    re.data[i0] = uu____0;);
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
add_message_error_reduce_ea(
  const Eurydice_arr_9e *myself,
  const Eurydice_arr_9e *message,
  Eurydice_arr_9e result
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(result.data[i0],
        1441);
    Eurydice_arr_d6
    sum1 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &message->data[i0]);
    Eurydice_arr_d6 sum2 = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &sum1);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum2);
    result.data[i0] = red;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
add_message_error_reduce_d6_ea(
  const Eurydice_arr_9e *self,
  const Eurydice_arr_9e *message,
  Eurydice_arr_9e result
)
{
  return add_message_error_reduce_ea(self, message, result);
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_ee(
  const Eurydice_arr_d20 *t_as_ntt,
  const Eurydice_arr_d20 *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_ee(&result, &product););
  invert_ntt_montgomery_ee(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_d1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)4,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 4
*/
static Eurydice_arr_d6 compress_b8_d1(Eurydice_arr_d6 a)
{
  return compress_d1(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_4_ea(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = compress_b8_d1(to_unsigned_field_modulus_ea(re.data[i0]));
    Eurydice_array_u8x8 bytes = libcrux_ml_kem_vector_portable_serialize_4_b8(coefficient);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)8U * i0,
            .end = (size_t)8U * i0 + (size_t)8U
          }
        )),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_f4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)5,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 5
*/
static Eurydice_arr_d6 compress_b8_f4(Eurydice_arr_d6 a)
{
  return compress_f4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_5
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_5_ea(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficients =
      compress_b8_f4(libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(re.data[i0]));
    Eurydice_arr_6d bytes = libcrux_ml_kem_vector_portable_serialize_5_b8(coefficients);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)10U * i0,
            .end = (size_t)10U * i0 + (size_t)10U
          }
        )),
      Eurydice_array_to_slice_shared_30(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
- OUT_LEN= 160
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_1c(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_5_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- V_COMPRESSION_FACTOR= 5
- C2_LEN= 160
*/
static KRML_MUSTINLINE void
encrypt_c2_1c(
  const Eurydice_arr_d20 *t_as_ntt,
  const Eurydice_arr_d20 *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_ee(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_1c(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_unpacked_d51(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d1 ciphertext = { .data = { 0U } };
  tuple_12
  uu____0 =
    encrypt_c1_871(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d419(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)1408U })));
  Eurydice_arr_d20 r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_1c(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f6(&ciphertext, (size_t)1408U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_fe(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_unpacked_d51(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_25){
        .fst = libcrux_ml_kem_types_from_19_d9(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static Eurydice_arr_9e call_mut_35_1c(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_ef(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)10);
    decompressed >>= (uint32_t)(10 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 10
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_ef(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_ef(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_10
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_10_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)20U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)20U,
            .end = i0 * (size_t)20U + (size_t)20U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_10_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_ef(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_c4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)11);
    decompressed >>= (uint32_t)(11 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 11
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_c4(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_c4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_11_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)22U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)22U,
            .end = i0 * (size_t)22U + (size_t)22U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_11_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_c4(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_u_ee(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_11_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE void ntt_vector_u_ee(Eurydice_arr_9e *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d20
deserialize_then_decompress_u_1c(const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_1c(&lvalue););
  Eurydice_arr_d20 u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1568U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d48(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_ee(u_bytes);
    ntt_vector_u_ee(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_d1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)4);
    decompressed >>= (uint32_t)(4 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 4
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_d1(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_d1(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_4_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)8U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)8U,
            .end = i0 * (size_t)8U + (size_t)8U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_4_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_d1(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_f4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)5);
    decompressed >>= (uint32_t)(5 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 5
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_f4(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_f4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_5
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_5_ea(Eurydice_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)10U; i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_shared_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)10U,
            .end = i0 * (size_t)10U + (size_t)10U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_portable_deserialize_5_b8(bytes);
    Eurydice_arr_d6 uu____1 = decompress_ciphertext_coefficient_b8_f4(re.data[i0]);
    re.data[i0] = uu____1;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_1c(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_5_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
subtract_reduce_ea(const Eurydice_arr_9e *myself, Eurydice_arr_9e b)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(b.data[i0],
        1441);
    Eurydice_arr_d6
    diff = libcrux_ml_kem_vector_portable_sub_b8(myself->data[i0], &coefficient_normal_form);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(diff);
    b.data[i0] = red;
  }
  return b;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
subtract_reduce_d6_ea(const Eurydice_arr_9e *self, Eurydice_arr_9e b)
{
  return subtract_reduce_ea(self, b);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_ee(
  const Eurydice_arr_9e *v,
  const Eurydice_arr_d20 *secret_as_ntt,
  const Eurydice_arr_d20 *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_ee(&result, &product););
  invert_ntt_montgomery_ee(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_ec compress_then_serialize_message_ea(Eurydice_arr_9e re)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = to_unsigned_field_modulus_ea(re.data[i0]);
    Eurydice_arr_d6
    coefficient_compressed = libcrux_ml_kem_vector_portable_compress_1_b8(coefficient);
    Eurydice_array_u8x2
    bytes = libcrux_ml_kem_vector_portable_serialize_1_b8(coefficient_compressed);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)2U * i0,
            .end = (size_t)2U * i0 + (size_t)2U
          }
        )),
      Eurydice_array_to_slice_shared_82(&bytes),
      uint8_t););
  return serialized;
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_38(const Eurydice_arr_d20 *secret_key, const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 u_as_ntt = deserialize_then_decompress_u_1c(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_1c(Eurydice_array_to_subslice_from_shared_5f4(ciphertext,
        (size_t)1408U));
  Eurydice_arr_9e message = compute_message_ee(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF
with const generics
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_ce(Eurydice_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 4
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_f5(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(
  const libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  const Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_38(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_49(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f5(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_f5(Eurydice_array_to_slice_shared_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext =
    encrypt_unpacked_d51(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_b50(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_0b_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20
deserialize_ring_elements_reduced_out_ee(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_ee(&lvalue););
  Eurydice_arr_d20 deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_ee(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_1c(const Eurydice_arr_d1 *public_key)
{
  Eurydice_arr_d20
  deserialized_pk =
    deserialize_ring_elements_reduced_out_ee(Eurydice_array_to_subslice_to_shared_212(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_1c(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f4(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  return Eurydice_array_eq((size_t)1568U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_4c(const Eurydice_arr_a8 *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_23(Eurydice_array_to_subslice_shared_d49(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)4U,
            .end = (size_t)768U * (size_t)4U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d49(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)4U + (size_t)32U,
          .end = (size_t)768U * (size_t)4U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_79(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_4c(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair1024
generate_keypair_301(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_d20 private_key = default_70_ee();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 public_key = default_8b_ee();
  generate_keypair_unpacked_391(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_1c(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE Eurydice_arr_a8
serialize_kem_secret_key_4c(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_a8 out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b81(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 = generate_keypair_301(ind_cpa_keypair_randomness);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 public_key = uu____0.snd;
  Eurydice_arr_a8
  secret_key_serialized =
    serialize_kem_secret_key_4c(Eurydice_array_to_slice_shared_2f(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_b50(&public_key),
      implicit_rejection_value);
  Eurydice_arr_a8 private_key = libcrux_ml_kem_types_from_b2_0e(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_70(private_key,
      libcrux_ml_kem_types_from_51_d9(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_fe(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
build_unpacked_public_key_051(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
  unpacked_public_key = default_8b_ee();
  build_unpacked_public_key_mut_051(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_d51(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
  unpacked_public_key = build_unpacked_public_key_051(public_key);
  return encrypt_unpacked_d51(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_4c(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_991(
  const Eurydice_arr_d1 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_fe(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_23(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_d51(Eurydice_array_to_slice_shared_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d1 uu____2 = libcrux_ml_kem_types_from_19_d9(ciphertext);
  return (KRML_CLITERAL(tuple_25){ .fst = uu____2, .snd = kdf_39_4c(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static Eurydice_arr_9e call_mut_0b_38(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_38(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_38(&lvalue););
  Eurydice_arr_d20 secret_key_unpacked = arr_struct;
  deserialize_vector_ee(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_38(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd1(
  const Eurydice_arr_a8 *private_key,
  const Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_shared_68(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_38(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14 to_hash = libcrux_ml_kem_utils_into_padded_array_49(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f5(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_f5(Eurydice_array_to_slice_shared_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext = encrypt_d51(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_4c(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_4c(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_b50(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_66(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_1e *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 2
*/
static inline Eurydice_arr_e3 shake128_init_absorb_final_af(const Eurydice_arr_bf *input)
{
  Eurydice_arr_e3 shake128_state;
  Eurydice_arr_7c repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_shared_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 2
*/
Eurydice_arr_e3
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(
  const Eurydice_arr_bf *input
)
{
  return shake128_init_absorb_final_af(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 2
*/
static inline Eurydice_arr_b8 shake128_squeeze_first_three_blocks_af(Eurydice_arr_e3 *st)
{
  Eurydice_arr_b8 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 2
*/
Eurydice_arr_b8
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(
  Eurydice_arr_e3 *self
)
{
  return shake128_squeeze_first_three_blocks_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_53(
  const Eurydice_arr_b8 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 2
*/
static inline Eurydice_arr_5b0 shake128_squeeze_next_block_af(Eurydice_arr_e3 *st)
{
  Eurydice_arr_5b0 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 2
*/
Eurydice_arr_5b0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(Eurydice_arr_e3 *self)
{
  return shake128_squeeze_next_block_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_530(
  const Eurydice_arr_5b0 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_0a_910(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e sample_from_xof_910(const Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_e3
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(seeds);
  Eurydice_arr_b8
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_53(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(&xof_state);
      done = sample_from_uniform_distribution_next_530(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_1e arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_910(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_910(Eurydice_arr_df0 *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_1e sampled = sample_from_xof_910(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 2
*/
static inline Eurydice_arr_ec H_4a_af(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(
  const Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_210(public_key, (size_t)768U);
  deserialize_ring_elements_reduced_66(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f1(public_key,
        (size_t)768U));
  Eurydice_arr_df0 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f1(public_key,
        (size_t)768U));
  sample_matrix_A_910(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_af(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
serialize_vector_66(const Eurydice_arr_1e *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_53(
  const Eurydice_arr_1e *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_03 *serialized
)
{
  serialize_vector_66(t_as_ntt,
    Eurydice_array_to_subslice_mut_d46(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self,
  Eurydice_arr_03 *serialized
)
{
  serialize_public_key_mut_53(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialize_public_key_53(const Eurydice_arr_1e *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_03 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_53(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialized_dd_53(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self)
{
  return
    libcrux_ml_kem_types_from_51_df(serialize_public_key_53(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
)
{
  return serialized_dd_53(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair512
serialize_unpacked_secret_key_44(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key,
  const Eurydice_arr_1e *private_key
)
{
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_53(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_d2 secret_key_serialized = { .data = { 0U } };
  serialize_vector_66(private_key, Eurydice_array_to_slice_mut_27(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair512){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_af(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 =
    serialize_unpacked_secret_key_44(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(Eurydice_array_to_slice_shared_27(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_3b(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
)
{
  Eurydice_arr_ab0 sk = libcrux_ml_kem_types_default_d3_be();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_vector_66(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_1e *secret_as_ntt)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_050(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_66(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)768U);
  Eurydice_arr_df0 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_910(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(
  const Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_shared_99(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_66(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_050(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)768U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_1e default_70_66(void)
{
  Eurydice_arr_1e lit;
  Eurydice_arr_9e repeat_expression[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b default_8b_66(void)
{
  Eurydice_arr_1e uu____0;
  Eurydice_arr_9e repeat_expression0[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)2U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_1e repeat_expression1[2U];
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    Eurydice_arr_1e lit;
    Eurydice_arr_9e repeat_expression[2U];
    KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)2U * sizeof (Eurydice_arr_1e));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_ind_cca_unpacked_default_30_66(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b){
        .ind_cpa_public_key = default_8b_66(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_66(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b
  uu____0 =
    { .ind_cpa_private_key = default_70_66(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_66()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 2
*/
static inline Eurydice_arr_c7 G_4a_af(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_10(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)2U;
  return G_4a_af(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 2
- LEN= 192
*/
static inline Eurydice_arr_eb PRFxN_d5(const Eurydice_arr_4d *input)
{
  Eurydice_arr_eb out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_d9(&out.data[i0]),
      Eurydice_array_to_slice_shared_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 2
- LEN= 192
*/
static inline Eurydice_arr_eb PRFxN_4a_d5(const Eurydice_arr_4d *input)
{
  return PRFxN_d5(input);
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- ETA= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_68(Eurydice_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_3_ea(randomness);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- ETA= 3
- ETA_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf0(
  Eurydice_arr_1e *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_eb prf_outputs = PRFxN_4a_d5(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_68(Eurydice_array_to_slice_shared_d9(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static Eurydice_arr_9e call_mut_73_390(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_66(Eurydice_arr_9e *myself, const Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_66(Eurydice_arr_9e *self, const Eurydice_arr_9e *rhs)
{
  add_to_ring_element_66(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
compute_As_plus_e_66(
  Eurydice_arr_1e *t_as_ntt,
  const Eurydice_arr_df0 *matrix_A,
  const Eurydice_arr_1e *s_as_ntt,
  const Eurydice_arr_1e *error_as_ntt
)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_1e *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR2(i1,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_66(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_390(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_1e *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_10(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_df0 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_910(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf0(private_key, &prf_input, 0U);
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_390(&lvalue););
  Eurydice_arr_1e error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf0(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_66(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_b4_66(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_1e call_mut_22_66(void **_)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_66(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_df0 transpose_a_66(Eurydice_arr_df0 ind_cpa_a)
{
  Eurydice_arr_df0 arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_66(&lvalue););
  Eurydice_arr_df0 A = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_390(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_df0 A = transpose_a_66(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_03
  pk_serialized =
    serialize_public_key_53(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_af(Eurydice_array_to_slice_shared_3b(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_c7
encaps_prepare_10(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_af(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_1e, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_77_s
{
  Eurydice_arr_1e fst;
  Eurydice_arr_9e snd;
}
tuple_77;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_870(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_870(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_f3 PRFxN_d50(const Eurydice_arr_4d *input)
{
  Eurydice_arr_f3 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_shared_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_f3 PRFxN_4a_d50(const Eurydice_arr_4d *input)
{
  return PRFxN_d50(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf0(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_1e *error_1
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_f3 prf_outputs = PRFxN_4a_d50(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_d50(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_a8_66(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_66(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e
compute_vector_u_66(
  const Eurydice_arr_df0 *a_as_ntt,
  const Eurydice_arr_1e *r_as_ntt,
  const Eurydice_arr_1e *error_1
)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_66(&lvalue););
  Eurydice_arr_1e result = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_1e *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_66(&result.data[i1], &product););
    invert_ntt_montgomery_66(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_10
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0 compress_then_serialize_10_e1(const Eurydice_arr_9e *re)
{
  Eurydice_arr_b0 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = compress_b8_ef(to_unsigned_field_modulus_ea(re->data[i0]));
    Eurydice_arr_fc bytes = libcrux_ml_kem_vector_portable_serialize_10_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d49(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)20U * i0,
            .end = (size_t)20U * i0 + (size_t)20U
          }
        )),
      Eurydice_array_to_slice_shared_8f(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 10
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0
compress_then_serialize_ring_element_u_f7(const Eurydice_arr_9e *re)
{
  return compress_then_serialize_10_e1(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- OUT_LEN= 640
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_a3(Eurydice_arr_1e input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)640U / (size_t)2U),
            .end = (i0 + (size_t)1U) * ((size_t)640U / (size_t)2U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_f7(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_77
encrypt_c1_870(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_df0 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_1e arr_struct0;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_870(&lvalue););
  Eurydice_arr_1e r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf0(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_870(&lvalue););
  Eurydice_arr_1e error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_bf0(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_d50(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_1e u = compute_vector_u_66(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_a3(u, ciphertext);
  return (KRML_CLITERAL(tuple_77){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_66(
  const Eurydice_arr_1e *t_as_ntt,
  const Eurydice_arr_1e *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_66(&result, &product););
  invert_ntt_montgomery_66(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_44(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_44(
  const Eurydice_arr_1e *t_as_ntt,
  const Eurydice_arr_1e *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_66(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_44(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_unpacked_d50(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d2 ciphertext = { .data = { 0U } };
  tuple_77
  uu____0 =
    encrypt_c1_870(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d410(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)640U })));
  Eurydice_arr_1e r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_44(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f1(&ciphertext, (size_t)640U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_10(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_unpacked_d50(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_ab){
        .fst = libcrux_ml_kem_types_from_19_80(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_9e call_mut_35_44(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_u_f7(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_10_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE void ntt_vector_u_f7(Eurydice_arr_9e *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_1e
deserialize_then_decompress_u_44(const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_44(&lvalue););
  Eurydice_arr_1e u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)768U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d41(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_f7(u_bytes);
    ntt_vector_u_f7(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_53(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_ea(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_66(
  const Eurydice_arr_9e *v,
  const Eurydice_arr_1e *secret_as_ntt,
  const Eurydice_arr_1e *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_66(&result, &product););
  invert_ntt_montgomery_66(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_71(const Eurydice_arr_1e *secret_key, const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e u_as_ntt = deserialize_then_decompress_u_44(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_53(Eurydice_array_to_subslice_from_shared_5f(ciphertext,
        (size_t)640U));
  Eurydice_arr_9e message = compute_message_66(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 2
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_d5(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(
  const libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  const Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_71(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_df(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_d5(Eurydice_array_to_slice_shared_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext =
    encrypt_unpacked_d50(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_27(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_0b_66(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e
deserialize_ring_elements_reduced_out_66(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_66(&lvalue););
  Eurydice_arr_1e deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_66(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_53(const Eurydice_arr_03 *public_key)
{
  Eurydice_arr_1e
  deserialized_pk =
    deserialize_ring_elements_reduced_out_66(Eurydice_array_to_subslice_to_shared_210(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_53(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f1(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  return Eurydice_array_eq((size_t)800U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_e2(const Eurydice_arr_ab0 *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_af(Eurydice_array_to_subslice_shared_d45(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)2U,
            .end = (size_t)768U * (size_t)2U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d45(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)2U + (size_t)32U,
          .end = (size_t)768U * (size_t)2U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d5(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_e2(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair512
generate_keypair_300(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_1e private_key = default_70_66();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b public_key = default_8b_66();
  generate_keypair_unpacked_390(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_44(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE Eurydice_arr_ab0
serialize_kem_secret_key_e2(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_ab0 out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_b80(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 = generate_keypair_300(ind_cpa_keypair_randomness);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 public_key = uu____0.snd;
  Eurydice_arr_ab0
  secret_key_serialized =
    serialize_kem_secret_key_e2(Eurydice_array_to_slice_shared_27(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_3b(&public_key),
      implicit_rejection_value);
  Eurydice_arr_ab0 private_key = libcrux_ml_kem_types_from_b2_be(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_d6(private_key,
      libcrux_ml_kem_types_from_51_df(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_10(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
build_unpacked_public_key_050(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
  unpacked_public_key = default_8b_66();
  build_unpacked_public_key_mut_050(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_d50(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
  unpacked_public_key = build_unpacked_public_key_050(public_key);
  return encrypt_unpacked_d50(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_e2(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_990(
  const Eurydice_arr_03 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_10(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_af(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_d50(Eurydice_array_to_slice_shared_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d2 uu____2 = libcrux_ml_kem_types_from_19_80(ciphertext);
  return (KRML_CLITERAL(tuple_ab){ .fst = uu____2, .snd = kdf_39_e2(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_9e call_mut_0b_71(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_71(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_71(&lvalue););
  Eurydice_arr_1e secret_key_unpacked = arr_struct;
  deserialize_vector_66(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_71(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd0(
  const Eurydice_arr_ab0 *private_key,
  const Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_shared_99(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_71(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03 to_hash = libcrux_ml_kem_utils_into_padded_array_df(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_d5(Eurydice_array_to_slice_shared_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext = encrypt_d50(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_e2(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_e2(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_27(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_68(
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_arr_bb *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_shared_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 3
*/
static inline Eurydice_arr_1b shake128_init_absorb_final_78(const Eurydice_arr_81 *input)
{
  Eurydice_arr_1b shake128_state;
  Eurydice_arr_7c repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_shared_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 3
*/
Eurydice_arr_1b
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(
  const Eurydice_arr_81 *input
)
{
  return shake128_init_absorb_final_78(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 3
*/
static inline Eurydice_arr_7e shake128_squeeze_first_three_blocks_78(Eurydice_arr_1b *st)
{
  Eurydice_arr_7e
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 3
*/
Eurydice_arr_7e
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(
  Eurydice_arr_1b *self
)
{
  return shake128_squeeze_first_three_blocks_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_b6(
  const Eurydice_arr_7e *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d42(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 3
*/
static inline Eurydice_arr_2c shake128_squeeze_next_block_78(Eurydice_arr_1b *st)
{
  Eurydice_arr_2c
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 3
*/
Eurydice_arr_2c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(Eurydice_arr_1b *self)
{
  return shake128_squeeze_next_block_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_b60(
  const Eurydice_arr_2c *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_shared_d43(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e7(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_0a_91(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_shared_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb sample_from_xof_91(const Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1b
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(seeds);
  Eurydice_arr_7e
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_b6(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(&xof_state);
      done = sample_from_uniform_distribution_next_b60(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_bb arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_91(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_91(Eurydice_arr_1d *A_transpose, const Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_bb sampled = sample_from_xof_91(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 3
*/
static inline Eurydice_arr_ec H_4a_78(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(
  const Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  Eurydice_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_shared_211(public_key, (size_t)1152U);
  deserialize_ring_elements_reduced_68(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_shared_5f3(public_key,
        (size_t)1152U));
  Eurydice_arr_1d *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_shared_5f3(public_key,
        (size_t)1152U));
  sample_matrix_A_91(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_78(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
const
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return &self->public_key;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.clone_91
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static inline libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
clone_91_68(const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *self)
{
  Eurydice_arr_bb
  uu____0 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
      &self->t_as_ntt,
      Eurydice_arr_9e,
      Eurydice_arr_bb);
  Eurydice_arr_ec
  uu____1 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
      &self->seed_for_A,
      uint8_t,
      Eurydice_arr_ec);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51){
        .t_as_ntt = uu____0,
        .seed_for_A = uu____1,
        .A = core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
          &self->A,
          Eurydice_arr_bb,
          Eurydice_arr_1d)
      }
    );
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  uu____0 = clone_91_68(&self->ind_cpa_public_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51){
        .ind_cpa_public_key = uu____0,
        .public_key_hash = core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
          &self->public_key_hash,
          uint8_t,
          Eurydice_arr_ec)
      }
    );
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
serialize_vector_68(const Eurydice_arr_bb *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_b6(
  const Eurydice_arr_bb *t_as_ntt,
  Eurydice_borrow_slice_u8 seed_for_a,
  Eurydice_arr_5f *serialized
)
{
  serialize_vector_68(t_as_ntt,
    Eurydice_array_to_subslice_mut_d415(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f4(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self,
  Eurydice_arr_5f *serialized
)
{
  serialize_public_key_mut_b6(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialize_public_key_b6(const Eurydice_arr_bb *t_as_ntt, Eurydice_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_5f public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_b6(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialized_dd_b6(const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self)
{
  return
    libcrux_ml_kem_types_from_51_3d(serialize_public_key_b6(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_shared_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return serialized_dd_b6(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair768
serialize_unpacked_secret_key_30(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key,
  const Eurydice_arr_bb *private_key
)
{
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_b6(&public_key->t_as_ntt,
      Eurydice_array_to_slice_shared_01(&public_key->seed_for_A));
  Eurydice_arr_0e secret_key_serialized = { .data = { 0U } };
  serialize_vector_68(private_key, Eurydice_array_to_slice_mut_f4(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair768){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_78(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d416(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 =
    serialize_unpacked_secret_key_30(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(Eurydice_array_to_slice_shared_f4(&ind_cpa_private_key),
    Eurydice_array_to_slice_shared_ff(&ind_cpa_public_key),
    Eurydice_array_to_slice_shared_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  Eurydice_arr_7d sk = libcrux_ml_kem_types_default_d3_79();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_vector_68(Eurydice_borrow_slice_u8 secret_key, Eurydice_arr_bb *secret_as_ntt)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_shared_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_05(
  Eurydice_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_68(Eurydice_slice_subslice_to_shared_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_shared_6d(public_key, (size_t)1152U);
  Eurydice_arr_1d *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_91(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(
  const Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_shared_51(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_68(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_05(ind_cpa_public_key, &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_shared_6d(ind_cpa_public_key, (size_t)1152U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_bb default_70_68(void)
{
  Eurydice_arr_bb lit;
  Eurydice_arr_9e repeat_expression[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 default_8b_68(void)
{
  Eurydice_arr_bb uu____0;
  Eurydice_arr_9e repeat_expression0[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)3U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_bb repeat_expression1[3U];
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    Eurydice_arr_bb lit;
    Eurydice_arr_9e repeat_expression[3U];
    KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)3U * sizeof (Eurydice_arr_bb));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_default_30_68(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51){
        .ind_cpa_public_key = default_8b_68(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_68(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51
  uu____0 =
    { .ind_cpa_private_key = default_70_68(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_68()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 3
*/
static inline Eurydice_arr_c7 G_4a_78(Eurydice_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_13(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)3U;
  return G_4a_78(Eurydice_array_to_slice_shared_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_58 PRFxN_3b(const Eurydice_arr_801 *input)
{
  Eurydice_arr_58
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_shared_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_58 PRFxN_4a_3b(const Eurydice_arr_801 *input)
{
  return PRFxN_3b(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf(
  Eurydice_arr_bb *re_as_ntt,
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_4a_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_73_39(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_68(Eurydice_arr_9e *myself, const Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_68(Eurydice_arr_9e *self, const Eurydice_arr_9e *rhs)
{
  add_to_ring_element_68(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
compute_As_plus_e_68(
  Eurydice_arr_bb *t_as_ntt,
  const Eurydice_arr_1d *matrix_A,
  const Eurydice_arr_bb *s_as_ntt,
  const Eurydice_arr_bb *error_as_ntt
)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    const Eurydice_arr_bb *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR3(i1,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i1;
      const Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_68(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_39(
  Eurydice_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_bb *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_13(key_generation_seed);
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_1d *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_91(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf(private_key, &prf_input, 0U);
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_39(&lvalue););
  Eurydice_arr_bb error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_68(&public_key->t_as_ntt, &public_key->A, &private_key[0U], &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_b4_68(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_bb call_mut_22_68(void **_)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_68(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_1d transpose_a_68(Eurydice_arr_1d ind_cpa_a)
{
  Eurydice_arr_1d arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_68(&lvalue););
  Eurydice_arr_1d A = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_39(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_1d A = transpose_a_68(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_5f
  pk_serialized =
    serialize_public_key_b6(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_shared_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_78(Eurydice_array_to_slice_shared_ff(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_c7
encaps_prepare_13(Eurydice_borrow_slice_u8 randomness, Eurydice_borrow_slice_u8 pk_hash)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_78(Eurydice_array_to_slice_shared_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_bb, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_5b_s
{
  Eurydice_arr_bb fst;
  Eurydice_arr_9e snd;
}
tuple_5b;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_87(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_87(void **_)
{
  return ZERO_d6_ea();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf(
  const Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_bb *error_1
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_4a_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_3b0(Eurydice_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_a8_68(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_68(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb
compute_vector_u_68(
  const Eurydice_arr_1d *a_as_ntt,
  const Eurydice_arr_bb *r_as_ntt,
  const Eurydice_arr_bb *error_1
)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_68(&lvalue););
  Eurydice_arr_bb result = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    const Eurydice_arr_bb *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      const Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_68(&result.data[i1], &product););
    invert_ntt_montgomery_68(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- OUT_LEN= 960
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_21(Eurydice_arr_bb input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)960U / (size_t)3U),
            .end = (i0 + (size_t)1U) * ((size_t)960U / (size_t)3U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_f7(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_5b
encrypt_c1_87(
  Eurydice_borrow_slice_u8 randomness,
  const Eurydice_arr_1d *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_bb arr_struct0;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_87(&lvalue););
  Eurydice_arr_bb r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_87(&lvalue););
  Eurydice_arr_bb error_1 = arr_struct;
  uint8_t domain_separator = sample_ring_element_cbd_bf(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_3b0(Eurydice_array_to_slice_shared_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_shared_78(&prf_output));
  Eurydice_arr_bb u = compute_vector_u_68(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_21(u, ciphertext);
  return (KRML_CLITERAL(tuple_5b){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_68(
  const Eurydice_arr_bb *t_as_ntt,
  const Eurydice_arr_bb *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_68(&result, &product););
  invert_ntt_montgomery_68(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_30(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_30(
  const Eurydice_arr_bb *t_as_ntt,
  const Eurydice_arr_bb *r_as_ntt,
  const Eurydice_arr_9e *error_2,
  const Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_68(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_30(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_unpacked_d5(
  const libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  Eurydice_arr_2b ciphertext = { .data = { 0U } };
  tuple_5b
  uu____0 =
    encrypt_c1_87(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d414(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)960U })));
  Eurydice_arr_bb r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_30(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f3(&ciphertext, (size_t)960U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(
  const libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_13(Eurydice_array_to_slice_shared_01(randomness),
      Eurydice_array_to_slice_shared_01(&public_key->public_key_hash));
  Eurydice_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_2b
  ciphertext = encrypt_unpacked_d5(&public_key->ind_cpa_public_key, randomness, pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_f4){
        .fst = libcrux_ml_kem_types_from_19_52(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_9e call_mut_35_30(void **_)
{
  return ZERO_d6_ea();
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_bb
deserialize_then_decompress_u_30(const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_30(&lvalue););
  Eurydice_arr_bb u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1088U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_shared_d46(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_f7(u_bytes);
    ntt_vector_u_f7(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_b6(Eurydice_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_ea(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_68(
  const Eurydice_arr_9e *v,
  const Eurydice_arr_bb *secret_as_ntt,
  const Eurydice_arr_bb *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_68(&result, &product););
  invert_ntt_montgomery_68(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_01(const Eurydice_arr_bb *secret_key, const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb u_as_ntt = deserialize_then_decompress_u_30(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_b6(Eurydice_array_to_subslice_from_shared_5f2(ciphertext,
        (size_t)960U));
  Eurydice_arr_9e message = compute_message_68(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 3
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_3b(Eurydice_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(
  const libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  const Eurydice_arr_2b *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_01(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_shared_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_66(Eurydice_array_to_slice_shared_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f2(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_3b(Eurydice_array_to_slice_shared_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext =
    encrypt_unpacked_d5(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_shared_06(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_0b_68(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb
deserialize_ring_elements_reduced_out_68(Eurydice_borrow_slice_u8 public_key)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_68(&lvalue););
  Eurydice_arr_bb deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_68(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_b6(const Eurydice_arr_5f *public_key)
{
  Eurydice_arr_bb
  deserialized_pk =
    deserialize_ring_elements_reduced_out_68(Eurydice_array_to_subslice_to_shared_211(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_b6(&deserialized_pk,
      Eurydice_array_to_subslice_from_shared_5f3(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  return Eurydice_array_eq((size_t)1184U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_52(const Eurydice_arr_7d *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_78(Eurydice_array_to_subslice_shared_d47(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)3U,
            .end = (size_t)768U * (size_t)3U + (size_t)32U
          }
        )));
  Eurydice_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_shared_d47(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)3U + (size_t)32U,
          .end = (size_t)768U * (size_t)3U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_shared((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_ba(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_52(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair768
generate_keypair_30(Eurydice_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_bb private_key = default_70_68();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 public_key = default_8b_68();
  generate_keypair_unpacked_39(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_30(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE Eurydice_arr_7d
serialize_kem_secret_key_52(
  Eurydice_borrow_slice_u8 private_key,
  Eurydice_borrow_slice_u8 public_key,
  Eurydice_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_7d out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b8(const Eurydice_arr_c7 *randomness)
{
  Eurydice_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_shared_d44(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_shared_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 = generate_keypair_30(ind_cpa_keypair_randomness);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f public_key = uu____0.snd;
  Eurydice_arr_7d
  secret_key_serialized =
    serialize_kem_secret_key_52(Eurydice_array_to_slice_shared_f4(&ind_cpa_private_key),
      Eurydice_array_to_slice_shared_ff(&public_key),
      implicit_rejection_value);
  Eurydice_arr_7d private_key = libcrux_ml_kem_types_from_b2_79(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_bc(private_key,
      libcrux_ml_kem_types_from_51_3d(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_13(Eurydice_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
build_unpacked_public_key_05(Eurydice_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  unpacked_public_key = default_8b_68();
  build_unpacked_public_key_mut_05(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_d5(
  Eurydice_borrow_slice_u8 public_key,
  const Eurydice_arr_ec *message,
  Eurydice_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  unpacked_public_key = build_unpacked_public_key_05(public_key);
  return encrypt_unpacked_d5(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_52(Eurydice_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_99(
  const Eurydice_arr_5f *public_key,
  const Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_13(Eurydice_array_to_slice_shared_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_78(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_shared_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_shared_17(&to_hash));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_d5(Eurydice_array_to_slice_shared_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_2b uu____2 = libcrux_ml_kem_types_from_19_52(ciphertext);
  return (KRML_CLITERAL(tuple_f4){ .fst = uu____2, .snd = kdf_39_52(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_9e call_mut_0b_01(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_01(Eurydice_borrow_slice_u8 secret_key, const Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_01(&lvalue););
  Eurydice_arr_bb secret_key_unpacked = arr_struct;
  deserialize_vector_68(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_01(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd(
  const Eurydice_arr_7d *private_key,
  const Eurydice_arr_2b *ciphertext
)
{
  Eurydice_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_shared_51(private_key));
  Eurydice_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_01(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_shared_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_shared_17(&to_hash0));
  Eurydice_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_shared_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_borrow_slice_u8_x2);
  Eurydice_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af to_hash = libcrux_ml_kem_utils_into_padded_array_66(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f2(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_3b(Eurydice_array_to_slice_shared_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext = encrypt_d5(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_52(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_52(shared_secret0);
  Eurydice_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_shared_06(&expected_ciphertext),
      Eurydice_array_to_slice_shared_01(&shared_secret),
      Eurydice_array_to_slice_shared_01(&implicit_rejection_shared_secret0));
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_mlkem_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem_portable_H
#define libcrux_mlkem_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

Eurydice_arr_c7 libcrux_ml_kem_hash_functions_portable_G(Eurydice_borrow_slice_u8 input);

Eurydice_arr_ec libcrux_ml_kem_hash_functions_portable_H(Eurydice_borrow_slice_u8 input);

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR ((size_t)16U)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS (1353)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS (3329)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R (62209U)

typedef Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_PortableVector;

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_i16_array(Eurydice_borrow_slice_i16 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_borrow_slice_i16 array);

typedef struct uint8_t_x11_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
  uint8_t f4;
  uint8_t f5;
  uint8_t f6;
  uint8_t f7;
  uint8_t f8;
  uint8_t f9;
  uint8_t f10;
}
uint8_t_x11;

uint8_t_x11
libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_borrow_slice_i16 v);

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_serialize_11(Eurydice_arr_d6 v);

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11_b8(Eurydice_arr_d6 a);

typedef struct int16_t_x8_s
{
  int16_t fst;
  int16_t snd;
  int16_t thd;
  int16_t f3;
  int16_t f4;
  int16_t f5;
  int16_t f6;
  int16_t f7;
}
int16_t_x8;

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_11(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11_b8(Eurydice_borrow_slice_u8 a);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_to_i16_array(Eurydice_arr_d6 x);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_i16_array_b8(Eurydice_arr_d6 x);

#define LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE ((KRML_CLITERAL(Eurydice_arr_87){ .data = { { .data = { 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U } }, { .data = { 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U } }, { .data = { 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U } }, { .data = { 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U } } } }))

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_zero(void);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_ZERO_b8(void);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_bytes(Eurydice_borrow_slice_u8 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_from_bytes_b8(Eurydice_borrow_slice_u8 array);

void
libcrux_ml_kem_vector_portable_vector_type_to_bytes(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
void
libcrux_ml_kem_vector_portable_to_bytes_b8(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_add(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_add_b8(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_sub(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_sub_b8(Eurydice_arr_d6 lhs, const Eurydice_arr_d6 *rhs);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(Eurydice_arr_d6 vec, int16_t c);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_multiply_by_constant_b8(Eurydice_arr_d6 vec, int16_t c);

/**
 Note: This function is not secret independent
 Only use with public values.
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(Eurydice_arr_d6 vec);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(Eurydice_arr_d6 v);

#define LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_BARRETT_MULTIPLIER (20159)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT (26)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_R ((int32_t)((uint32_t)1 << (uint32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT))

/**
 Signed Barrett Reduction

 Given an input `value`, `barrett_reduce` outputs a representative `result`
 such that:

 - result ≡ value (mod FIELD_MODULUS)
 - the absolute value of `result` is bound as follows:

 `|result| ≤ FIELD_MODULUS / 2 · (|value|/BARRETT_R + 1)

 Note: The input bound is 28296 to prevent overflow in the multiplication of quotient by FIELD_MODULUS

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(int16_t value);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(Eurydice_arr_d6 vec);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_barrett_reduce_b8(Eurydice_arr_d6 vector);

#define LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT (16U)

/**
 Signed Montgomery Reduction

 Given an input `value`, `montgomery_reduce` outputs a representative `o`
 such that:

 - o ≡ value · MONTGOMERY_R^(-1) (mod FIELD_MODULUS)
 - the absolute value of `o` is bound as follows:

 `|result| ≤ ceil(|value| / MONTGOMERY_R) + 1665

 In particular, if `|value| ≤ FIELD_MODULUS-1 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS-1`.
 And, if `|value| ≤ pow2 16 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS + 1664

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(int32_t value);

/**
 If `fe` is some field element 'x' of the Kyber field and `fer` is congruent to
 `y · MONTGOMERY_R`, this procedure outputs a value that is congruent to
 `x · y`, as follows:

    `fe · fer ≡ x · y · MONTGOMERY_R (mod FIELD_MODULUS)`

 `montgomery_reduce` takes the value `x · y · MONTGOMERY_R` and outputs a representative
 `x · y · MONTGOMERY_R * MONTGOMERY_R^{-1} ≡ x · y (mod FIELD_MODULUS)`.
*/
int16_t
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(
  int16_t fe,
  int16_t fer
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(
  Eurydice_arr_d6 vec,
  int16_t c
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(
  Eurydice_arr_d6 vector,
  int16_t constant
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(
  Eurydice_arr_d6 vec,
  int16_t c
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(Eurydice_arr_d6 a);

/**
 The `compress_*` functions implement the `Compress` function specified in the NIST FIPS
 203 standard (Page 18, Expression 4.5), which is defined as:

 ```plaintext
 Compress_d: ℤq -> ℤ_{2ᵈ}
 Compress_d(x) = ⌈(2ᵈ/q)·x⌋
 ```

 Since `⌈x⌋ = ⌊x + 1/2⌋` we have:

 ```plaintext
 Compress_d(x) = ⌊(2ᵈ/q)·x + 1/2⌋
               = ⌊(2^{d+1}·x + q) / 2q⌋
 ```

 For further information about the function implementations, consult the
 `implementation_notes.pdf` document in this directory.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
uint8_t libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(uint16_t fe);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_compress_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_1_b8(Eurydice_arr_d6 a);

uint32_t
libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(
  uint8_t n,
  uint32_t value
);

int16_t
libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient(
  uint8_t coefficient_bits,
  uint16_t fe
);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_decompress_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_decompress_1_b8(Eurydice_arr_d6 a);

void
libcrux_ml_kem_vector_portable_ntt_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta);

void
libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta);

/**
 Compute the product of two Kyber binomials with respect to the
 modulus `X² - zeta`.

 This function almost implements <strong>Algorithm 11</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input:  a₀, a₁, b₀, b₁ ∈ ℤq.
 Input: γ ∈ ℤq.
 Output: c₀, c₁ ∈ ℤq.

 c₀ ← a₀·b₀ + a₁·b₁·γ
 c₁ ← a₀·b₁ + a₁·b₀
 return c₀, c₁
 ```
 We say "almost" because the coefficients output by this function are in
 the Montgomery domain (unlike in the specification).

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
void
libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(
  const Eurydice_arr_d6 *a,
  const Eurydice_arr_d6 *b,
  int16_t zeta,
  size_t i,
  Eurydice_arr_d6 *out
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_multiply(
  const Eurydice_arr_d6 *lhs,
  const Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_multiply_b8(
  const Eurydice_arr_d6 *lhs,
  const Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_serialize_1(Eurydice_arr_d6 v);

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1_b8(Eurydice_arr_d6 a);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_1(Eurydice_borrow_slice_u8 v);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_borrow_slice_u8 a);

typedef struct uint8_t_x4_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
}
uint8_t_x4;

uint8_t_x4
libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_borrow_slice_i16 v);

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_serialize_4(Eurydice_arr_d6 v);

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_4(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4_b8(Eurydice_borrow_slice_u8 a);

typedef struct uint8_t_x5_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
  uint8_t f4;
}
uint8_t_x5;

uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_borrow_slice_i16 v);

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_serialize_5(Eurydice_arr_d6 v);

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_5(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5_b8(Eurydice_borrow_slice_u8 a);

uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_borrow_slice_i16 v);

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_serialize_10(Eurydice_arr_d6 v);

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_10(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10_b8(Eurydice_borrow_slice_u8 a);

typedef struct uint8_t_x3_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
}
uint8_t_x3;

uint8_t_x3
libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_borrow_slice_i16 v);

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_serialize_12(Eurydice_arr_d6 v);

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12_b8(Eurydice_arr_d6 a);

typedef struct int16_t_x2_s
{
  int16_t fst;
  int16_t snd;
}
int16_t_x2;

int16_t_x2
libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_12(Eurydice_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12(Eurydice_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12_b8(Eurydice_borrow_slice_u8 a);

size_t
libcrux_ml_kem_vector_portable_sampling_rej_sample(
  Eurydice_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 result
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
size_t
libcrux_ml_kem_vector_portable_rej_sample_b8(
  Eurydice_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 out
);

typedef int16_t libcrux_ml_kem_vector_portable_arithmetic_FieldElementTimesMontgomeryR;

typedef int16_t libcrux_ml_kem_vector_portable_arithmetic_MontgomeryFieldElement;

typedef int16_t libcrux_ml_kem_vector_portable_vector_type_FieldElement;

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_clone_9c(const Eurydice_arr_d6 *self);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem_portable_H_DEFINED
#endif /* libcrux_mlkem_portable_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_sha3_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_sha3_avx2.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i zero_b0(void)
{
  return mm256_set1_epi64x(0LL);
}

static KRML_MUSTINLINE __m256i
_veor5q_u64(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  __m256i ab = mm256_xor_si256(a, b);
  __m256i cd = mm256_xor_si256(c, d);
  __m256i abcd = mm256_xor_si256(ab, cd);
  return mm256_xor_si256(abcd, e);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor5_b0(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  return _veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i rotate_left_76(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(1, x, __m256i), mm256_srli_epi64(63, x, __m256i));
}

static KRML_MUSTINLINE __m256i _vrax1q_u64(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, rotate_left_76(b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i rotate_left1_and_xor_b0(__m256i a, __m256i b)
{
  return _vrax1q_u64(a, b);
}

static KRML_MUSTINLINE __m256i _vbcaxq_u64(__m256i a, __m256i b, __m256i c)
{
  return mm256_xor_si256(a, mm256_andnot_si256(c, b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i and_not_xor_b0(__m256i a, __m256i b, __m256i c)
{
  return _vbcaxq_u64(a, b, c);
}

static KRML_MUSTINLINE __m256i _veorq_n_u64(__m256i a, uint64_t c)
{
  __m256i c0 = mm256_set1_epi64x((int64_t)c);
  return mm256_xor_si256(a, c0);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_constant_b0(__m256i a, uint64_t c)
{
  return _veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_b0(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40 new_80_5d(void)
{
  Eurydice_arr_c40 lit;
  __m256i repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = zero_b0();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (__m256i));
  return lit;
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void set_ij_5d(Eurydice_arr_c40 *arr, size_t i, size_t j, __m256i value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE const
__m256i
*get_ij_5d(const Eurydice_arr_c40 *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
load_block_b2(Eurydice_arr_c40 *state, const Eurydice_arr_68 *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256(32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256(32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256(49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256(49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], v0));
    set_ij_5d(state, i1, j1, mm256_xor_si256(get_ij_5d(state, i1, j1)[0U], v1));
    set_ij_5d(state, i2, j2, mm256_xor_si256(get_ij_5d(state, i2, j2)[0U], v2));
    set_ij_5d(state, i3, j3, mm256_xor_si256(get_ij_5d(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)136U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)136U / (size_t)32U);
  Eurydice_arr_ec u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)136U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)136U / (size_t)32U) % (size_t)5U;
  set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_ec u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    set_ij_5d(state, i, j, mm256_xor_si256(get_ij_5d(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_22(Eurydice_arr_c40 *state, const Eurydice_arr_68 *blocks, size_t start, size_t len)
{
  Eurydice_arr_dc0
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_shared_c8(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)136U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_68
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_shared_58(buffers.data),
        Eurydice_array_to_slice_shared_58(&buffers.data[1U]),
        Eurydice_array_to_slice_shared_58(&buffers.data[2U]),
        Eurydice_array_to_slice_shared_58(&buffers.data[3U])
      }
    };
  load_block_b2(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 136
- DELIMITER= 31
*/
static void
load_last_8f_22(Eurydice_arr_c40 *self, const Eurydice_arr_68 *input, size_t start, size_t len)
{
  load_last_22(self, input, start, len);
}

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $5size_t
*/
typedef struct arr_50_s { __m256i data[5U]; } arr_50;

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static const __m256i *index_c2_5d(const Eurydice_arr_c40 *self, size_t_x2 index)
{
  return get_ij_5d(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE arr_50 theta_80_5d(Eurydice_arr_c40 *self)
{
  arr_50
  c =
    {
      .data = {
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(arr_50){
        .data = {
          rotate_left1_and_xor_b0(c.data[((size_t)0U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)1U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)2U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)3U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)4U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static void set_80_5d(Eurydice_arr_c40 *self, size_t i, size_t j, __m256i v)
{
  set_ij_5d(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i rotate_left_02(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(36, x, __m256i), mm256_srli_epi64(28, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_02(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_02(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_02(__m256i a, __m256i b)
{
  return _vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i rotate_left_ac(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(3, x, __m256i), mm256_srli_epi64(61, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ac(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ac(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ac(__m256i a, __m256i b)
{
  return _vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i rotate_left_020(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(41, x, __m256i), mm256_srli_epi64(23, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_020(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_020(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_020(__m256i a, __m256i b)
{
  return _vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i rotate_left_a9(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(18, x, __m256i), mm256_srli_epi64(46, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_a9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_a9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_a9(__m256i a, __m256i b)
{
  return _vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_0_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)0U,
    xor_b0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)0U,
    xor_and_rotate_b0_02(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)0U,
    xor_and_rotate_b0_ac(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)0U,
    xor_and_rotate_b0_020(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)0U,
    xor_and_rotate_b0_a9(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_76(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_76(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_76(__m256i a, __m256i b)
{
  return _vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i rotate_left_58(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(44, x, __m256i), mm256_srli_epi64(20, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_58(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_58(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_58(__m256i a, __m256i b)
{
  return _vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i rotate_left_e0(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(10, x, __m256i), mm256_srli_epi64(54, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_e0(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_e0(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_e0(__m256i a, __m256i b)
{
  return _vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i rotate_left_63(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(45, x, __m256i), mm256_srli_epi64(19, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_63(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_63(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_63(__m256i a, __m256i b)
{
  return _vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i rotate_left_6a(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(2, x, __m256i), mm256_srli_epi64(62, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6a(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6a(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6a(__m256i a, __m256i b)
{
  return _vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_1_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)1U,
    xor_and_rotate_b0_76(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)1U,
    xor_and_rotate_b0_58(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)1U,
    xor_and_rotate_b0_e0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)1U,
    xor_and_rotate_b0_63(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)1U,
    xor_and_rotate_b0_6a(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i rotate_left_ab(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(62, x, __m256i), mm256_srli_epi64(2, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ab(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ab(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ab(__m256i a, __m256i b)
{
  return _vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i rotate_left_5b(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(6, x, __m256i), mm256_srli_epi64(58, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_5b(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_5b(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_5b(__m256i a, __m256i b)
{
  return _vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i rotate_left_6f(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(43, x, __m256i), mm256_srli_epi64(21, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6f(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6f(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6f(__m256i a, __m256i b)
{
  return _vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i rotate_left_62(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(15, x, __m256i), mm256_srli_epi64(49, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_62(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_62(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_62(__m256i a, __m256i b)
{
  return _vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i rotate_left_23(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(61, x, __m256i), mm256_srli_epi64(3, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_23(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_23(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_23(__m256i a, __m256i b)
{
  return _vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_2_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)2U,
    xor_and_rotate_b0_ab(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)2U,
    xor_and_rotate_b0_5b(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)2U,
    xor_and_rotate_b0_6f(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)2U,
    xor_and_rotate_b0_62(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)2U,
    xor_and_rotate_b0_23(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i rotate_left_37(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(28, x, __m256i), mm256_srli_epi64(36, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_37(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_37(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_37(__m256i a, __m256i b)
{
  return _vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i rotate_left_bb(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(55, x, __m256i), mm256_srli_epi64(9, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_bb(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_bb(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_bb(__m256i a, __m256i b)
{
  return _vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i rotate_left_b9(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(25, x, __m256i), mm256_srli_epi64(39, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_b9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_b9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_b9(__m256i a, __m256i b)
{
  return _vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i rotate_left_54(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(21, x, __m256i), mm256_srli_epi64(43, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_54(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_54(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_54(__m256i a, __m256i b)
{
  return _vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i rotate_left_4c(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(56, x, __m256i), mm256_srli_epi64(8, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_4c(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_4c(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_4c(__m256i a, __m256i b)
{
  return _vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_3_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)3U,
    xor_and_rotate_b0_37(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)3U,
    xor_and_rotate_b0_bb(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)3U,
    xor_and_rotate_b0_b9(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)3U,
    xor_and_rotate_b0_54(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)3U,
    xor_and_rotate_b0_4c(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i rotate_left_ce(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(27, x, __m256i), mm256_srli_epi64(37, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ce(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ce(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ce(__m256i a, __m256i b)
{
  return _vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i rotate_left_77(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(20, x, __m256i), mm256_srli_epi64(44, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_77(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_77(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_77(__m256i a, __m256i b)
{
  return _vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i rotate_left_25(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(39, x, __m256i), mm256_srli_epi64(25, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_25(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_25(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_25(__m256i a, __m256i b)
{
  return _vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i rotate_left_af(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(8, x, __m256i), mm256_srli_epi64(56, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_af(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_af(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_af(__m256i a, __m256i b)
{
  return _vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i rotate_left_fd(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(14, x, __m256i), mm256_srli_epi64(50, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_fd(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_fd(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_fd(__m256i a, __m256i b)
{
  return _vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_4_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)4U,
    xor_and_rotate_b0_ce(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)4U,
    xor_and_rotate_b0_77(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)4U,
    xor_and_rotate_b0_25(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)4U,
    xor_and_rotate_b0_af(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)4U,
    xor_and_rotate_b0_fd(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  rho_0_80_5d(self, t);
  rho_1_80_5d(self, t);
  rho_2_80_5d(self, t);
  rho_3_80_5d(self, t);
  rho_4_80_5d(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_0_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)1U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_1_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_2_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_3_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_4_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_80_5d(Eurydice_arr_c40 *self)
{
  Eurydice_arr_c40 old = self[0U];
  pi_0_80_5d(self, old);
  pi_1_80_5d(self, old);
  pi_2_80_5d(self, old);
  pi_3_80_5d(self, old);
  pi_4_80_5d(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void chi_80_5d(Eurydice_arr_c40 *self)
{
  Eurydice_arr_c40 old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      set_80_5d(self,
        i1,
        j,
        and_not_xor_b0(index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          index_c2_5d(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          index_c2_5d(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void iota_80_5d(Eurydice_arr_c40 *self, size_t i)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)0U,
    xor_constant_b0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void keccakf1600_80_5d(Eurydice_arr_c40 *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    arr_50 t = theta_80_5d(self);
    rho_80_5d(self, t);
    pi_80_5d(self);
    chi_80_5d(self);
    iota_80_5d(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
absorb_final_80_af(
  Eurydice_arr_c40 *self,
  const Eurydice_arr_68 *input,
  size_t start,
  size_t len
)
{
  load_last_8f_22(self, input, start, len);
  keccakf1600_80_5d(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
store_block_b2(
  const Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_ec u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____1, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____2, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l = mm256_permute2x128_si256(32, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v1h = mm256_permute2x128_si256(32, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i
    v2l = mm256_permute2x128_si256(49, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v3h = mm256_permute2x128_si256(49, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 136
*/
static void
squeeze4_17_b2(
  const Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_b2(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block_8f
with const generics
- RATE= 136
*/
static void
load_block_8f_b2(Eurydice_arr_c40 *self, const Eurydice_arr_68 *input, size_t start)
{
  load_block_b2(self, input, start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
*/
static KRML_MUSTINLINE void
absorb_block_80_48(Eurydice_arr_c40 *self, const Eurydice_arr_68 *input, size_t start)
{
  load_block_8f_b2(self, input, start);
  keccakf1600_80_5d(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.keccak4
with const generics
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
keccak4_22(
  const Eurydice_arr_68 *data,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  Eurydice_arr_c40 s = new_80_5d();
  size_t data_len = data->data->meta;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = data_len / (size_t)136U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = data_len % (size_t)136U;
      absorb_final_80_af(&s, data, data_len - rem, rem);
      size_t outlen = out0.meta;
      size_t blocks = outlen / (size_t)136U;
      size_t last = outlen - outlen % (size_t)136U;
      if (blocks == (size_t)0U)
      {
        squeeze4_17_b2(&s, out0, out1, out2, out3, (size_t)0U, outlen);
      }
      else
      {
        squeeze4_17_b2(&s, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < blocks; i++)
        {
          size_t i0 = i;
          keccakf1600_80_5d(&s);
          squeeze4_17_b2(&s, out0, out1, out2, out3, i0 * (size_t)136U, (size_t)136U);
        }
        if (last < outlen)
        {
          keccakf1600_80_5d(&s);
          squeeze4_17_b2(&s, out0, out1, out2, out3, last, outlen - last);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    absorb_block_80_48(&s, data, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_68 lvalue = { .data = { input0, input1, input2, input3 } };
  keccak4_22(&lvalue, out0, out1, out2, out3);
}

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_c40 libcrux_sha3_avx2_x4_incremental_init(void)
{
  return new_80_5d();
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
load_block_60(Eurydice_arr_c40 *state, const Eurydice_arr_68 *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_shared_c8(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256(32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256(32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256(49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256(49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], v0));
    set_ij_5d(state, i1, j1, mm256_xor_si256(get_ij_5d(state, i1, j1)[0U], v1));
    set_ij_5d(state, i2, j2, mm256_xor_si256(get_ij_5d(state, i2, j2)[0U], v2));
    set_ij_5d(state, i3, j3, mm256_xor_si256(get_ij_5d(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)168U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)168U / (size_t)32U);
  Eurydice_arr_ec u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_shared_c8(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)168U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)168U / (size_t)32U) % (size_t)5U;
  set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_ec u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_shared_c8(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    set_ij_5d(state, i, j, mm256_xor_si256(get_ij_5d(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_37(Eurydice_arr_c40 *state, const Eurydice_arr_68 *blocks, size_t start, size_t len)
{
  Eurydice_arr_9c
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d41(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_shared_c8(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)168U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_68
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_shared_2c(buffers.data),
        Eurydice_array_to_slice_shared_2c(&buffers.data[1U]),
        Eurydice_array_to_slice_shared_2c(&buffers.data[2U]),
        Eurydice_array_to_slice_shared_2c(&buffers.data[3U])
      }
    };
  load_block_60(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 168
- DELIMITER= 31
*/
static void
load_last_8f_37(Eurydice_arr_c40 *self, const Eurydice_arr_68 *input, size_t start, size_t len)
{
  load_last_37(self, input, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 168
- DELIM= 31
*/
static KRML_MUSTINLINE void
absorb_final_80_af0(
  Eurydice_arr_c40 *self,
  const Eurydice_arr_68 *input,
  size_t start,
  size_t len
)
{
  load_last_8f_37(self, input, start, len);
  keccakf1600_80_5d(self);
}

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_68 lvalue = { .data = { data0, data1, data2, data3 } };
  absorb_final_80_af0(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
store_block_60(
  const Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_ec u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____1, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____2, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_shared_d4(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l = mm256_permute2x128_si256(32, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v1h = mm256_permute2x128_si256(32, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i
    v2l = mm256_permute2x128_si256(49, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v3h = mm256_permute2x128_si256(49, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 168
*/
static void
squeeze4_17_60(
  const Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_60(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_three_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_three_blocks_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_three_blocks_81_60(s, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, start, (size_t)168U);
}

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_60(s, out0, out1, out2, out3, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_five_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_five_blocks_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)3U * (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_five_blocks_81_60(s, out0, out1, out2, out3);
}

/**
 Absorb
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_68 lvalue = { .data = { data0, data1, data2, data3 } };
  absorb_final_80_af(s, &lvalue, (size_t)0U, data0.meta);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_first_block_81_b2(
  const Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_b2(self, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
}

/**
 Squeeze block
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_block_81_b2(&s[0U], out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_b2(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  keccakf1600_80_5d(self);
  squeeze4_17_b2(self, out0, out1, out2, out3, start, (size_t)136U);
}

/**
 Squeeze next block
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_b2(s, out0, out1, out2, out3, (size_t)0U);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_sha3_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_avx2_H
#define libcrux_sha3_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_c40_s { __m256i data[25U]; } Eurydice_arr_c40;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types core_core_arch_x86___m256i
with const generics
- $4size_t
*/
typedef Eurydice_arr_c40 libcrux_sha3_generic_keccak_KeccakState_7d;

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_borrow_slice_u8 input0,
  Eurydice_borrow_slice_u8 input1,
  Eurydice_borrow_slice_u8 input2,
  Eurydice_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

typedef libcrux_sha3_generic_keccak_KeccakState_7d
libcrux_sha3_avx2_x4_incremental_KeccakState;

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_c40 libcrux_sha3_avx2_x4_incremental_init(void);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
);

/**
 Squeeze three blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze five blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_borrow_slice_u8 data0,
  Eurydice_borrow_slice_u8 data1,
  Eurydice_borrow_slice_u8 data2,
  Eurydice_borrow_slice_u8 data3
);

/**
 Squeeze block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze next block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_avx2_H_DEFINED
#endif /* libcrux_sha3_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_internal_H
#define libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define libcrux_sha3_Algorithm_Sha224 1
#define libcrux_sha3_Algorithm_Sha256 2
#define libcrux_sha3_Algorithm_Sha384 3
#define libcrux_sha3_Algorithm_Sha512 4

typedef uint8_t libcrux_sha3_Algorithm;

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_internal_H_DEFINED
#endif /* libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-kem/libcrux_sha3_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_sha3_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_zero_d2(void)
{
  return 0ULL;
}

KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__veor5q_u64(
  uint64_t a,
  uint64_t b,
  uint64_t c,
  uint64_t d,
  uint64_t e
)
{
  return (((a ^ b) ^ c) ^ d) ^ e;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor5_d2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e)
{
  return libcrux_sha3_simd_portable__veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_76(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)1);
}

KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, uint64_t b)
{
  return a ^ libcrux_sha3_simd_portable_rotate_left_76(b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vrax1q_u64(a, b);
}

KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, uint64_t b, uint64_t c)
{
  return a ^ (b & ~c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, uint64_t b, uint64_t c)
{
  return libcrux_sha3_simd_portable__vbcaxq_u64(a, b, c);
}

KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, uint64_t c)
{
  return a ^ c;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c)
{
  return libcrux_sha3_simd_portable__veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_xor_d2(uint64_t a, uint64_t b)
{
  return a ^ b;
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE Eurydice_arr_7c libcrux_sha3_generic_keccak_new_80_71(void)
{
  Eurydice_arr_7c lit;
  uint64_t repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = libcrux_sha3_simd_portable_zero_d2();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (uint64_t));
  return lit;
}

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE const
uint64_t
*libcrux_sha3_traits_get_ij_71(const Eurydice_arr_7c *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_traits_set_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j, uint64_t value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_c6(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)72U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)72U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 72
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_dc(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ab buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d4(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)72U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_c6(state,
    Eurydice_array_to_slice_shared_e2(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_dc(self, input->data[0U], start, len);
}

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types uint64_t
with const generics
- N= 1
*/
const
uint64_t
*libcrux_sha3_generic_keccak_index_c2_71(const Eurydice_arr_7c *self, size_t_x2 index)
{
  return libcrux_sha3_traits_get_ij_71(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE Eurydice_arr_84 libcrux_sha3_generic_keccak_theta_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_84
  c =
    {
      .data = {
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(Eurydice_arr_84){
        .data = {
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)0U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)1U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)2U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)3U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)4U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types uint64_t
with const generics
- N= 1
*/
void
libcrux_sha3_generic_keccak_set_80_71(Eurydice_arr_7c *self, size_t i, size_t j, uint64_t v)
{
  libcrux_sha3_traits_set_ij_71(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_02(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)36);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_02(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)3);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ac(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_020(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)41);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_020(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)18);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_a9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_02(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_020(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_76(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_58(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)44);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_58(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)10);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_e0(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_63(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)45);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_63(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)2);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6a(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_76(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_58(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_63(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)62);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ab(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)6);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_5b(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)43);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6f(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_62(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)15);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_62(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_23(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)61);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_23(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_62(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_23(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_37(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)28);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_37(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)55);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_bb(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)25);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_b9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_54(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)21);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_54(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)56);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_4c(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_37(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_54(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)27);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ce(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_77(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)20);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_77(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_25(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)39);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_25(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_af(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)8);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_af(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)14);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_fd(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_77(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_25(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_af(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_rho_0_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_1_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_2_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_3_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_4_80_71(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_pi_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_7c old = self[0U];
  libcrux_sha3_generic_keccak_pi_0_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_1_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_2_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_3_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_4_80_71(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_chi_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_7c old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      libcrux_sha3_generic_keccak_set_80_71(self,
        i1,
        j,
        libcrux_sha3_simd_portable_and_not_xor_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_iota_80_71(Eurydice_arr_7c *self, size_t i)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_constant_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_keccakf1600_80_71(Eurydice_arr_7c *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_arr_84 t = libcrux_sha3_generic_keccak_theta_80_71(self);
    libcrux_sha3_generic_keccak_rho_80_71(self, t);
    libcrux_sha3_generic_keccak_pi_80_71(self);
    libcrux_sha3_generic_keccak_chi_80_71(self);
    libcrux_sha3_generic_keccak_iota_80_71(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_dc(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_c6(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_21(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_squeeze_9b_c6(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_c6(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_a1_c6(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_c6(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e9(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_c6(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 72
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_dc(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)72U;
  size_t input_rem = input_len % (size_t)72U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd(&s, &lvalue, input_len - input_rem, input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)72U;
      size_t output_rem = output_len % (size_t)72U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, (size_t)0U, (size_t)72U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, i0 * (size_t)72U, (size_t)72U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e9(&s, &lvalue, i * (size_t)72U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 512 implementation.
*/
void
libcrux_sha3_portable_sha512(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_dc(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_b2(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)136U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_22(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ff buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_b2(state,
    Eurydice_array_to_slice_shared_58(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_22(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_22(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd0(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_22(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_b2(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_21(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_squeeze_9b_b2(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_b2(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_a1_b2(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_b2(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e90(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_b2(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_22(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd0(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e90(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 256 implementation.
*/
void
libcrux_sha3_portable_sha256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_22(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_220(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ff buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_b2(state,
    Eurydice_array_to_slice_shared_58(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_220(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_220(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd1(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_220(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 31
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_220(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd1(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e90(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHAKE256 implementation.
*/
void
libcrux_sha3_portable_shake256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_220(data, digest);
}

/**
 Create a new SHAKE-128 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake128_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_71();
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_60(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)168U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_37(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_c5 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d41(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)168U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_60(state,
    Eurydice_array_to_slice_shared_2c(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_37(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_37(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd2(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_37(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
 Absorb
*/
void
libcrux_sha3_portable_incremental_shake128_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_borrow_slice_u8 data0
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_dc lvalue = { .data = { data0 } };
  libcrux_sha3_generic_keccak_absorb_final_80_bd2(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_60(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_21(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_squeeze_9b_60(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_60(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(s, out0);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, start, (size_t)168U);
}

/**
 Squeeze another block
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(s, out0, (size_t)0U);
}

/**
 Returns the output size of a digest.
*/
size_t libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode)
{
  switch (mode)
  {
    case libcrux_sha3_Algorithm_Sha224:
      {
        break;
      }
    case libcrux_sha3_Algorithm_Sha256:
      {
        return LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha384:
      {
        return LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha512:
      {
        return LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_9e(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)144U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)144U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 144
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_3a(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_f4 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d42(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)144U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_9e(state,
    Eurydice_array_to_slice_shared_38(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_3a(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_3a(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd3(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_3a(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_9e(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_21(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_squeeze_9b_9e(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_9e(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_a1_9e(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_9e(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e91(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_9e(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 144
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_3a(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)144U;
  size_t input_rem = input_len % (size_t)144U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd3(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)144U;
      size_t output_rem = output_len % (size_t)144U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, (size_t)0U, (size_t)144U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, i0 * (size_t)144U, (size_t)144U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e91(&s, &lvalue, i * (size_t)144U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 224 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_sha224(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_3a(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_53(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)104U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)104U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_shared_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 104
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_dc0(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_c4 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d43(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_shared_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)104U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_53(state,
    Eurydice_array_to_slice_shared_72(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc0(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_dc0(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd4(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_dc0(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_53(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_shared_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0,
      Eurydice_array_to_subslice_to_shared_21(&bytes, remaining),
      uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_squeeze_9b_53(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_53(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_a1_53(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_53(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e92(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_53(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 104
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_dc0(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)104U;
  size_t input_rem = input_len % (size_t)104U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd4(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)104U;
      size_t output_rem = output_len % (size_t)104U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, (size_t)0U, (size_t)104U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, i0 * (size_t)104U, (size_t)104U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e92(&s, &lvalue, i * (size_t)104U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 384 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_sha384(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_dc0(data, digest);
}

/**
 SHA3 224

 Preconditions:
 - `digest.len() == 28`
*/
void
libcrux_sha3_sha224_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha224(digest, payload);
}

/**
 SHA3 224
*/
Eurydice_arr_a2 libcrux_sha3_sha224(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_a2 out = { .data = { 0U } };
  libcrux_sha3_sha224_ema(Eurydice_array_to_slice_mut_5e(&out), data);
  return out;
}

/**
 SHA3 256
*/
void
libcrux_sha3_sha256_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha256(digest, payload);
}

/**
 SHA3 256
*/
Eurydice_arr_ec libcrux_sha3_sha256(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  libcrux_sha3_sha256_ema(Eurydice_array_to_slice_mut_01(&out), data);
  return out;
}

/**
 SHA3 384
*/
void
libcrux_sha3_sha384_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha384(digest, payload);
}

/**
 SHA3 384
*/
Eurydice_arr_65 libcrux_sha3_sha384(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_65 out = { .data = { 0U } };
  libcrux_sha3_sha384_ema(Eurydice_array_to_slice_mut_9f(&out), data);
  return out;
}

/**
 SHA3 512
*/
void
libcrux_sha3_sha512_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload)
{
  libcrux_sha3_portable_sha512(digest, payload);
}

/**
 SHA3 512
*/
Eurydice_arr_c7 libcrux_sha3_sha512(Eurydice_borrow_slice_u8 data)
{
  Eurydice_arr_c7 out = { .data = { 0U } };
  libcrux_sha3_sha512_ema(Eurydice_array_to_slice_mut_17(&out), data);
  return out;
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_a1_60(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_60(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e93(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_60(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 168
- DELIM= 31
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_37(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)168U;
  size_t input_rem = input_len % (size_t)168U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_dc lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd2(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)168U;
      size_t output_rem = output_len % (size_t)168U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, (size_t)0U, (size_t)168U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, i0 * (size_t)168U, (size_t)168U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_dc lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e93(&s, &lvalue, i * (size_t)168U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHAKE128 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_shake128(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_37(data, digest);
}

/**
 SHAKE 128

 Writes `out.len()` bytes.
*/
void libcrux_sha3_shake128_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake128(out, data);
}

/**
 SHAKE 256

 Writes `out.len()` bytes.
*/
void libcrux_sha3_shake256_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake256(out, data);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)3U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(s, out0);
}

/**
 Absorb some data for SHAKE-256 for the last time
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_borrow_slice_u8 data
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_dc lvalue = { .data = { data } };
  libcrux_sha3_generic_keccak_absorb_final_80_bd1(s, &lvalue, (size_t)0U, data.meta);
}

/**
 Create a new SHAKE-256 state object.
*/
KRML_MUSTINLINE Eurydice_arr_7c libcrux_sha3_portable_incremental_shake256_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_71();
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_b2(self, out, (size_t)0U, (size_t)136U);
}

/**
 Squeeze the first SHAKE-256 block
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_first_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(&s[0U], out);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_b2(self, out, start, (size_t)136U);
}

/**
 Squeeze the next SHAKE-256 block
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(s, out, (size_t)0U);
}



================================================
FILE: out/test-libcrux-ml-kem/libcrux_sha3_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_portable_H
#define libcrux_sha3_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_zero_d2(void);

uint64_t
libcrux_sha3_simd_portable__veor5q_u64(
  uint64_t a,
  uint64_t b,
  uint64_t c,
  uint64_t d,
  uint64_t e
);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t
libcrux_sha3_simd_portable_xor5_d2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_76(uint64_t x);

uint64_t libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b);

uint64_t libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, uint64_t b, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, uint64_t b, uint64_t c);

uint64_t libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_xor_d2(uint64_t a, uint64_t b);

#define LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS ((KRML_CLITERAL(Eurydice_arr_22){ .data = { 1ULL, 32898ULL, 9223372036854808714ULL, 9223372039002292224ULL, 32907ULL, 2147483649ULL, 9223372039002292353ULL, 9223372036854808585ULL, 138ULL, 136ULL, 2147516425ULL, 2147483658ULL, 2147516555ULL, 9223372036854775947ULL, 9223372036854808713ULL, 9223372036854808579ULL, 9223372036854808578ULL, 9223372036854775936ULL, 32778ULL, 9223372039002259466ULL, 9223372039002292353ULL, 9223372036854808704ULL, 2147483649ULL, 9223372039002292232ULL } }))

typedef struct size_t_x2_s
{
  size_t fst;
  size_t snd;
}
size_t_x2;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types uint64_t
with const generics
- $1size_t
*/
typedef Eurydice_arr_7c libcrux_sha3_generic_keccak_KeccakState_f3;

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types uint64_t
with const generics
- N= 1
*/
Eurydice_arr_7c libcrux_sha3_generic_keccak_new_80_71(void);

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types uint64_t
with const generics
- N= 1
*/
const uint64_t *libcrux_sha3_traits_get_ij_71(const Eurydice_arr_7c *arr, size_t i, size_t j);

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_traits_set_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j, uint64_t value);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_c6(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_dc(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types uint64_t
with const generics
- N= 1
*/
const
uint64_t
*libcrux_sha3_generic_keccak_index_c2_71(const Eurydice_arr_7c *self, size_t_x2 index);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types uint64_t
with const generics
- N= 1
*/
Eurydice_arr_84 libcrux_sha3_generic_keccak_theta_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types uint64_t
with const generics
- N= 1
*/
void
libcrux_sha3_generic_keccak_set_80_71(Eurydice_arr_7c *self, size_t i, size_t j, uint64_t v);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_02(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_020(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_58(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_63(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_62(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_23(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_37(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_54(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_77(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_25(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_af(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_chi_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_iota_80_71(Eurydice_arr_7c *self, size_t i);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_keccakf1600_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_store_block_c6(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_squeeze_9b_c6(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_a1_c6(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e9(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 72
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_dc(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 512 implementation.
*/
void
libcrux_sha3_portable_sha512(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_b2(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_22(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_22(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd0(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_store_block_b2(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_squeeze_9b_b2(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_a1_b2(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e90(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_22(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 256 implementation.
*/
void
libcrux_sha3_portable_sha256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_220(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_220(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd1(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_220(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHAKE256 implementation.
*/
void
libcrux_sha3_portable_shake256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

typedef libcrux_sha3_generic_keccak_KeccakState_f3 libcrux_sha3_portable_KeccakState;

/**
 Create a new SHAKE-128 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake128_init(void);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_60(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_37(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_37(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd2(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
 Absorb
*/
void
libcrux_sha3_portable_incremental_shake128_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_borrow_slice_u8 data0
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_store_block_60(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_squeeze_9b_60(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze three blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
);

/**
 Squeeze another block
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

#define libcrux_sha3_Algorithm_Sha224 1
#define libcrux_sha3_Algorithm_Sha256 2
#define libcrux_sha3_Algorithm_Sha384 3
#define libcrux_sha3_Algorithm_Sha512 4

typedef uint8_t libcrux_sha3_Algorithm;

#define LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE ((size_t)28U)

#define LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE ((size_t)32U)

#define LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE ((size_t)48U)

#define LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE ((size_t)64U)

/**
 Returns the output size of a digest.
*/
size_t libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_9e(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_3a(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_3a(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd3(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_store_block_9e(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_squeeze_9b_9e(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_a1_9e(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e91(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 144
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_3a(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 224 implementation.
*/
void
libcrux_sha3_portable_sha224(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_53(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_dc0(
  Eurydice_arr_7c *state,
  Eurydice_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc0(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd4(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_store_block_53(
  const Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_squeeze_9b_53(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_a1_53(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e92(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 104
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_dc0(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 384 implementation.
*/
void
libcrux_sha3_portable_sha384(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

/**
 SHA3 224

 Preconditions:
 - `digest.len() == 28`
*/
void
libcrux_sha3_sha224_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload);

/**
 SHA3 224
*/
Eurydice_arr_a2 libcrux_sha3_sha224(Eurydice_borrow_slice_u8 data);

/**
 SHA3 256
*/
void
libcrux_sha3_sha256_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload);

/**
 SHA3 256
*/
Eurydice_arr_ec libcrux_sha3_sha256(Eurydice_borrow_slice_u8 data);

/**
 SHA3 384
*/
void
libcrux_sha3_sha384_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload);

/**
 SHA3 384
*/
Eurydice_arr_65 libcrux_sha3_sha384(Eurydice_borrow_slice_u8 data);

/**
 SHA3 512
*/
void
libcrux_sha3_sha512_ema(Eurydice_mut_borrow_slice_u8 digest, Eurydice_borrow_slice_u8 payload);

/**
 SHA3 512
*/
Eurydice_arr_c7 libcrux_sha3_sha512(Eurydice_borrow_slice_u8 data);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_a1_60(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e93(
  Eurydice_arr_7c *self,
  const Eurydice_arr_dc *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 168
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_37(
  Eurydice_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHAKE128 implementation.
*/
void
libcrux_sha3_portable_shake128(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_borrow_slice_u8 data
);

/**
 SHAKE 128

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake128_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data);

/**
 SHAKE 256

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake256_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_borrow_slice_u8 data);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $168size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_55_s
{
  Eurydice_arr_7c inner;
  Eurydice_arr_88 buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_55;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_55
libcrux_sha3_portable_incremental_Shake128Xof;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $136size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_8d_s
{
  Eurydice_arr_7c inner;
  Eurydice_arr_0b buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_8d;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_8d
libcrux_sha3_portable_incremental_Shake256Xof;

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze five blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

/**
 Absorb some data for SHAKE-256 for the last time
*/
void
libcrux_sha3_portable_incremental_shake256_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_borrow_slice_u8 data
);

/**
 Create a new SHAKE-256 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake256_init(void);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4
with const generics
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(
  const Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze the first SHAKE-256 block
*/
void
libcrux_sha3_portable_incremental_shake256_squeeze_first_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
);

/**
 Squeeze the next SHAKE-256 block
*/
void
libcrux_sha3_portable_incremental_shake256_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_4a_s { Eurydice_arr_7c data[4U]; } Eurydice_arr_4a;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_1b_s { Eurydice_arr_7c data[3U]; } Eurydice_arr_1b;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_e3_s { Eurydice_arr_7c data[2U]; } Eurydice_arr_e3;

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_portable_H_DEFINED
#endif /* libcrux_sha3_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_core_H
#define internal_libcrux_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "../libcrux_core.h"

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_87_tags;

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_87_tags tag;
  size_t f0;
}
core_option_Option_87;

static inline uint64_t core_num__u64__from_le_bytes(Eurydice_array_u8x8 x0);

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1);

static inline Eurydice_array_u8x8 core_num__u64__to_le_bytes(uint64_t x0);

static inline uint32_t core_num__u8__count_ones(uint8_t x0);

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

uint8_t
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs,
  Eurydice_mut_borrow_slice_u8 rhs
);

Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs,
  Eurydice_mut_borrow_slice_u8 rhs,
  uint8_t selector
);

Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs_c,
  Eurydice_mut_borrow_slice_u8 rhs_c,
  Eurydice_mut_borrow_slice_u8 lhs_s,
  Eurydice_mut_borrow_slice_u8 rhs_s
);

#define LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE ((size_t)32U)

/**
 K * BITS_PER_RING_ELEMENT / 8

 [eurydice] Note that we can't use const generics here because that breaks
            C extraction with eurydice.
*/
size_t libcrux_ml_kem_constants_ranked_bytes_per_ring_element(size_t rank);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_declassify_d8_39(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint8_t libcrux_secrets_int_as_u8_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_classify_27_39(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u8}
*/
int16_t libcrux_secrets_int_as_i16_59(uint8_t self);

int16_t libcrux_secrets_int_I16(int16_t v);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int32_t libcrux_secrets_int_as_i32_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i32}
*/
int16_t libcrux_secrets_int_as_i16_36(int32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int32_t libcrux_secrets_int_as_i32_b8(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint16_t libcrux_secrets_int_as_u16_f5(int16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
int16_t libcrux_secrets_int_as_i16_ca(uint16_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
uint64_t libcrux_secrets_int_as_u64_ca(uint16_t self);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint32_t

*/
uint32_t libcrux_secrets_int_public_integers_classify_27_df(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u64}
*/
uint32_t libcrux_secrets_int_as_u32_a3(uint64_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int16_t libcrux_secrets_int_as_i16_b8(uint32_t self);

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int16_t libcrux_secrets_int_as_i16_f5(int16_t self);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_default_d3_0e(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_212(Eurydice_arr_d1 *a, size_t r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_51_d9(Eurydice_arr_d1 value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_types_from_17_70(Eurydice_arr_a8 sk, Eurydice_arr_d1 pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_from_b2_0e(Eurydice_arr_a8 value);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d422(Eurydice_arr_a8 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1536size_t
*/
typedef struct Eurydice_arr_df_s { uint8_t data[1536U]; } Eurydice_arr_df;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2f(Eurydice_arr_df *a);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_19_d9(Eurydice_arr_d1 value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_e6_d9(Eurydice_arr_d1 *self);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_a9_d9(Eurydice_arr_d1 *self);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $352size_t
*/
typedef struct Eurydice_arr_e7_s { uint8_t data[352U]; } Eurydice_arr_e7;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d421(Eurydice_arr_e7 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_25(Eurydice_arr_e7 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $128size_t
*/
typedef struct Eurydice_arr_89_s { uint8_t data[128U]; } Eurydice_arr_89;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_3b0_s { Eurydice_arr_89 data[4U]; } Eurydice_arr_3b0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $33size_t
*/
typedef struct Eurydice_arr_fa_s { uint8_t data[33U]; } Eurydice_arr_fa;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_890_s { Eurydice_arr_fa data[4U]; } Eurydice_arr_890;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 4
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_23(Eurydice_arr_890 *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $272size_t
*/
typedef struct Eurydice_arr_5b_s { int16_t data[272U]; } Eurydice_arr_5b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_24_s { Eurydice_arr_5b data[4U]; } Eurydice_arr_24;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cc_s { size_t data[4U]; } Eurydice_arr_cc;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $504size_t
*/
typedef struct Eurydice_arr_79_s { uint8_t data[504U]; } Eurydice_arr_79;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_7c0_s { Eurydice_arr_79 data[4U]; } Eurydice_arr_7c0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $34size_t
*/
typedef struct Eurydice_arr_31_s { uint8_t data[34U]; } Eurydice_arr_31;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_56_s { Eurydice_arr_31 data[4U]; } Eurydice_arr_56;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1600size_t
*/
typedef struct Eurydice_arr_14_s { uint8_t data[1600U]; } Eurydice_arr_14;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_720(Eurydice_arr_14 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_b50(Eurydice_arr_d1 *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1568
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_d9(Eurydice_arr_d1 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f6(Eurydice_arr_14 *a, size_t r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1600
*/
Eurydice_arr_14 libcrux_ml_kem_utils_into_padded_array_49(Eurydice_mut_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f5(Eurydice_arr_d1 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d419(Eurydice_arr_d1 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_68(Eurydice_arr_a8 *a);

typedef struct Eurydice_mut_borrow_slice_u8_x4_s
{
  Eurydice_mut_borrow_slice_u8 fst;
  Eurydice_mut_borrow_slice_u8 snd;
  Eurydice_mut_borrow_slice_u8 thd;
  Eurydice_mut_borrow_slice_u8 f3;
}
Eurydice_mut_borrow_slice_u8_x4;

typedef struct Eurydice_mut_borrow_slice_u8_x2_s
{
  Eurydice_mut_borrow_slice_u8 fst;
  Eurydice_mut_borrow_slice_u8 snd;
}
Eurydice_mut_borrow_slice_u8_x2;

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_mut_borrow_slice_u8 private_key);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_default_d3_79(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_211(Eurydice_arr_5f *a, size_t r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f libcrux_ml_kem_types_from_51_3d(Eurydice_arr_5f value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_types_from_17_bc(Eurydice_arr_7d sk, Eurydice_arr_5f pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_from_b2_79(Eurydice_arr_7d value);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d418(Eurydice_arr_7d *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1152size_t
*/
typedef struct Eurydice_arr_0e_s { uint8_t data[1152U]; } Eurydice_arr_0e;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f4(Eurydice_arr_0e *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f4(Eurydice_arr_5f *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d417(Eurydice_arr_5f *a, core_ops_range_Range_87 r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b libcrux_ml_kem_types_from_19_52(Eurydice_arr_2b value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f *libcrux_ml_kem_types_as_slice_e6_3d(Eurydice_arr_5f *self);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ff(Eurydice_arr_5f *a);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b *libcrux_ml_kem_types_as_slice_a9_52(Eurydice_arr_2b *self);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_58_s { Eurydice_arr_89 data[3U]; } Eurydice_arr_58;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_801_s { Eurydice_arr_fa data[3U]; } Eurydice_arr_801;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 3
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_78(Eurydice_arr_801 *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_2c_s { Eurydice_arr_c5 data[3U]; } Eurydice_arr_2c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_b1_s { Eurydice_arr_5b data[3U]; } Eurydice_arr_b1;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_eb0_s { size_t data[3U]; } Eurydice_arr_eb0;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_7e_s { Eurydice_arr_79 data[3U]; } Eurydice_arr_7e;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_81_s { Eurydice_arr_31 data[3U]; } Eurydice_arr_81;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1120size_t
*/
typedef struct Eurydice_arr_af_s { uint8_t data[1120U]; } Eurydice_arr_af;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_81(Eurydice_arr_af *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_06(Eurydice_arr_2b *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1088
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_52(Eurydice_arr_2b *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f3(Eurydice_arr_af *a, size_t r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1120
*/
Eurydice_arr_af libcrux_ml_kem_utils_into_padded_array_66(Eurydice_mut_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f2(Eurydice_arr_2b *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d415(Eurydice_arr_2b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_51(Eurydice_arr_7d *a);

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_64(Eurydice_mut_borrow_slice_u8 private_key);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d44(Eurydice_arr_ec *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 32
*/
Eurydice_arr_ec libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_mut_borrow_slice_u8 slice);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_default_d3_be(void);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_210(Eurydice_arr_03 *a, size_t r);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 800
*/
Eurydice_arr_03 libcrux_ml_kem_types_from_51_df(Eurydice_arr_03 value);

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_types_from_17_d6(Eurydice_arr_ab0 sk, Eurydice_arr_03 pk);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_from_b2_be(Eurydice_arr_ab0 value);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d414(Eurydice_arr_ab0 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 24
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ed(Eurydice_arr_94 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $384size_t
*/
typedef struct Eurydice_arr_b20_s { uint8_t data[384U]; } Eurydice_arr_b20;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d413(Eurydice_arr_b20 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_a9(Eurydice_arr_b20 *a);

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_07_tags;

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_ec, core_array_TryFromSliceError

*/
typedef struct core_result_Result_07_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_ec case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_07;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$32size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_ec core_result_unwrap_26_39(core_result_Result_07 self);

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 libcrux_ml_kem_types_from_19_80(Eurydice_arr_d2 value);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 800
*/
Eurydice_arr_03 *libcrux_ml_kem_types_as_slice_e6_df(Eurydice_arr_03 *self);

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 *libcrux_ml_kem_types_as_slice_a9_80(Eurydice_arr_d2 *self);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 10
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_30(Eurydice_arr_6d *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 22
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_98(Eurydice_arr_80 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 20
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_8f(Eurydice_arr_fc *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $320size_t
*/
typedef struct Eurydice_arr_b0_s { uint8_t data[320U]; } Eurydice_arr_b0;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d412(Eurydice_arr_b0 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_56(Eurydice_arr_b0 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_89
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_f3_s { Eurydice_arr_89 data[2U]; } Eurydice_arr_f3;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_78(Eurydice_arr_89 *a);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_04_s { int16_t data[256U]; } Eurydice_arr_04;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 256
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_990(Eurydice_arr_04 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $192size_t
*/
typedef struct Eurydice_arr_1c_s { uint8_t data[192U]; } Eurydice_arr_1c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_1c
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_eb_s { Eurydice_arr_1c data[2U]; } Eurydice_arr_eb;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 192
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d9(Eurydice_arr_1c *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_b5(Eurydice_arr_fa *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_fa
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_4d_s { Eurydice_arr_fa data[2U]; } Eurydice_arr_4d;

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 2
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_af(Eurydice_arr_4d *prf_inputs, uint8_t domain_separator);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d411(Eurydice_arr_fa *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 33
*/
Eurydice_arr_fa libcrux_ml_kem_utils_into_padded_array_29(Eurydice_mut_borrow_slice_u8 slice);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 34
*/
Eurydice_arr_31 libcrux_ml_kem_utils_into_padded_array_de(Eurydice_mut_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_5b0_s { Eurydice_arr_c5 data[2U]; } Eurydice_arr_5b0;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5b
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_800_s { Eurydice_arr_5b data[2U]; } Eurydice_arr_800;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_85_s { size_t data[2U]; } Eurydice_arr_85;

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e70(Eurydice_arr_5b *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d49(Eurydice_arr_79 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_79
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_b8_s { Eurydice_arr_79 data[2U]; } Eurydice_arr_b8;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_48(Eurydice_arr_79 *a);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_31
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_bf_s { Eurydice_arr_31 data[2U]; } Eurydice_arr_bf;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 34
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e9(Eurydice_arr_31 *a);

/**
A monomorphic instance of Eurydice.slice_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_from_mut_6d(Eurydice_mut_borrow_slice_u8 s, size_t r);

/**
A monomorphic instance of Eurydice.slice_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_to_mut_72(Eurydice_mut_borrow_slice_u8 s, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_3b(Eurydice_arr_03 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_27(Eurydice_arr_d2 *a);

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 768
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_80(Eurydice_arr_d2 *self);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f1(Eurydice_arr_03 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d48(Eurydice_arr_03 *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 800
*/
Eurydice_arr_03 libcrux_ml_kem_utils_into_padded_array_df(Eurydice_mut_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f0(Eurydice_arr_c7 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d47(Eurydice_arr_c7 *a, core_ops_range_Range_87 r);

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 64
*/
Eurydice_arr_c7 libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_mut_borrow_slice_u8 slice);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_82(Eurydice_array_u8x2 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f(Eurydice_arr_d2 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d46(Eurydice_arr_d2 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_99(Eurydice_arr_ab0 *a);

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_mut_borrow_slice_u8 private_key);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_94, core_array_TryFromSliceError

*/
typedef struct core_result_Result_57_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_94 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_57;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$24size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_94 core_result_unwrap_26_78(core_result_Result_57 self);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_fc, core_array_TryFromSliceError

*/
typedef struct core_result_Result_83_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_fc case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_83;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$20size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_fc core_result_unwrap_26_7d(core_result_Result_83 self);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_6d, core_array_TryFromSliceError

*/
typedef struct core_result_Result_80_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_6d case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_80;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$10size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_6d core_result_unwrap_26_63(core_result_Result_80 self);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d45(Eurydice_arr_b2 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_29(Eurydice_arr_b2 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_8a(Eurydice_arr_d6 *a);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$24size_t]]

*/
Eurydice_arr_94 libcrux_secrets_int_public_integers_declassify_d8_40(Eurydice_arr_94 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$20size_t]]

*/
Eurydice_arr_fc libcrux_secrets_int_public_integers_declassify_d8_2b(Eurydice_arr_fc self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$10size_t]]

*/
Eurydice_arr_6d libcrux_secrets_int_public_integers_declassify_d8_37(Eurydice_arr_6d self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$8size_t]]

*/
Eurydice_array_u8x8
libcrux_secrets_int_public_integers_declassify_d8_52(Eurydice_array_u8x8 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$2size_t]]

*/
Eurydice_array_u8x2
libcrux_secrets_int_public_integers_declassify_d8_75(Eurydice_array_u8x2 self);

/**
 Classify a mutable slice (identity)
 We define a separate function for this because hax has limited support for &mut-returning functions
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_mut_slice
with types Eurydice_dst_ref_mut uint8_t size_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_public_integers_classify_mut_slice_75(Eurydice_mut_borrow_slice_u8 x);

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_classify_27_4b(Eurydice_arr_d6 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_declassify_d8_4b(Eurydice_arr_d6 self);

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types uint8_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_classify_public_classify_ref_6d_90(Eurydice_mut_borrow_slice_u8 self);

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$22size_t]]

*/
Eurydice_arr_80 libcrux_secrets_int_public_integers_declassify_d8_0b(Eurydice_arr_80 self);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e7(Eurydice_arr_d6 *a, core_ops_range_Range_87 r);

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types int16_t

*/
Eurydice_mut_borrow_slice_i16
libcrux_secrets_int_classify_public_classify_ref_6d_39(Eurydice_mut_borrow_slice_i16 self);

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_mut_borrow_slice_i16
Eurydice_slice_subslice_mut_a6(Eurydice_mut_borrow_slice_i16 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of core.result.Result
with types Eurydice_arr_d6, core_array_TryFromSliceError

*/
typedef struct core_result_Result_ec_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_arr_d6 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_ec;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr int16_t[[$16size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_d6 core_result_unwrap_26_d3(core_result_Result_ec self);

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $128size_t
*/
typedef struct Eurydice_arr_34_s { int16_t data[128U]; } Eurydice_arr_34;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_9c_s { Eurydice_arr_c5 data[4U]; } Eurydice_arr_9c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ff
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_dc_s { Eurydice_arr_ff data[4U]; } Eurydice_arr_dc;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_mut_borrow_slice_u8
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_0b0_s { Eurydice_mut_borrow_slice_u8 data[4U]; } Eurydice_arr_0b0;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_17(Eurydice_arr_c7 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_9f(Eurydice_arr_65 *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_01(Eurydice_arr_ec *a);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5e(Eurydice_arr_a2 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $104size_t
*/
typedef struct Eurydice_arr_c4_s { uint8_t data[104U]; } Eurydice_arr_c4;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_72(Eurydice_arr_c4 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d43(Eurydice_arr_c4 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $144size_t
*/
typedef struct Eurydice_arr_f4_s { uint8_t data[144U]; } Eurydice_arr_f4;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_38(Eurydice_arr_f4 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d42(Eurydice_arr_f4 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2c(Eurydice_arr_c5 *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d41(Eurydice_arr_c5 *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_58(Eurydice_arr_ff *a);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d40(Eurydice_arr_ff *a, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_21(Eurydice_array_u8x8 *a, size_t r);

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 8
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_6e(Eurydice_array_u8x8 *a);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $72size_t
*/
typedef struct Eurydice_arr_ab_s { uint8_t data[72U]; } Eurydice_arr_ab;

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e2(Eurydice_arr_ab *a);

/**
A monomorphic instance of core.result.Result
with types Eurydice_array_u8x8, core_array_TryFromSliceError

*/
typedef struct core_result_Result_8e_s
{
  core_result_Result_07_tags tag;
  union {
    Eurydice_array_u8x8 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_8e;

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_e0(core_result_Result_8e self);

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_c8(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_87 r);

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d4(Eurydice_arr_ab *a, core_ops_range_Range_87 r);

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair768_s
{
  Eurydice_arr_0e fst;
  Eurydice_arr_5f snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair768;

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair512_s
{
  Eurydice_arr_d2 fst;
  Eurydice_arr_03 snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair512;

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair1024_s
{
  Eurydice_arr_df fst;
  Eurydice_arr_d1 snd;
}
libcrux_ml_kem_utils_extraction_helper_Keypair1024;

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_core_H_DEFINED
#endif /* internal_libcrux_core_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem1024_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem1024_avx2_H
#define internal_libcrux_mlkem1024_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem1024_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_d1 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem1024_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem1024_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem1024_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem1024_portable_H
#define internal_libcrux_mlkem1024_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem1024_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_d1 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_unpacked_public_key(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem1024_portable_H_DEFINED
#endif /* internal_libcrux_mlkem1024_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem512_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem512_avx2_H
#define internal_libcrux_mlkem512_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem512_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_03 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem512_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem512_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem512_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem512_portable_H
#define internal_libcrux_mlkem512_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem512_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_03 *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_unpacked_public_key(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem512_portable_H_DEFINED
#endif /* internal_libcrux_mlkem512_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem768_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem768_avx2_H
#define internal_libcrux_mlkem768_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_avx2.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem768_avx2.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_public_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *pk
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem768_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem768_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem768_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem768_portable_H
#define internal_libcrux_mlkem768_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem768_portable.h"

typedef libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768PublicKeyUnpacked;

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_init_key_pair(void);

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_init_public_key(void);

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_public_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *pk
);

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_5f *serialized
);

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_unpacked_public_key(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem768_portable_H_DEFINED
#endif /* internal_libcrux_mlkem768_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem_avx2_H
#define internal_libcrux_mlkem_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"
#include "../libcrux_mlkem_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_13_s { __m256i data[16U]; } Eurydice_arr_13;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_60_s { Eurydice_arr_13 data[3U]; } Eurydice_arr_60;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_60
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_ea_s { Eurydice_arr_60 data[3U]; } Eurydice_arr_ea;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef_s
{
  Eurydice_arr_60 t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_ea A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef_s
{
  Eurydice_arr_60 ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef;

typedef struct libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef public_key;
}
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_default_30_e3(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_e3(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_79(Eurydice_arr_5f *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_a4(Eurydice_arr_7d *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d50(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db1(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_a11(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_661(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_3b_s { Eurydice_arr_13 data[4U]; } Eurydice_arr_3b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_3b
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_cd_s { Eurydice_arr_3b data[4U]; } Eurydice_arr_cd;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4_s
{
  Eurydice_arr_3b t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_cd A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4_s
{
  Eurydice_arr_3b ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4;

typedef struct libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 public_key;
}
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_ind_cca_unpacked_default_30_5b(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_5b(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_74(Eurydice_arr_d1 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_f8(Eurydice_arr_a8 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_b3(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db0(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_a10(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_660(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_f6
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_ee_s { Eurydice_arr_13 data[2U]; } Eurydice_arr_ee;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ee
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_e2_s { Eurydice_arr_ee data[2U]; } Eurydice_arr_e2;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7_s
{
  Eurydice_arr_ee t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_e2 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7;

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7_s
{
  Eurydice_arr_ee ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7;

typedef struct libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 public_key;
}
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_ind_cca_unpacked_default_30_16(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_16(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_ce(Eurydice_arr_03 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_37(Eurydice_arr_ab0 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_85(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_db(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_a1(Eurydice_arr_03 *public_key, Eurydice_arr_ec *randomness);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_66(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem_avx2_H_DEFINED
#endif /* internal_libcrux_mlkem_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_mlkem_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_mlkem_portable_H
#define internal_libcrux_mlkem_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "internal/libcrux_core.h"
#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "../libcrux_mlkem_portable.h"

int16_t libcrux_ml_kem_polynomial_zeta(size_t i);

#define LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT ((size_t)16U)

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_9e_s { Eurydice_arr_d6 data[16U]; } Eurydice_arr_9e;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_d20_s { Eurydice_arr_9e data[4U]; } Eurydice_arr_d20;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_d20
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_600_s { Eurydice_arr_d20 data[4U]; } Eurydice_arr_600;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94_s
{
  Eurydice_arr_d20 t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_600 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 4
*/
Eurydice_arr_4a
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(Eurydice_arr_56 *input);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 4
*/
Eurydice_arr_7c0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(
  Eurydice_arr_4a *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 4
*/
Eurydice_arr_9c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(Eurydice_arr_4a *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $4size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94_s
{
  Eurydice_arr_d20 ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94;

typedef struct libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 public_key;
}
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_ind_cca_unpacked_default_30_ee(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_ee(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_1c(Eurydice_arr_d1 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_4c(Eurydice_arr_a8 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_79(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b81(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_991(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd1(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_1e_s { Eurydice_arr_9e data[2U]; } Eurydice_arr_1e;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_1e
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_df0_s { Eurydice_arr_1e data[2U]; } Eurydice_arr_df0;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b_s
{
  Eurydice_arr_1e t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_df0 A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 2
*/
Eurydice_arr_e3
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(Eurydice_arr_bf *input);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 2
*/
Eurydice_arr_b8
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(
  Eurydice_arr_e3 *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 2
*/
Eurydice_arr_5b0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(Eurydice_arr_e3 *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $2size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b_s
{
  Eurydice_arr_1e ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b;

typedef struct libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b public_key;
}
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_ind_cca_unpacked_default_30_66(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_66(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_53(Eurydice_arr_03 *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_e2(Eurydice_arr_ab0 *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d5(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_b80(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_990(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec *randomness
);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd0(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_ml_kem_polynomial_PolynomialRingElement_1d
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_bb_s { Eurydice_arr_9e data[3U]; } Eurydice_arr_bb;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_bb
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_1d_s { Eurydice_arr_bb data[3U]; } Eurydice_arr_1d;

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.IndCpaPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51_s
{
  Eurydice_arr_bb t_as_ntt;
  Eurydice_arr_ec seed_for_A;
  Eurydice_arr_1d A;
}
libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51;

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPublicKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51_s
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 ind_cpa_public_key;
  Eurydice_arr_ec public_key_hash;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51;

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 3
*/
Eurydice_arr_1b
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(Eurydice_arr_81 *input);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 3
*/
Eurydice_arr_7e
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(
  Eurydice_arr_1b *self
);

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 3
*/
Eurydice_arr_2c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(Eurydice_arr_1b *self);

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.MlKemPrivateKeyUnpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- $3size_t
*/
typedef struct libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51_s
{
  Eurydice_arr_bb ind_cpa_private_key;
  Eurydice_arr_ec implicit_rejection_value;
}
libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51;

typedef struct libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked_s
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51 private_key;
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 public_key;
}
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked;

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
);

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
);

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
);

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_default_30_68(void);

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_68(void);

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec *randomness
);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
);

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_b6(Eurydice_arr_5f *public_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_52(Eurydice_arr_7d *private_key);

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_ba(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *_ciphertext
);

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b8(Eurydice_arr_c7 *randomness);

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_99(Eurydice_arr_5f *public_key, Eurydice_arr_ec *randomness);

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_mlkem_portable_H_DEFINED
#endif /* internal_libcrux_mlkem_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/internal/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_libcrux_sha3_internal_H
#define internal_libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"
#include "../libcrux_sha3_internal.h"

typedef Eurydice_arr_60 libcrux_sha3_Sha3_256Digest;

#if defined(__cplusplus)
}
#endif

#define internal_libcrux_sha3_internal_H_DEFINED
#endif /* internal_libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_core.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_core.h"

/**
 Return 1 if `value` is not zero and 0 otherwise.
*/
static KRML_NOINLINE uint8_t inz(uint8_t value)
{
  uint16_t value0 = (uint16_t)value;
  uint8_t result = (uint8_t)((uint32_t)core_num__u16__wrapping_add(~value0, 1U) >> 8U);
  return (uint32_t)result & 1U;
}

static KRML_NOINLINE uint8_t is_non_zero(uint8_t value)
{
  return inz(value);
}

/**
 Return 1 if the bytes of `lhs` and `rhs` do not exactly
 match and 0 otherwise.
*/
static KRML_NOINLINE uint8_t
compare(Eurydice_mut_borrow_slice_u8 lhs, Eurydice_mut_borrow_slice_u8 rhs)
{
  uint8_t r = 0U;
  for (size_t i = (size_t)0U; i < lhs.meta; i++)
  {
    size_t i0 = i;
    uint8_t nr = (uint32_t)r | ((uint32_t)lhs.ptr[i0] ^ (uint32_t)rhs.ptr[i0]);
    r = nr;
  }
  return is_non_zero(r);
}

KRML_NOINLINE uint8_t
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs,
  Eurydice_mut_borrow_slice_u8 rhs
)
{
  return compare(lhs, rhs);
}

/**
 If `selector` is not zero, return the bytes in `rhs`; return the bytes in
 `lhs` otherwise.
*/
static KRML_NOINLINE Eurydice_arr_ec
select_ct(Eurydice_mut_borrow_slice_u8 lhs, Eurydice_mut_borrow_slice_u8 rhs, uint8_t selector)
{
  uint8_t mask = core_num__u8__wrapping_sub(is_non_zero(selector), 1U);
  Eurydice_arr_ec out = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE; i++)
  {
    size_t i0 = i;
    uint8_t
    outi =
      ((uint32_t)lhs.ptr[i0] & (uint32_t)mask) | ((uint32_t)rhs.ptr[i0] & (~(uint32_t)mask & 0xFFU));
    out.data[i0] = outi;
  }
  return out;
}

KRML_NOINLINE Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs,
  Eurydice_mut_borrow_slice_u8 rhs,
  uint8_t selector
)
{
  return select_ct(lhs, rhs, selector);
}

KRML_NOINLINE Eurydice_arr_ec
libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(
  Eurydice_mut_borrow_slice_u8 lhs_c,
  Eurydice_mut_borrow_slice_u8 rhs_c,
  Eurydice_mut_borrow_slice_u8 lhs_s,
  Eurydice_mut_borrow_slice_u8 rhs_s
)
{
  uint8_t
  selector = libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(lhs_c, rhs_c);
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(lhs_s,
      rhs_s,
      selector);
}

/**
 K * BITS_PER_RING_ELEMENT / 8

 [eurydice] Note that we can't use const generics here because that breaks
            C extraction with eurydice.
*/
size_t libcrux_ml_kem_constants_ranked_bytes_per_ring_element(size_t rank)
{
  return rank * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U;
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint8_t

*/
static KRML_MUSTINLINE uint8_t classify_27_90(uint8_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_declassify_d8_39(int16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint8_t libcrux_secrets_int_as_u8_f5(int16_t self)
{
  return classify_27_90((uint8_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int16_t

*/
int16_t libcrux_secrets_int_public_integers_classify_27_39(int16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint8_t

*/
static KRML_MUSTINLINE uint8_t declassify_d8_90(uint8_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u8}
*/
int16_t libcrux_secrets_int_as_i16_59(uint8_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_90(self));
}

/**
 Construct a public integer (identity)
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.secret
with types int16_t

*/
static KRML_MUSTINLINE int16_t secret_39(int16_t x)
{
  return x;
}

int16_t libcrux_secrets_int_I16(int16_t v)
{
  return secret_39(v);
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types int32_t

*/
static KRML_MUSTINLINE int32_t classify_27_a8(int32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int32_t libcrux_secrets_int_as_i32_f5(int16_t self)
{
  return classify_27_a8((int32_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types int32_t

*/
static KRML_MUSTINLINE int32_t declassify_d8_a8(int32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i32}
*/
int16_t libcrux_secrets_int_as_i16_36(int32_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_a8(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint32_t

*/
static KRML_MUSTINLINE uint32_t declassify_d8_df(uint32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int32_t libcrux_secrets_int_as_i32_b8(uint32_t self)
{
  return classify_27_a8((int32_t)declassify_d8_df(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint16_t

*/
static KRML_MUSTINLINE uint16_t classify_27_de(uint16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
uint16_t libcrux_secrets_int_as_u16_f5(int16_t self)
{
  return classify_27_de((uint16_t)libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint16_t

*/
static KRML_MUSTINLINE uint16_t declassify_d8_de(uint16_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
int16_t libcrux_secrets_int_as_i16_ca(uint16_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_de(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint64_t

*/
static KRML_MUSTINLINE uint64_t classify_27_49(uint64_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u16}
*/
uint64_t libcrux_secrets_int_as_u64_ca(uint16_t self)
{
  return classify_27_49((uint64_t)declassify_d8_de(self));
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types uint32_t

*/
uint32_t libcrux_secrets_int_public_integers_classify_27_df(uint32_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types uint64_t

*/
static KRML_MUSTINLINE uint64_t declassify_d8_49(uint64_t self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u64}
*/
uint32_t libcrux_secrets_int_as_u32_a3(uint64_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_df((uint32_t)declassify_d8_49(self));
}

/**
This function found in impl {libcrux_secrets::int::CastOps for u32}
*/
int16_t libcrux_secrets_int_as_i16_b8(uint32_t self)
{
  return libcrux_secrets_int_public_integers_classify_27_39((int16_t)declassify_d8_df(self));
}

/**
This function found in impl {libcrux_secrets::int::CastOps for i16}
*/
int16_t libcrux_secrets_int_as_i16_f5(int16_t self)
{
  return
    libcrux_secrets_int_public_integers_classify_27_39(libcrux_secrets_int_public_integers_declassify_d8_39(self));
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_default_d3_0e(void)
{
  return (KRML_CLITERAL(Eurydice_arr_a8){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_212(Eurydice_arr_d1 *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_51_d9(Eurydice_arr_d1 value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_types_from_17_70(Eurydice_arr_a8 sk, Eurydice_arr_d1 pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_mlkem1024_MlKem1024KeyPair){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 3168
*/
Eurydice_arr_a8 libcrux_ml_kem_types_from_b2_0e(Eurydice_arr_a8 value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d422(Eurydice_arr_a8 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1536
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2f(Eurydice_arr_df *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1536U;
  return lit;
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 libcrux_ml_kem_types_from_19_d9(Eurydice_arr_d1 value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_e6_d9(Eurydice_arr_d1 *self)
{
  return self;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1568
*/
Eurydice_arr_d1 *libcrux_ml_kem_types_as_slice_a9_d9(Eurydice_arr_d1 *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d421(Eurydice_arr_e7 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 352
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_25(Eurydice_arr_e7 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)352U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 4
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_23(Eurydice_arr_890 *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_720(Eurydice_arr_14 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1600U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_b50(Eurydice_arr_d1 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1568U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1568
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_d9(Eurydice_arr_d1 *self)
{
  return Eurydice_array_to_slice_mut_b50(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f6(Eurydice_arr_14 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1600U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1600
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d420(Eurydice_arr_14 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1600
*/
Eurydice_arr_14 libcrux_ml_kem_utils_into_padded_array_49(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_14 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d420(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f5(Eurydice_arr_d1 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1568U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1568
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d419(Eurydice_arr_d1 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 3168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_68(Eurydice_arr_a8 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)3168U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_mut_borrow_slice_u8 private_key)
{
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)1536U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)1568U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_default_d3_79(void)
{
  return (KRML_CLITERAL(Eurydice_arr_7d){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_211(Eurydice_arr_5f *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f libcrux_ml_kem_types_from_51_3d(Eurydice_arr_5f value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_types_from_17_bc(Eurydice_arr_7d sk, Eurydice_arr_5f pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_mlkem768_MlKem768KeyPair){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 2400
*/
Eurydice_arr_7d libcrux_ml_kem_types_from_b2_79(Eurydice_arr_7d value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d418(Eurydice_arr_7d *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1152
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_f4(Eurydice_arr_0e *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1152U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f4(Eurydice_arr_5f *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1184U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d417(Eurydice_arr_5f *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b libcrux_ml_kem_types_from_19_52(Eurydice_arr_2b value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 1184
*/
Eurydice_arr_5f *libcrux_ml_kem_types_as_slice_e6_3d(Eurydice_arr_5f *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1184
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ff(Eurydice_arr_5f *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1184U;
  return lit;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 1088
*/
Eurydice_arr_2b *libcrux_ml_kem_types_as_slice_a9_52(Eurydice_arr_2b *self)
{
  return self;
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 3
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_78(Eurydice_arr_801 *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_81(Eurydice_arr_af *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1120U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_06(Eurydice_arr_2b *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1088U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 1088
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_52(Eurydice_arr_2b *self)
{
  return Eurydice_array_to_slice_mut_06(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f3(Eurydice_arr_af *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1120U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1120
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d416(Eurydice_arr_af *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 1120
*/
Eurydice_arr_af libcrux_ml_kem_utils_into_padded_array_66(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_af out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d416(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f2(Eurydice_arr_2b *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)1088U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1088
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d415(Eurydice_arr_2b *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2400
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_51(Eurydice_arr_7d *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2400U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_64(Eurydice_mut_borrow_slice_u8 private_key)
{
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)1152U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)1184U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d44(Eurydice_arr_ec *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 32
*/
Eurydice_arr_ec libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.default_d3
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_default_d3_be(void)
{
  return (KRML_CLITERAL(Eurydice_arr_ab0){ .data = { 0U } });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_210(Eurydice_arr_03 *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_51
with const generics
- SIZE= 800
*/
Eurydice_arr_03 libcrux_ml_kem_types_from_51_df(Eurydice_arr_03 value)
{
  return value;
}

/**
 Create a new [`MlKemKeyPair`] from the secret and public key.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemKeyPair<PRIVATE_KEY_SIZE, PUBLIC_KEY_SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_17
with const generics
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_types_from_17_d6(Eurydice_arr_ab0 sk, Eurydice_arr_03 pk)
{
  return (KRML_CLITERAL(libcrux_ml_kem_types_MlKemKeyPair_0d){ .sk = sk, .pk = pk });
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemPrivateKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_b2
with const generics
- SIZE= 1632
*/
Eurydice_arr_ab0 libcrux_ml_kem_types_from_b2_be(Eurydice_arr_ab0 value)
{
  return value;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d414(Eurydice_arr_ab0 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 24
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_ed(Eurydice_arr_94 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)24U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d413(Eurydice_arr_b20 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 384
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_a9(Eurydice_arr_b20 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)384U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$32size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_ec core_result_unwrap_26_39(core_result_Result_07 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
This function found in impl {core::convert::From<[u8; SIZE]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.from_19
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 libcrux_ml_kem_types_from_19_80(Eurydice_arr_d2 value)
{
  return value;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemPublicKey<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_e6
with const generics
- SIZE= 800
*/
Eurydice_arr_03 *libcrux_ml_kem_types_as_slice_e6_df(Eurydice_arr_03 *self)
{
  return self;
}

/**
 A reference to the raw byte slice.
*/
/**
This function found in impl {libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_slice_a9
with const generics
- SIZE= 768
*/
Eurydice_arr_d2 *libcrux_ml_kem_types_as_slice_a9_80(Eurydice_arr_d2 *self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 10
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_30(Eurydice_arr_6d *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)10U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 22
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_98(Eurydice_arr_80 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)22U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 20
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_8f(Eurydice_arr_fc *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)20U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d412(Eurydice_arr_b0 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 320
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_56(Eurydice_arr_b0 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)320U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 128
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_78(Eurydice_arr_89 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)128U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 256
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_990(Eurydice_arr_04 *a)
{
  Eurydice_mut_borrow_slice_i16 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)256U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 192
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_d9(Eurydice_arr_1c *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)192U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_b5(Eurydice_arr_fa *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)33U;
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.utils.prf_input_inc
with const generics
- K= 2
*/
uint8_t
libcrux_ml_kem_utils_prf_input_inc_af(Eurydice_arr_4d *prf_inputs, uint8_t domain_separator)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    prf_inputs->data[i0].data[32U] = domain_separator;
    domain_separator = (uint32_t)domain_separator + 1U;);
  return domain_separator;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 33
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d411(Eurydice_arr_fa *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 33
*/
Eurydice_arr_fa libcrux_ml_kem_utils_into_padded_array_29(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_fa out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 34
*/
static Eurydice_mut_borrow_slice_u8
array_to_subslice_mut_d410(Eurydice_arr_31 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 34
*/
Eurydice_arr_31 libcrux_ml_kem_utils_into_padded_array_de(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_31 out = { .data = { 0U } };
  Eurydice_slice_copy(array_to_subslice_mut_d410(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 272
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e70(Eurydice_arr_5b *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_i16){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d49(Eurydice_arr_79 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 504
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_48(Eurydice_arr_79 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)504U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 34
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e9(Eurydice_arr_31 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)34U;
  return lit;
}

/**
A monomorphic instance of Eurydice.slice_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_from_mut_6d(Eurydice_mut_borrow_slice_u8 s, size_t r)
{
  return (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr + r, .meta = s.meta - r });
}

/**
A monomorphic instance of Eurydice.slice_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_to_mut_72(Eurydice_mut_borrow_slice_u8 s, size_t r)
{
  return (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr, .meta = r });
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_3b(Eurydice_arr_03 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)800U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_27(Eurydice_arr_d2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)768U;
  return lit;
}

/**
This function found in impl {core::convert::AsRef<[u8]> for libcrux_ml_kem::types::MlKemCiphertext<SIZE>}
*/
/**
A monomorphic instance of libcrux_ml_kem.types.as_ref_c1
with const generics
- SIZE= 768
*/
Eurydice_mut_borrow_slice_u8 libcrux_ml_kem_types_as_ref_c1_80(Eurydice_arr_d2 *self)
{
  return Eurydice_array_to_slice_mut_27(self);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f1(Eurydice_arr_03 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)800U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 800
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d48(Eurydice_arr_03 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 800
*/
Eurydice_arr_03 libcrux_ml_kem_utils_into_padded_array_df(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_03 out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d48(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f0(Eurydice_arr_c7 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)64U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d47(Eurydice_arr_c7 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
 Pad the `slice` with `0`s at the end.
*/
/**
A monomorphic instance of libcrux_ml_kem.utils.into_padded_array
with const generics
- LEN= 64
*/
Eurydice_arr_c7 libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_mut_borrow_slice_u8 slice)
{
  Eurydice_arr_c7 out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d47(&out,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = slice.meta })),
    slice,
    uint8_t);
  return out;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 2
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_82(Eurydice_array_u8x2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)2U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_from_mut
with types uint8_t, core_ops_range_RangeFrom size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_from_mut_5f(Eurydice_arr_d2 *a, size_t r)
{
  return
    (KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = a->data + r, .meta = (size_t)768U - r });
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 768
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d46(Eurydice_arr_d2 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 1632
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_99(Eurydice_arr_ab0 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)1632U;
  return lit;
}

/**
 Unpack an incoming private key into it's different parts.

 We have this here in types to extract into a common core for C.
*/
/**
A monomorphic instance of libcrux_ml_kem.types.unpack_private_key
with const generics
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_mut_borrow_slice_u8_x4
libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_mut_borrow_slice_u8 private_key)
{
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(private_key,
      (size_t)768U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 secret_key0 = uu____0.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(secret_key0,
      (size_t)800U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 secret_key = uu____1.snd;
  Eurydice_mut_borrow_slice_u8_x2
  uu____2 =
    Eurydice_slice_split_at(secret_key,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____2.fst;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____2.snd;
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8_x4){
        .fst = ind_cpa_secret_key,
        .snd = ind_cpa_public_key,
        .thd = ind_cpa_public_key_hash,
        .f3 = implicit_rejection_value
      }
    );
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$24size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_94 core_result_unwrap_26_78(core_result_Result_57 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$20size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_fc core_result_unwrap_26_7d(core_result_Result_83 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$10size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_6d core_result_unwrap_26_63(core_result_Result_80 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d45(Eurydice_arr_b2 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_29(Eurydice_arr_b2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16 Eurydice_array_to_slice_mut_8a(Eurydice_arr_d6 *a)
{
  Eurydice_mut_borrow_slice_i16 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)16U;
  return lit;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$24size_t]]

*/
Eurydice_arr_94 libcrux_secrets_int_public_integers_declassify_d8_40(Eurydice_arr_94 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$20size_t]]

*/
Eurydice_arr_fc libcrux_secrets_int_public_integers_declassify_d8_2b(Eurydice_arr_fc self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$10size_t]]

*/
Eurydice_arr_6d libcrux_secrets_int_public_integers_declassify_d8_37(Eurydice_arr_6d self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$8size_t]]

*/
Eurydice_array_u8x8
libcrux_secrets_int_public_integers_declassify_d8_52(Eurydice_array_u8x8 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$2size_t]]

*/
Eurydice_array_u8x2
libcrux_secrets_int_public_integers_declassify_d8_75(Eurydice_array_u8x2 self)
{
  return self;
}

/**
 Classify a mutable slice (identity)
 We define a separate function for this because hax has limited support for &mut-returning functions
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_mut_slice
with types Eurydice_dst_ref_mut uint8_t size_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_public_integers_classify_mut_slice_75(Eurydice_mut_borrow_slice_u8 x)
{
  return x;
}

/**
This function found in impl {libcrux_secrets::traits::Classify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.classify_27
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_classify_27_4b(Eurydice_arr_d6 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr int16_t[[$16size_t]]

*/
Eurydice_arr_d6 libcrux_secrets_int_public_integers_declassify_d8_4b(Eurydice_arr_d6 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types uint8_t

*/
Eurydice_mut_borrow_slice_u8
libcrux_secrets_int_classify_public_classify_ref_6d_90(Eurydice_mut_borrow_slice_u8 self)
{
  return self;
}

/**
This function found in impl {libcrux_secrets::traits::Declassify<T> for T}
*/
/**
A monomorphic instance of libcrux_secrets.int.public_integers.declassify_d8
with types Eurydice_arr uint8_t[[$22size_t]]

*/
Eurydice_arr_80 libcrux_secrets_int_public_integers_declassify_d8_0b(Eurydice_arr_80 self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t
with const generics
- N= 16
*/
Eurydice_mut_borrow_slice_i16
Eurydice_array_to_subslice_mut_e7(Eurydice_arr_d6 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_i16){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
This function found in impl {libcrux_secrets::traits::ClassifyRef<&'a ([T])> for &'a ([T])}
*/
/**
A monomorphic instance of libcrux_secrets.int.classify_public.classify_ref_6d
with types int16_t

*/
Eurydice_mut_borrow_slice_i16
libcrux_secrets_int_classify_public_classify_ref_6d_39(Eurydice_mut_borrow_slice_i16 self)
{
  return self;
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types int16_t, core_ops_range_Range size_t, Eurydice_derefed_slice int16_t

*/
Eurydice_mut_borrow_slice_i16
Eurydice_slice_subslice_mut_a6(Eurydice_mut_borrow_slice_i16 s, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_i16){
        .ptr = s.ptr + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr int16_t[[$16size_t]], core_array_TryFromSliceError

*/
Eurydice_arr_d6 core_result_unwrap_26_d3(core_result_Result_ec self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 64
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_17(Eurydice_arr_c7 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)64U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 48
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_9f(Eurydice_arr_65 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)48U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 32
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_01(Eurydice_arr_ec *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)32U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 28
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_5e(Eurydice_arr_a2 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)28U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_72(Eurydice_arr_c4 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)104U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 104
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d43(Eurydice_arr_c4 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_38(Eurydice_arr_f4 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)144U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 144
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d42(Eurydice_arr_f4 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_2c(Eurydice_arr_c5 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)168U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 168
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d41(Eurydice_arr_c5 *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_58(Eurydice_arr_ff *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)136U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 136
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d40(Eurydice_arr_ff *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_to_mut
with types uint8_t, core_ops_range_RangeTo size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 8
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_to_mut_21(Eurydice_array_u8x8 *a, size_t r)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = r;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 8
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_6e(Eurydice_array_u8x8 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)8U;
  return lit;
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8 Eurydice_array_to_slice_mut_e2(Eurydice_arr_ab *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)72U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$8size_t]], core_array_TryFromSliceError

*/
Eurydice_array_u8x8 core_result_unwrap_26_e0(core_result_Result_8e self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
Eurydice_mut_borrow_slice_u8
Eurydice_slice_subslice_mut_c8(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t
with const generics
- N= 72
*/
Eurydice_mut_borrow_slice_u8
Eurydice_array_to_subslice_mut_d4(Eurydice_arr_ab *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){
        .ptr = a->data + r.start,
        .meta = r.end - r.start
      }
    );
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_core.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_core_H
#define libcrux_core_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE ((size_t)32U)

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $32size_t
*/
typedef struct Eurydice_arr_ec_s { uint8_t data[32U]; } Eurydice_arr_ec;

#define LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT ((size_t)12U)

#define LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT ((size_t)256U)

#define LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)12U)

#define LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE ((size_t)32U)

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $3168size_t
*/
typedef struct Eurydice_arr_a8_s { uint8_t data[3168U]; } Eurydice_arr_a8;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1568size_t
*/
typedef struct Eurydice_arr_d1_s { uint8_t data[1568U]; } Eurydice_arr_d1;

typedef struct libcrux_ml_kem_mlkem1024_MlKem1024KeyPair_s
{
  Eurydice_arr_a8 sk;
  Eurydice_arr_d1 pk;
}
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_mlkem1024_MlKem1024Ciphertext, Eurydice_arr_ec

*/
typedef struct tuple_25_s
{
  Eurydice_arr_d1 fst;
  Eurydice_arr_ec snd;
}
tuple_25;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $2400size_t
*/
typedef struct Eurydice_arr_7d_s { uint8_t data[2400U]; } Eurydice_arr_7d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1184size_t
*/
typedef struct Eurydice_arr_5f_s { uint8_t data[1184U]; } Eurydice_arr_5f;

typedef struct libcrux_ml_kem_mlkem768_MlKem768KeyPair_s
{
  Eurydice_arr_7d sk;
  Eurydice_arr_5f pk;
}
libcrux_ml_kem_mlkem768_MlKem768KeyPair;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1088size_t
*/
typedef struct Eurydice_arr_2b_s { uint8_t data[1088U]; } Eurydice_arr_2b;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_mlkem768_MlKem768Ciphertext, Eurydice_arr_ec

*/
typedef struct tuple_f4_s
{
  Eurydice_arr_2b fst;
  Eurydice_arr_ec snd;
}
tuple_f4;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $168size_t
*/
typedef struct Eurydice_arr_c5_s { uint8_t data[168U]; } Eurydice_arr_c5;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1632size_t
*/
typedef struct Eurydice_arr_ab0_s { uint8_t data[1632U]; } Eurydice_arr_ab0;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $800size_t
*/
typedef struct Eurydice_arr_03_s { uint8_t data[800U]; } Eurydice_arr_03;

/**
A monomorphic instance of libcrux_ml_kem.types.MlKemKeyPair
with const generics
- $1632size_t
- $800size_t
*/
typedef struct libcrux_ml_kem_types_MlKemKeyPair_0d_s
{
  Eurydice_arr_ab0 sk;
  Eurydice_arr_03 pk;
}
libcrux_ml_kem_types_MlKemKeyPair_0d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_94_s { uint8_t data[24U]; } Eurydice_arr_94;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $768size_t
*/
typedef struct Eurydice_arr_d2_s { uint8_t data[768U]; } Eurydice_arr_d2;

/**
A monomorphic instance of n-tuple
with types libcrux_ml_kem_types_MlKemCiphertext_6e, Eurydice_arr_ec

*/
typedef struct tuple_ab_s
{
  Eurydice_arr_d2 fst;
  Eurydice_arr_ec snd;
}
tuple_ab;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $10size_t
*/
typedef struct Eurydice_arr_6d_s { uint8_t data[10U]; } Eurydice_arr_6d;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $22size_t
*/
typedef struct Eurydice_arr_80_s { uint8_t data[22U]; } Eurydice_arr_80;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $20size_t
*/
typedef struct Eurydice_arr_fc_s { uint8_t data[20U]; } Eurydice_arr_fc;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $64size_t
*/
typedef struct Eurydice_arr_c7_s { uint8_t data[64U]; } Eurydice_arr_c7;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_b2_s { uint8_t data[16U]; } Eurydice_arr_b2;

/**
A monomorphic instance of Eurydice.arr
with types int16_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_d6_s { int16_t data[16U]; } Eurydice_arr_d6;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_b2
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_87_s { Eurydice_arr_b2 data[256U]; } Eurydice_arr_87;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $136size_t
*/
typedef struct Eurydice_arr_ff_s { uint8_t data[136U]; } Eurydice_arr_ff;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_ff
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_0b_s { Eurydice_arr_ff data[1U]; } Eurydice_arr_0b;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_c5
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_88_s { Eurydice_arr_c5 data[1U]; } Eurydice_arr_88;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $48size_t
*/
typedef struct Eurydice_arr_65_s { uint8_t data[48U]; } Eurydice_arr_65;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $28size_t
*/
typedef struct Eurydice_arr_a2_s { uint8_t data[28U]; } Eurydice_arr_a2;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $5size_t
*/
typedef struct Eurydice_arr_84_s { uint64_t data[5U]; } Eurydice_arr_84;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_mut_borrow_slice_u8
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_69_s { Eurydice_mut_borrow_slice_u8 data[1U]; } Eurydice_arr_69;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_7c_s { uint64_t data[25U]; } Eurydice_arr_7c;

/**
A monomorphic instance of Eurydice.arr
with types uint64_t
with const generics
- $24size_t
*/
typedef struct Eurydice_arr_22_s { uint64_t data[24U]; } Eurydice_arr_22;

#if defined(__cplusplus)
}
#endif

#define libcrux_core_H_DEFINED
#endif /* libcrux_core_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem1024.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_H
#define libcrux_mlkem1024_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM1024_VECTOR_U_COMPRESSION_FACTOR ((size_t)11U)

#define LIBCRUX_ML_KEM_MLKEM1024_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM1024_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_RANK ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM1024_C1_SIZE (LIBCRUX_ML_KEM_MLKEM1024_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM1024_RANK)

#define LIBCRUX_ML_KEM_MLKEM1024_VECTOR_V_COMPRESSION_FACTOR ((size_t)5U)

#define LIBCRUX_ML_KEM_MLKEM1024_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM1024_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM1024_C1_SIZE + LIBCRUX_ML_KEM_MLKEM1024_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM1024_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA1 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM1024_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM1024_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM1024_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM1024_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_a8 libcrux_ml_kem_mlkem1024_MlKem1024PrivateKey;

typedef Eurydice_arr_d1 libcrux_ml_kem_mlkem1024_MlKem1024PublicKey;

#define LIBCRUX_ML_KEM_MLKEM1024_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM1024_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM1024_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM1024_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_H_DEFINED
#endif /* libcrux_mlkem1024_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem1024_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem1024_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_avx2_85(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_660(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_85(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return decapsulate_avx2_85(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_decapsulate(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25 encapsulate_avx2_07(Eurydice_arr_d1 *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a10(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25 encapsulate_07(Eurydice_arr_d1 *public_key, Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_07(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_encapsulate(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_07(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_avx2_b3(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db0(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_b3(Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_b3(randomness);
}

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b3(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static bool
validate_private_key_avx2_43(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_b3(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static bool validate_private_key_43(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return validate_private_key_avx2_43(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return validate_private_key_43(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
static KRML_MUSTINLINE bool validate_private_key_only_f5(Eurydice_arr_a8 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_f8(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_private_key_only(Eurydice_arr_a8 *private_key)
{
  return validate_private_key_only_f5(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static bool validate_public_key_avx2_f5(Eurydice_arr_d1 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_74(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static bool validate_public_key_f5(Eurydice_arr_d1 *public_key)
{
  return validate_public_key_avx2_f5(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_public_key(Eurydice_arr_d1 *public_key)
{
  return validate_public_key_f5(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_avx2_850(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_850(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_avx2_850(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_850(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_avx2_070(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25
encapsulate_070(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_070(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_070(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_avx2_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  generate_keypair_avx2_b30(randomness, out);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  generate_keypair_b30(randomness, key_pair);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_5b();
  libcrux_ml_kem_mlkem1024_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_5b();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_mlkem1024_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_5b();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
keypair_from_private_key_39(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_39(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static void
unpack_public_key_avx2_43(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static void
unpack_public_key_43(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  unpack_public_key_avx2_43(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  unpack_public_key_43(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem1024_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_avx2_H
#define libcrux_mlkem1024_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_avx2_decapsulate(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_avx2_encapsulate(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_avx2_validate_private_key(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_private_key_only(Eurydice_arr_a8 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_avx2_validate_public_key(Eurydice_arr_d1 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_avx2_H_DEFINED
#endif /* libcrux_mlkem1024_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem1024_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem1024_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static Eurydice_arr_ec
decapsulate_85(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd1(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_decapsulate(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_25 encapsulate_07(Eurydice_arr_d1 *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_991(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_encapsulate(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_07(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
generate_keypair_b3(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b81(randomness);
}

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b3(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE bool
validate_private_key_43(Eurydice_arr_a8 *private_key, Eurydice_arr_d1 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_79(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return validate_private_key_43(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
static KRML_MUSTINLINE bool validate_private_key_only_f5(Eurydice_arr_a8 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_4c(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_private_key_only(Eurydice_arr_a8 *private_key)
{
  return validate_private_key_only_f5(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE bool validate_public_key_f5(Eurydice_arr_d1 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_1c(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_public_key(Eurydice_arr_d1 *public_key)
{
  return validate_public_key_f5(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_850(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 1024 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem1024KeyPairUnpacked`]
 and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  return decapsulate_850(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_25
encapsulate_070(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(public_key, randomness);
}

/**
 Encapsulate ML-KEM 1024 (unpacked)

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem1024PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
 TODO: The F* prefix opens required modules, it should go away when the following issue is resolved:
 <https://github.com/hacspec/hax/issues/770>
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_070(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_b30(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(randomness, out);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  generate_keypair_b30(randomness, key_pair);
}

/**
 Generate ML-KEM 1024 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_ee();
  libcrux_ml_kem_mlkem1024_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_mlkem1024_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_ee();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_mlkem1024_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_ee();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
keypair_from_private_key_39(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_39(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_a8
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_d1
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
unpack_public_key_43(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem1024_portable_unpacked_unpacked_public_key(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  unpack_public_key_43(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem1024_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem1024_portable_H
#define libcrux_mlkem1024_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 1024

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem1024PrivateKey`] and an [`MlKem1024Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem1024_portable_decapsulate(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Encapsulate ML-KEM 1024

 Generates an ([`MlKem1024Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem1024PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_25
libcrux_ml_kem_mlkem1024_portable_encapsulate(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 1024 Key Pair
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_mlkem1024_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem1024_portable_validate_private_key(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_private_key_only(Eurydice_arr_a8 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem1024_portable_validate_public_key(Eurydice_arr_d1 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem1024_portable_H_DEFINED
#endif /* libcrux_mlkem1024_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem512.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_H
#define libcrux_mlkem512_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM512_VECTOR_U_COMPRESSION_FACTOR ((size_t)10U)

#define LIBCRUX_ML_KEM_MLKEM512_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM512_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_RANK ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM512_C1_SIZE (LIBCRUX_ML_KEM_MLKEM512_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM512_RANK)

#define LIBCRUX_ML_KEM_MLKEM512_VECTOR_V_COMPRESSION_FACTOR ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM512_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM512_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM512_C1_SIZE + LIBCRUX_ML_KEM_MLKEM512_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM512_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA1 ((size_t)3U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM512_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM512_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM512_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM512_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_d2 libcrux_ml_kem_mlkem512_MlKem512Ciphertext;

typedef libcrux_ml_kem_types_MlKemKeyPair_0d libcrux_ml_kem_mlkem512_MlKem512KeyPair;

typedef Eurydice_arr_ab0 libcrux_ml_kem_mlkem512_MlKem512PrivateKey;

typedef Eurydice_arr_03 libcrux_ml_kem_mlkem512_MlKem512PublicKey;

#define LIBCRUX_ML_KEM_MLKEM512_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM512_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM512_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM512_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_H_DEFINED
#endif /* libcrux_mlkem512_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem512_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem512_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_avx2_37(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_66(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_37(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return decapsulate_avx2_37(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_decapsulate(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_37(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab encapsulate_avx2_80(Eurydice_arr_03 *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a1(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab encapsulate_80(Eurydice_arr_03 *public_key, Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_80(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_encapsulate(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_80(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d
generate_keypair_avx2_b8(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d generate_keypair_b8(Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_b8(randomness);
}

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b8(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static bool
validate_private_key_avx2_25(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_85(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static bool validate_private_key_25(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return validate_private_key_avx2_25(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return validate_private_key_25(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
static KRML_MUSTINLINE bool validate_private_key_only_d5(Eurydice_arr_ab0 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_37(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_private_key_only(Eurydice_arr_ab0 *private_key)
{
  return validate_private_key_only_d5(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static bool validate_public_key_avx2_d5(Eurydice_arr_03 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_ce(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static bool validate_public_key_d5(Eurydice_arr_03 *public_key)
{
  return validate_public_key_avx2_d5(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_public_key(Eurydice_arr_03 *public_key)
{
  return validate_public_key_d5(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_avx2_370(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_370(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_avx2_370(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_370(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_avx2_800(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab
encapsulate_800(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_800(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_800(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static void
generate_keypair_avx2_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static void
generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  generate_keypair_avx2_b80(randomness, out);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  generate_keypair_b80(randomness, key_pair);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_16();
  libcrux_ml_kem_mlkem512_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_16();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_mlkem512_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_16();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
keypair_from_private_key_c3(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_c3(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static void
unpack_public_key_avx2_25(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static void
unpack_public_key_25(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  unpack_public_key_avx2_25(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  unpack_public_key_25(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem512_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_avx2_H
#define libcrux_mlkem512_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_avx2_decapsulate(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_avx2_encapsulate(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_avx2_validate_private_key(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_private_key_only(Eurydice_arr_ab0 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_avx2_validate_public_key(Eurydice_arr_03 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_avx2_H_DEFINED
#endif /* libcrux_mlkem512_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem512_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem512_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static Eurydice_arr_ec
decapsulate_37(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd0(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_decapsulate(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_37(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_ab encapsulate_80(Eurydice_arr_03 *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_990(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_encapsulate(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_80(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static libcrux_ml_kem_types_MlKemKeyPair_0d generate_keypair_b8(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b80(randomness);
}

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_b8(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE bool
validate_private_key_25(Eurydice_arr_ab0 *private_key, Eurydice_arr_d2 *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_d5(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return validate_private_key_25(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
static KRML_MUSTINLINE bool validate_private_key_only_d5(Eurydice_arr_ab0 *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_e2(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_private_key_only(Eurydice_arr_ab0 *private_key)
{
  return validate_private_key_only_d5(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE bool validate_public_key_d5(Eurydice_arr_03 *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_53(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_public_key(Eurydice_arr_03 *public_key)
{
  return validate_public_key_d5(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_370(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 512 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem512KeyPairUnpacked`]
 and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  return decapsulate_370(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_ab
encapsulate_800(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(public_key, randomness);
}

/**
 Encapsulate ML-KEM 512 (unpacked)

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem512PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_800(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(randomness, out);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  generate_keypair_b80(randomness, key_pair);
}

/**
 Generate ML-KEM 512 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_66();
  libcrux_ml_kem_mlkem512_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_mlkem512_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_66();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_mlkem512_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_66();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
keypair_from_private_key_c3(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_c3(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_ab0
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_03
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
unpack_public_key_25(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem512_portable_unpacked_unpacked_public_key(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  unpack_public_key_25(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem512_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem512_portable_H
#define libcrux_mlkem512_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 512

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem512PrivateKey`] and an [`MlKem512Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem512_portable_decapsulate(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Encapsulate ML-KEM 512

 Generates an ([`MlKem512Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem512PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_ab
libcrux_ml_kem_mlkem512_portable_encapsulate(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 512 Key Pair
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_mlkem512_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem512_portable_validate_private_key(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_private_key_only(Eurydice_arr_ab0 *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem512_portable_validate_public_key(Eurydice_arr_03 *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem512_portable_H_DEFINED
#endif /* libcrux_mlkem512_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem768.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_H
#define libcrux_mlkem768_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

#define LIBCRUX_ML_KEM_MLKEM768_VECTOR_U_COMPRESSION_FACTOR ((size_t)10U)

#define LIBCRUX_ML_KEM_MLKEM768_C1_BLOCK_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM768_VECTOR_U_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_RANK ((size_t)3U)

#define LIBCRUX_ML_KEM_MLKEM768_C1_SIZE (LIBCRUX_ML_KEM_MLKEM768_C1_BLOCK_SIZE * LIBCRUX_ML_KEM_MLKEM768_RANK)

#define LIBCRUX_ML_KEM_MLKEM768_VECTOR_V_COMPRESSION_FACTOR ((size_t)4U)

#define LIBCRUX_ML_KEM_MLKEM768_C2_SIZE (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_MLKEM768_VECTOR_V_COMPRESSION_FACTOR / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE (LIBCRUX_ML_KEM_MLKEM768_C1_SIZE + LIBCRUX_ML_KEM_MLKEM768_C2_SIZE)

#define LIBCRUX_ML_KEM_MLKEM768_T_AS_NTT_ENCODED_SIZE (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_T_AS_NTT_ENCODED_SIZE + (size_t)32U)

#define LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_COEFFICIENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA1 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA1_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM768_ETA1 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA2 ((size_t)2U)

#define LIBCRUX_ML_KEM_MLKEM768_ETA2_RANDOMNESS_SIZE (LIBCRUX_ML_KEM_MLKEM768_ETA2 * (size_t)64U)

#define LIBCRUX_ML_KEM_MLKEM768_IMPLICIT_REJECTION_HASH_INPUT_SIZE (LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE + LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE)

typedef Eurydice_arr_7d libcrux_ml_kem_mlkem768_MlKem768PrivateKey;

typedef Eurydice_arr_5f libcrux_ml_kem_mlkem768_MlKem768PublicKey;

#define LIBCRUX_ML_KEM_MLKEM768_RANKED_BYTES_PER_RING_ELEMENT (LIBCRUX_ML_KEM_MLKEM768_RANK * LIBCRUX_ML_KEM_CONSTANTS_BITS_PER_RING_ELEMENT / (size_t)8U)

#define LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE (LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_SECRET_KEY_SIZE + LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE + LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE)

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_H_DEFINED
#endif /* libcrux_mlkem768_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem768_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem768_avx2.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_avx2.h"

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_avx2_19(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_661(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_19(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return decapsulate_avx2_19(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_decapsulate(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_19(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate_avx2
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4 encapsulate_avx2_26(Eurydice_arr_5f *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_a11(public_key, randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4 encapsulate_26(Eurydice_arr_5f *public_key, Eurydice_arr_ec *randomness)
{
  return encapsulate_avx2_26(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_encapsulate(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_26(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair_avx2
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair
generate_keypair_avx2_e9(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_db1(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair generate_keypair_e9(Eurydice_arr_c7 *randomness)
{
  return generate_keypair_avx2_e9(randomness);
}

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_avx2_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_e9(&randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static bool
validate_private_key_avx2_d3(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_d50(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static bool validate_private_key_d3(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return validate_private_key_avx2_d3(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_avx2_validate_private_key(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return validate_private_key_d3(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_private_key_only
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
static KRML_MUSTINLINE bool validate_private_key_only_3b(Eurydice_arr_7d *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_a4(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_private_key_only(Eurydice_arr_7d *private_key)
{
  return validate_private_key_only_3b(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key_avx2
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static bool validate_public_key_avx2_3b(Eurydice_arr_5f *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_79(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.validate_public_key
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static bool validate_public_key_3b(Eurydice_arr_5f *public_key)
{
  return validate_public_key_avx2_3b(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_public_key(Eurydice_arr_5f *public_key)
{
  return validate_public_key_3b(public_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate_avx2
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_avx2_190(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(key_pair, ciphertext);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_190(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_avx2_190(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_unpacked_decapsulate(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_190(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate_avx2
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_avx2_260(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(public_key, randomness);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4
encapsulate_260(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec *randomness
)
{
  return encapsulate_avx2_260(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_260(public_key, &randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair_avx2
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_avx2_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(randomness, out);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static void
generate_keypair_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  generate_keypair_avx2_e90(randomness, out);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  generate_keypair_e90(randomness, key_pair);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_e3();
  libcrux_ml_kem_mlkem768_avx2_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_avx2_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_e3();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_mlkem768_avx2_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_e3();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.keypair_from_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
keypair_from_private_key_71(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_from_private_mut(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_71(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(key_pair, serialized);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_public_key(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *pk
)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
  uu____0 =
    libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(key_pair));
  pk[0U] = uu____0;
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key_avx2
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static void
unpack_public_key_avx2_d3(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.avx2.unpacked.unpack_public_key
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static void
unpack_public_key_d3(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  unpack_public_key_avx2_d3(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_avx2_unpacked_unpacked_public_key(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  unpack_public_key_d3(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem768_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_avx2_H
#define libcrux_mlkem768_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_avx2_decapsulate(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_avx2_encapsulate(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_avx2_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_avx2_validate_private_key(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_private_key_only(Eurydice_arr_7d *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_avx2_validate_public_key(Eurydice_arr_5f *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_avx2_H_DEFINED
#endif /* libcrux_mlkem768_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem768_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem768_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"

/**
 Portable decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static Eurydice_arr_ec
decapsulate_19(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_decapsulate_fd(private_key, ciphertext);
}

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_decapsulate(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_19(private_key, ciphertext);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static tuple_f4 encapsulate_26(Eurydice_arr_5f *public_key, Eurydice_arr_ec *randomness)
{
  return libcrux_ml_kem_ind_cca_encapsulate_99(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_encapsulate(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_26(public_key, &randomness);
}

/**
 Portable generate key pair.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static libcrux_ml_kem_mlkem768_MlKem768KeyPair generate_keypair_e9(Eurydice_arr_c7 *randomness)
{
  return libcrux_ml_kem_ind_cca_generate_keypair_b8(randomness);
}

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_portable_generate_key_pair(Eurydice_arr_c7 randomness)
{
  return generate_keypair_e9(&randomness);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE bool
validate_private_key_d3(Eurydice_arr_7d *private_key, Eurydice_arr_2b *ciphertext)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_ba(private_key, ciphertext);
}

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return validate_private_key_d3(private_key, ciphertext);
}

/**
 Private key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_private_key_only
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
static KRML_MUSTINLINE bool validate_private_key_only_3b(Eurydice_arr_7d *private_key)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_52(private_key);
}

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_private_key_only(Eurydice_arr_7d *private_key)
{
  return validate_private_key_only_3b(private_key);
}

/**
 Public key validation
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.validate_public_key
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE bool validate_public_key_3b(Eurydice_arr_5f *public_key)
{
  return libcrux_ml_kem_ind_cca_validate_public_key_b6(public_key);
}

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_public_key(Eurydice_arr_5f *public_key)
{
  return validate_public_key_3b(public_key);
}

/**
 Unpacked decapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.decapsulate
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decapsulate_190(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
)
{
  return libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(key_pair, ciphertext);
}

/**
 Decapsulate ML-KEM 768 (unpacked)

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an unpacked key pair of type [`MlKem768KeyPairUnpacked`]
 and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_unpacked_decapsulate(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  return decapsulate_190(private_key, ciphertext);
}

/**
 Unpacked encapsulate
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.encapsulate
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_f4
encapsulate_260(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec *randomness
)
{
  return libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(public_key, randomness);
}

/**
 Encapsulate ML-KEM 768 (unpacked)

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an unpacked public key of type [`MlKem768PublicKeyUnpacked`],
 the SHA3-256 hash of this public key, and [`SHARED_SECRET_SIZE`] bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_unpacked_encapsulate(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec randomness
)
{
  return encapsulate_260(public_key, &randomness);
}

/**
 Generate a key pair
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.generate_keypair
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_e90(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
)
{
  libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(randomness, out);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  generate_keypair_e90(randomness, key_pair);
}

/**
 Generate ML-KEM 768 Key Pair in "unpacked" form.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair(Eurydice_arr_c7 randomness)
{
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
  key_pair = libcrux_ml_kem_ind_cca_unpacked_default_7b_68();
  libcrux_ml_kem_mlkem768_portable_unpacked_generate_key_pair_mut(randomness, &key_pair);
  return key_pair;
}

/**
 Create a new, empty unpacked key.
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_mlkem768_portable_unpacked_init_key_pair(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_7b_68();
}

/**
 Create a new, empty unpacked public key.
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_mlkem768_portable_unpacked_init_public_key(void)
{
  return libcrux_ml_kem_ind_cca_unpacked_default_30_68();
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.keypair_from_private_key
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
keypair_from_private_key_71(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(private_key, key_pair);
}

/**
 Get an unpacked key from a private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_from_private_mut(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  keypair_from_private_key_71(private_key, key_pair);
}

/**
 Get the serialized private key.
*/
Eurydice_arr_7d
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(key_pair);
}

/**
 Get the serialized private key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_private_key_mut(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(key_pair, serialized);
}

/**
 Get the serialized public key.
*/
Eurydice_arr_5f
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  return libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(key_pair);
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_key_pair_serialized_public_key_mut(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(key_pair, serialized);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_public_key(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *pk
)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
  uu____0 =
    libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(key_pair));
  pk[0U] = uu____0;
}

/**
 Get the serialized public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_serialized_public_key(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(public_key, serialized);
}

/**
 Get the unpacked public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.instantiations.portable.unpacked.unpack_public_key
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
unpack_public_key_d3(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(public_key, unpacked_public_key);
}

/**
 Get the unpacked public key.
*/
void
libcrux_ml_kem_mlkem768_portable_unpacked_unpacked_public_key(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  unpack_public_key_d3(public_key, unpacked_public_key);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem768_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem768_portable_H
#define libcrux_mlkem768_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
 Decapsulate ML-KEM 768

 Generates an [`MlKemSharedSecret`].
 The input is a reference to an [`MlKem768PrivateKey`] and an [`MlKem768Ciphertext`].
*/
Eurydice_arr_ec
libcrux_ml_kem_mlkem768_portable_decapsulate(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Encapsulate ML-KEM 768

 Generates an ([`MlKem768Ciphertext`], [`MlKemSharedSecret`]) tuple.
 The input is a reference to an [`MlKem768PublicKey`] and [`SHARED_SECRET_SIZE`]
 bytes of `randomness`.
*/
tuple_f4
libcrux_ml_kem_mlkem768_portable_encapsulate(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec randomness
);

/**
 Generate ML-KEM 768 Key Pair
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_mlkem768_portable_generate_key_pair(Eurydice_arr_c7 randomness);

/**
 Validate a private key.

 Returns `true` if valid, and `false` otherwise.
*/
bool
libcrux_ml_kem_mlkem768_portable_validate_private_key(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
);

/**
 Validate the private key only.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_private_key_only(Eurydice_arr_7d *private_key);

/**
 Validate a public key.

 Returns `true` if valid, and `false` otherwise.
*/
bool libcrux_ml_kem_mlkem768_portable_validate_public_key(Eurydice_arr_5f *public_key);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem768_portable_H_DEFINED
#endif /* libcrux_mlkem768_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem_avx2.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_sha3_avx2.h"
#include "libcrux_mlkem_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_mlkem_portable.h"
#include "internal/libcrux_core.h"

KRML_MUSTINLINE Eurydice_arr_c7
libcrux_ml_kem_hash_functions_avx2_G(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_c7 digest = { .data = { 0U } };
  libcrux_sha3_portable_sha512(Eurydice_array_to_slice_mut_17(&digest), input);
  return digest;
}

KRML_MUSTINLINE Eurydice_arr_ec
libcrux_ml_kem_hash_functions_avx2_H(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_sha256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_vec_zero(void)
{
  return mm256_setzero_si256();
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_ZERO_f5(void)
{
  return libcrux_ml_kem_vector_avx2_vec_zero();
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_vec_from_i16_array(Eurydice_mut_borrow_slice_i16 array)
{
  return mm256_loadu_si256_i16(array);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_mut_borrow_slice_i16 array)
{
  return libcrux_ml_kem_vector_avx2_vec_from_i16_array(array);
}

KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_vec_to_i16_array(__m256i v)
{
  Eurydice_arr_d6 output = { .data = { 0U } };
  mm256_storeu_si256_i16(Eurydice_array_to_slice_mut_8a(&output), v);
  return output;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_to_i16_array_f5(__m256i x)
{
  return libcrux_ml_kem_vector_avx2_vec_to_i16_array(x);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_from_bytes(Eurydice_mut_borrow_slice_u8 array)
{
  return
    mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(array,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)32U })));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_from_bytes_f5(Eurydice_mut_borrow_slice_u8 array)
{
  return libcrux_ml_kem_vector_avx2_from_bytes(array);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_avx2_to_bytes(__m256i x, Eurydice_mut_borrow_slice_u8 bytes)
{
  mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)32U })),
    x);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE void
libcrux_ml_kem_vector_avx2_to_bytes_f5(__m256i x, Eurydice_mut_borrow_slice_u8 bytes)
{
  libcrux_ml_kem_vector_avx2_to_bytes(x, bytes);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_add(__m256i lhs, __m256i rhs)
{
  return mm256_add_epi16(lhs, rhs);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_add_f5(__m256i lhs, __m256i *rhs)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_add(lhs, rhs[0U]);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_sub(__m256i lhs, __m256i rhs)
{
  return mm256_sub_epi16(lhs, rhs);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_sub_f5(__m256i lhs, __m256i *rhs)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_sub(lhs, rhs[0U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(__m256i vector, int16_t constant)
{
  __m256i cv = mm256_set1_epi16(constant);
  return mm256_mullo_epi16(vector, cv);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(__m256i vec, int16_t c)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(vec, c);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i v_minus_field_modulus = mm256_sub_epi16(vector, field_modulus);
  __m256i sign_mask = mm256_srai_epi16(15, v_minus_field_modulus, __m256i);
  __m256i conditional_add_field_modulus = mm256_and_si256(sign_mask, field_modulus);
  return mm256_add_epi16(v_minus_field_modulus, conditional_add_field_modulus);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_cond_subtract_3329(vector);
}

/**
 See Section 3.2 of the implementation notes document for an explanation
 of this code.
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(__m256i vector)
{
  __m256i
  t0 =
    mm256_mulhi_epi16(vector,
      mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_AVX2_ARITHMETIC_BARRETT_MULTIPLIER));
  __m256i t512 = mm256_set1_epi16(512);
  __m256i t1 = mm256_add_epi16(t0, t512);
  __m256i quotient = mm256_srai_epi16(10, t1, __m256i);
  __m256i
  quotient_times_field_modulus =
    mm256_mullo_epi16(quotient,
      mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  return mm256_sub_epi16(vector, quotient_times_field_modulus);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_barrett_reduce_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i vector,
  int16_t constant
)
{
  __m256i vec_constant = mm256_set1_epi16(constant);
  __m256i value_low = mm256_mullo_epi16(vector, vec_constant);
  __m256i
  k =
    mm256_mullo_epi16(value_low,
      mm256_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i k_times_modulus = mm256_mulhi_epi16(k, modulus);
  __m256i value_high = mm256_mulhi_epi16(vector, vec_constant);
  return mm256_sub_epi16(value_high, k_times_modulus);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(__m256i vector, int16_t constant)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(vector, constant);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(
  __m256i vector,
  int16_t constant
)
{
  __m256i cv = mm256_set1_epi16(constant);
  return mm256_and_si256(vector, cv);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.arithmetic.shift_right
with const generics
- SHIFT_BY= 15
*/
static KRML_MUSTINLINE __m256i shift_right_ef(__m256i vector)
{
  return mm256_srai_epi16(15, vector, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(__m256i a)
{
  __m256i t = shift_right_ef(a);
  __m256i
  fm =
    libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(t,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  return libcrux_ml_kem_vector_avx2_arithmetic_add(a, fm);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(a);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(__m256i vector)
{
  __m256i
  field_modulus_halved = mm256_set1_epi16((LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i
  field_modulus_quartered =
    mm256_set1_epi16((LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 4);
  __m256i shifted = mm256_sub_epi16(field_modulus_halved, vector);
  __m256i mask = mm256_srai_epi16(15, shifted, __m256i);
  __m256i shifted_to_positive = mm256_xor_si256(mask, shifted);
  __m256i
  shifted_to_positive_in_range = mm256_sub_epi16(shifted_to_positive, field_modulus_quartered);
  return mm256_srli_epi16(15, shifted_to_positive_in_range, __m256i);
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_1(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_1_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_compress_1(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(__m256i lhs, __m256i rhs)
{
  __m256i prod02 = mm256_mul_epu32(lhs, rhs);
  __m256i
  prod13 =
    mm256_mul_epu32(mm256_shuffle_epi32(245, lhs, __m256i),
      mm256_shuffle_epi32(245, rhs, __m256i));
  return
    mm256_unpackhi_epi64(mm256_unpacklo_epi32(prod02, prod13),
      mm256_unpackhi_epi32(prod02, prod13));
}

KRML_MUSTINLINE __m256i libcrux_ml_kem_vector_avx2_compress_decompress_1(__m256i a)
{
  __m256i z = mm256_setzero_si256();
  __m256i s = libcrux_ml_kem_vector_avx2_arithmetic_sub(z, a);
  return libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(s, 1665);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_decompress_1_f5(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_compress_decompress_1(a);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(
  __m256i vec,
  __m256i constants
)
{
  __m256i value_low = mm256_mullo_epi16(vec, constants);
  __m256i
  k =
    mm256_mullo_epi16(value_low,
      mm256_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i k_times_modulus = mm256_mulhi_epi16(k, modulus);
  __m256i value_high = mm256_mulhi_epi16(vec, constants);
  return mm256_sub_epi16(value_high, k_times_modulus);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i
  zetas =
    mm256_set_epi16(-zeta3,
      -zeta3,
      zeta3,
      zeta3,
      -zeta2,
      -zeta2,
      zeta2,
      zeta2,
      -zeta1,
      -zeta1,
      zeta1,
      zeta1,
      -zeta0,
      -zeta0,
      zeta0,
      zeta0);
  __m256i rhs = mm256_shuffle_epi32(245, vector, __m256i);
  __m256i
  rhs0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(rhs, zetas);
  __m256i lhs = mm256_shuffle_epi32(160, vector, __m256i);
  return mm256_add_epi16(lhs, rhs0);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  __m256i
  zetas =
    mm256_set_epi16(-zeta1,
      -zeta1,
      -zeta1,
      -zeta1,
      zeta1,
      zeta1,
      zeta1,
      zeta1,
      -zeta0,
      -zeta0,
      -zeta0,
      -zeta0,
      zeta0,
      zeta0,
      zeta0,
      zeta0);
  __m256i rhs = mm256_shuffle_epi32(238, vector, __m256i);
  __m256i
  rhs0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(rhs, zetas);
  __m256i lhs = mm256_shuffle_epi32(68, vector, __m256i);
  return mm256_add_epi16(lhs, rhs0);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(vector, zeta0, zeta1);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_2_step(vector, zeta0, zeta1);
}

KRML_MUSTINLINE __m128i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(
  __m128i vec,
  __m128i constants
)
{
  __m128i value_low = mm_mullo_epi16(vec, constants);
  __m128i
  k =
    mm_mullo_epi16(value_low,
      mm_set1_epi16((int16_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m128i modulus = mm_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m128i k_times_modulus = mm_mulhi_epi16(k, modulus);
  __m128i value_high = mm_mulhi_epi16(vec, constants);
  return mm_sub_epi16(value_high, k_times_modulus);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  __m128i rhs = mm256_extracti128_si256(1, vector, __m128i);
  __m128i
  rhs0 =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(rhs,
      mm_set1_epi16(zeta));
  __m128i lhs = mm256_castsi256_si128(vector);
  __m128i lower_coefficients = mm_add_epi16(lhs, rhs0);
  __m128i upper_coefficients = mm_sub_epi16(lhs, rhs0);
  __m256i combined = mm256_castsi128_si256(lower_coefficients);
  return mm256_inserti128_si256(1, combined, upper_coefficients, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(vector, zeta);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_layer_3_step(vector, zeta);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i lhs = mm256_shuffle_epi32(245, vector, __m256i);
  __m256i rhs = mm256_shuffle_epi32(160, vector, __m256i);
  __m256i
  rhs0 =
    mm256_mullo_epi16(rhs,
      mm256_set_epi16(-1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1));
  __m256i sum0 = mm256_add_epi16(lhs, rhs0);
  __m256i
  sum_times_zetas =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(sum0,
      mm256_set_epi16(zeta3,
        zeta3,
        0,
        0,
        zeta2,
        zeta2,
        0,
        0,
        zeta1,
        zeta1,
        0,
        0,
        zeta0,
        zeta0,
        0,
        0));
  __m256i sum = libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(sum0);
  return mm256_blend_epi16(204, sum, sum_times_zetas, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(vector, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
)
{
  __m256i lhs = mm256_permute4x64_epi64(245, vector, __m256i);
  __m256i rhs = mm256_permute4x64_epi64(160, vector, __m256i);
  __m256i
  rhs0 =
    mm256_mullo_epi16(rhs,
      mm256_set_epi16(-1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1));
  __m256i sum = mm256_add_epi16(lhs, rhs0);
  __m256i
  sum_times_zetas =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(sum,
      mm256_set_epi16(zeta1,
        zeta1,
        zeta1,
        zeta1,
        0,
        0,
        0,
        0,
        zeta0,
        zeta0,
        zeta0,
        zeta0,
        0,
        0,
        0,
        0));
  return mm256_blend_epi16(240, sum, sum_times_zetas, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(vector, zeta0, zeta1);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(vector, zeta0, zeta1);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  __m128i lhs = mm256_extracti128_si256(1, vector, __m128i);
  __m128i rhs = mm256_castsi256_si128(vector);
  __m128i lower_coefficients = mm_add_epi16(lhs, rhs);
  __m128i upper_coefficients = mm_sub_epi16(lhs, rhs);
  __m128i
  upper_coefficients0 =
    libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(upper_coefficients,
      mm_set1_epi16(zeta));
  __m256i combined = mm256_castsi128_si256(lower_coefficients);
  return mm256_inserti128_si256(1, combined, upper_coefficients0, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(vector, zeta);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(__m256i vector, int16_t zeta)
{
  return libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(vector, zeta);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(__m256i vec)
{
  __m256i
  k =
    mm256_mullo_epi16(vec,
      mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  __m256i
  k_times_modulus =
    mm256_mulhi_epi16(k,
      mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  __m256i value_high = mm256_srli_epi32(16, vec, __m256i);
  __m256i result = mm256_sub_epi16(value_high, k_times_modulus);
  __m256i result0 = mm256_slli_epi32(16, result, __m256i);
  return mm256_srai_epi32(16, result0, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(
  __m256i lhs,
  __m256i rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  __m256i
  shuffle_with =
    mm256_set_epi8(15,
      14,
      11,
      10,
      7,
      6,
      3,
      2,
      13,
      12,
      9,
      8,
      5,
      4,
      1,
      0,
      15,
      14,
      11,
      10,
      7,
      6,
      3,
      2,
      13,
      12,
      9,
      8,
      5,
      4,
      1,
      0);
  __m256i lhs_shuffled = mm256_shuffle_epi8(lhs, shuffle_with);
  __m256i lhs_shuffled0 = mm256_permute4x64_epi64(216, lhs_shuffled, __m256i);
  __m128i lhs_evens = mm256_castsi256_si128(lhs_shuffled0);
  __m256i lhs_evens0 = mm256_cvtepi16_epi32(lhs_evens);
  __m128i lhs_odds = mm256_extracti128_si256(1, lhs_shuffled0, __m128i);
  __m256i lhs_odds0 = mm256_cvtepi16_epi32(lhs_odds);
  __m256i rhs_shuffled = mm256_shuffle_epi8(rhs, shuffle_with);
  __m256i rhs_shuffled0 = mm256_permute4x64_epi64(216, rhs_shuffled, __m256i);
  __m128i rhs_evens = mm256_castsi256_si128(rhs_shuffled0);
  __m256i rhs_evens0 = mm256_cvtepi16_epi32(rhs_evens);
  __m128i rhs_odds = mm256_extracti128_si256(1, rhs_shuffled0, __m128i);
  __m256i rhs_odds0 = mm256_cvtepi16_epi32(rhs_odds);
  __m256i left = mm256_mullo_epi32(lhs_evens0, rhs_evens0);
  __m256i right = mm256_mullo_epi32(lhs_odds0, rhs_odds0);
  __m256i right0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(right);
  __m256i
  right1 =
    mm256_mullo_epi32(right0,
      mm256_set_epi32(-(int32_t)zeta3,
        (int32_t)zeta3,
        -(int32_t)zeta2,
        (int32_t)zeta2,
        -(int32_t)zeta1,
        (int32_t)zeta1,
        -(int32_t)zeta0,
        (int32_t)zeta0));
  __m256i products_left = mm256_add_epi32(left, right1);
  __m256i
  products_left0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(products_left);
  __m256i
  rhs_adjacent_swapped =
    mm256_shuffle_epi8(rhs,
      mm256_set_epi8(13,
        12,
        15,
        14,
        9,
        8,
        11,
        10,
        5,
        4,
        7,
        6,
        1,
        0,
        3,
        2,
        13,
        12,
        15,
        14,
        9,
        8,
        11,
        10,
        5,
        4,
        7,
        6,
        1,
        0,
        3,
        2));
  __m256i products_right = mm256_madd_epi16(lhs, rhs_adjacent_swapped);
  __m256i
  products_right0 = libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(products_right);
  __m256i products_right1 = mm256_slli_epi32(16, products_right0, __m256i);
  return mm256_blend_epi16(170, products_left0, products_right1, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_multiply(
  __m256i *lhs,
  __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return
    libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(lhs[0U],
      rhs[0U],
      zeta0,
      zeta1,
      zeta2,
      zeta3);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_ntt_multiply_f5(
  __m256i *lhs,
  __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_avx2_ntt_multiply(lhs, rhs, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_array_u8x2
libcrux_ml_kem_vector_avx2_serialize_serialize_1(__m256i vector)
{
  __m256i lsb_to_msb = mm256_slli_epi16(15, vector, __m256i);
  __m128i low_msbs = mm256_castsi256_si128(lsb_to_msb);
  __m128i high_msbs = mm256_extracti128_si256(1, lsb_to_msb, __m128i);
  __m128i msbs = mm_packs_epi16(low_msbs, high_msbs);
  int32_t bits_packed = mm_movemask_epi8(msbs);
  Eurydice_array_u8x2
  result = { .data = { (uint8_t)bits_packed, (uint8_t)(bits_packed >> 8U) } };
  return result;
}

KRML_MUSTINLINE Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_1(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_1(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s(int16_t a, int16_t b)
{
  __m256i coefficients = mm256_set_epi16(b, b, b, b, b, b, b, b, a, a, a, a, a, a, a, a);
  __m256i
  coefficients_in_msb =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 8U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 10U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 12U),
        (int16_t)((uint32_t)1 << 13U),
        (int16_t)((uint32_t)1 << 14U),
        -32768,
        (int16_t)((uint32_t)1 << 8U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 10U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 12U),
        (int16_t)((uint32_t)1 << 13U),
        (int16_t)((uint32_t)1 << 14U),
        -32768));
  return mm256_srli_epi16(15, coefficients_in_msb, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(uint8_t a, uint8_t b)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s((int16_t)a,
      (int16_t)b);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1(Eurydice_mut_borrow_slice_u8 bytes)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(bytes.ptr[0U],
      bytes.ptr[1U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_1(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_1(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_1(bytes);
}

/**
 `mm256_concat_pairs_n(n, x)` is then a sequence of 32 bits packets
 of the shape `0b0…0b₁…bₙa₁…aₙ`, if `x` is a sequence of pairs of
 16 bits, of the shape `(0b0…0a₁…aₙ, 0b0…0b₁…bₙ)` (where the last
 `n` bits are non-zero).
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(uint8_t n, __m256i x)
{
  int16_t n0 = (int16_t)((uint32_t)1 << (uint32_t)n);
  return
    mm256_madd_epi16(x,
      mm256_set_epi16(n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1, n0, 1));
}

KRML_MUSTINLINE Eurydice_array_u8x8
libcrux_ml_kem_vector_avx2_serialize_serialize_4(__m256i vector)
{
  Eurydice_arr_b2 serialized = { .data = { 0U } };
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(4U, vector);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_2_combined,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        8,
        4,
        0,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        8,
        4,
        0));
  __m256i
  combined =
    mm256_permutevar8x32_epi32(adjacent_8_combined,
      mm256_set_epi32(0, 0, 0, 0, 0, 0, 4, 0));
  __m128i combined0 = mm256_castsi256_si128(combined);
  mm_storeu_bytes_si128(Eurydice_array_to_slice_mut_29(&serialized), combined0);
  Eurydice_array_u8x8 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_mut_d45(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })).ptr,
    (size_t)8U * sizeof (uint8_t));
  return
    core_result_unwrap_26_e0((
        KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_4(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s(
  int16_t b0,
  int16_t b1,
  int16_t b2,
  int16_t b3,
  int16_t b4,
  int16_t b5,
  int16_t b6,
  int16_t b7
)
{
  __m256i
  coefficients = mm256_set_epi16(b7, b7, b6, b6, b5, b5, b4, b4, b3, b3, b2, b2, b1, b1, b0, b0);
  __m256i
  coefficients_in_msb =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U)));
  __m256i coefficients_in_lsb = mm256_srli_epi16(4, coefficients_in_msb, __m256i);
  return
    mm256_and_si256(coefficients_in_lsb,
      mm256_set1_epi16((int16_t)((uint32_t)1 << 4U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(
  uint8_t b0,
  uint8_t b1,
  uint8_t b2,
  uint8_t b3,
  uint8_t b4,
  uint8_t b5,
  uint8_t b6,
  uint8_t b7
)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s((int16_t)b0,
      (int16_t)b1,
      (int16_t)b2,
      (int16_t)b3,
      (int16_t)b4,
      (int16_t)b5,
      (int16_t)b6,
      (int16_t)b7);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes)
{
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(bytes.ptr[0U],
      bytes.ptr[1U],
      bytes.ptr[2U],
      bytes.ptr[3U],
      bytes.ptr[4U],
      bytes.ptr[5U],
      bytes.ptr[6U],
      bytes.ptr[7U]);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_4(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_4_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_4(bytes);
}

KRML_MUSTINLINE Eurydice_arr_6d
libcrux_ml_kem_vector_avx2_serialize_serialize_5(__m256i vector)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  __m256i
  adjacent_2_combined =
    mm256_madd_epi16(vector,
      mm256_set_epi16((int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1,
        (int16_t)((uint32_t)1 << 5U),
        1));
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 22, 0, 22, 0, 22, 0, 22));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(22, adjacent_4_combined, __m256i);
  __m256i adjacent_8_combined = mm256_shuffle_epi32(8, adjacent_4_combined0, __m256i);
  __m256i
  adjacent_8_combined0 =
    mm256_sllv_epi32(adjacent_8_combined,
      mm256_set_epi32(0, 0, 0, 12, 0, 0, 0, 12));
  __m256i adjacent_8_combined1 = mm256_srli_epi64(12, adjacent_8_combined0, __m256i);
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined1);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined1, __m128i);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)5U, .end = (size_t)21U })),
    upper_8);
  Eurydice_arr_6d arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)10U })).ptr,
    (size_t)10U * sizeof (uint8_t));
  return
    core_result_unwrap_26_63((
        KRML_CLITERAL(core_result_Result_80){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_5_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_5(vector);
}

/**
 We cannot model `mm256_inserti128_si256` on its own: it produces a
 Vec256 where the upper 128 bits are undefined. Thus
 `mm256_inserti128_si256` is not pure.

 Luckily, we always call `mm256_castsi128_si256` right after
 `mm256_inserti128_si256`: this composition sets the upper bits,
 making the whole computation pure again.
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(__m128i lower, __m128i upper)
{
  return mm256_inserti128_si256(1, mm256_castsi128_si256(lower), upper, __m256i);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_5(Eurydice_mut_borrow_slice_u8 bytes)
{
  __m128i
  coefficients =
    mm_set_epi8((int8_t)bytes.ptr[9U],
      (int8_t)bytes.ptr[8U],
      (int8_t)bytes.ptr[8U],
      (int8_t)bytes.ptr[7U],
      (int8_t)bytes.ptr[7U],
      (int8_t)bytes.ptr[6U],
      (int8_t)bytes.ptr[6U],
      (int8_t)bytes.ptr[5U],
      (int8_t)bytes.ptr[4U],
      (int8_t)bytes.ptr[3U],
      (int8_t)bytes.ptr[3U],
      (int8_t)bytes.ptr[2U],
      (int8_t)bytes.ptr[2U],
      (int8_t)bytes.ptr[1U],
      (int8_t)bytes.ptr[1U],
      (int8_t)bytes.ptr[0U]);
  __m256i
  coefficients_loaded =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(coefficients,
      coefficients);
  __m256i
  coefficients0 =
    mm256_shuffle_epi8(coefficients_loaded,
      mm256_set_epi8(15,
        14,
        15,
        14,
        13,
        12,
        13,
        12,
        11,
        10,
        11,
        10,
        9,
        8,
        9,
        8,
        7,
        6,
        7,
        6,
        5,
        4,
        5,
        4,
        3,
        2,
        3,
        2,
        1,
        0,
        1,
        0));
  __m256i
  coefficients1 =
    mm256_mullo_epi16(coefficients0,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 5U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 7U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 11U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 5U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 7U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 9U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 11U)));
  return mm256_srli_epi16(11, coefficients1, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_5_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_5(bytes);
}

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(__m256i vector)
{
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(10U, vector);
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 12, 0, 12, 0, 12, 0, 12));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(12, adjacent_4_combined, __m256i);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_4_combined0,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        11,
        10,
        9,
        8,
        4,
        3,
        2,
        1,
        0,
        -1,
        -1,
        -1,
        -1,
        -1,
        -1,
        12,
        11,
        10,
        9,
        8,
        4,
        3,
        2,
        1,
        0));
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined, __m128i);
  return (KRML_CLITERAL(core_core_arch_x86___m128i_x2){ .fst = lower_8, .snd = upper_8 });
}

KRML_MUSTINLINE Eurydice_arr_fc
libcrux_ml_kem_vector_avx2_serialize_serialize_10(__m256i vector)
{
  core_core_arch_x86___m128i_x2
  uu____0 = libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(vector);
  __m128i lower_8 = uu____0.fst;
  __m128i upper_8 = uu____0.snd;
  Eurydice_arr_ec serialized = { .data = { 0U } };
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)26U })),
    upper_8);
  Eurydice_arr_fc arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)20U })).ptr,
    (size_t)20U * sizeof (uint8_t));
  return
    core_result_unwrap_26_7d((
        KRML_CLITERAL(core_result_Result_83){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_10(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_10(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
)
{
  __m128i
  lower_coefficients =
    mm_shuffle_epi8(lower_coefficients0,
      mm_set_epi8(9, 8, 8, 7, 7, 6, 6, 5, 4, 3, 3, 2, 2, 1, 1, 0));
  __m128i
  upper_coefficients =
    mm_shuffle_epi8(upper_coefficients0,
      mm_set_epi8(15, 14, 14, 13, 13, 12, 12, 11, 10, 9, 9, 8, 8, 7, 7, 6));
  __m256i
  coefficients =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(lower_coefficients,
      upper_coefficients);
  __m256i
  coefficients0 =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 2U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 6U)));
  __m256i coefficients1 = mm256_srli_epi16(6, coefficients0, __m256i);
  return mm256_and_si256(coefficients1, mm256_set1_epi16((int16_t)((uint32_t)1 << 10U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes)
{
  Eurydice_mut_borrow_slice_u8
  lower_coefficients =
    Eurydice_slice_subslice_mut_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U }));
  Eurydice_mut_borrow_slice_u8
  upper_coefficients =
    Eurydice_slice_subslice_mut_c8(bytes,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)20U }));
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(mm_loadu_si128(lower_coefficients),
      mm_loadu_si128(upper_coefficients));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_10(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_10_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_10(bytes);
}

KRML_MUSTINLINE Eurydice_arr_80
libcrux_ml_kem_vector_avx2_serialize_serialize_11(__m256i vector)
{
  Eurydice_arr_d6 array = { .data = { 0U } };
  mm256_storeu_si256_i16(Eurydice_array_to_slice_mut_8a(&array), vector);
  Eurydice_arr_d6
  input =
    libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_array_to_slice_mut_8a(&array));
  return libcrux_ml_kem_vector_portable_serialize_11_b8(input);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_11_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_11(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_11(Eurydice_mut_borrow_slice_u8 bytes)
{
  Eurydice_arr_d6 output = libcrux_ml_kem_vector_portable_deserialize_11_b8(bytes);
  Eurydice_arr_d6 array = libcrux_ml_kem_vector_portable_to_i16_array_b8(output);
  return mm256_loadu_si256_i16(Eurydice_array_to_slice_mut_8a(&array));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_11_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_11(bytes);
}

KRML_MUSTINLINE core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(__m256i vector)
{
  __m256i
  adjacent_2_combined = libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(12U, vector);
  __m256i
  adjacent_4_combined =
    mm256_sllv_epi32(adjacent_2_combined,
      mm256_set_epi32(0, 8, 0, 8, 0, 8, 0, 8));
  __m256i adjacent_4_combined0 = mm256_srli_epi64(8, adjacent_4_combined, __m256i);
  __m256i
  adjacent_8_combined =
    mm256_shuffle_epi8(adjacent_4_combined0,
      mm256_set_epi8(-1,
        -1,
        -1,
        -1,
        13,
        12,
        11,
        10,
        9,
        8,
        5,
        4,
        3,
        2,
        1,
        0,
        -1,
        -1,
        -1,
        -1,
        13,
        12,
        11,
        10,
        9,
        8,
        5,
        4,
        3,
        2,
        1,
        0));
  __m128i lower_8 = mm256_castsi256_si128(adjacent_8_combined);
  __m128i upper_8 = mm256_extracti128_si256(1, adjacent_8_combined, __m128i);
  return (KRML_CLITERAL(core_core_arch_x86___m128i_x2){ .fst = lower_8, .snd = upper_8 });
}

KRML_MUSTINLINE Eurydice_arr_94
libcrux_ml_kem_vector_avx2_serialize_serialize_12(__m256i vector)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  core_core_arch_x86___m128i_x2
  uu____0 = libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(vector);
  __m128i lower_8 = uu____0.fst;
  __m128i upper_8 = uu____0.snd;
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })),
    lower_8);
  mm_storeu_bytes_si128(Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)28U })),
    upper_8);
  Eurydice_arr_94 arr;
  memcpy(arr.data,
    Eurydice_array_to_subslice_mut_d44(&serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)24U })).ptr,
    (size_t)24U * sizeof (uint8_t));
  return
    core_result_unwrap_26_78((
        KRML_CLITERAL(core_result_Result_57){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

KRML_MUSTINLINE Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_serialize_12(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12_f5(__m256i vector)
{
  return libcrux_ml_kem_vector_avx2_serialize_12(vector);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
)
{
  __m128i
  lower_coefficients =
    mm_shuffle_epi8(lower_coefficients0,
      mm_set_epi8(11, 10, 10, 9, 8, 7, 7, 6, 5, 4, 4, 3, 2, 1, 1, 0));
  __m128i
  upper_coefficients =
    mm_shuffle_epi8(upper_coefficients0,
      mm_set_epi8(15, 14, 14, 13, 12, 11, 11, 10, 9, 8, 8, 7, 6, 5, 5, 4));
  __m256i
  coefficients =
    libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(lower_coefficients,
      upper_coefficients);
  __m256i
  coefficients0 =
    mm256_mullo_epi16(coefficients,
      mm256_set_epi16((int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U),
        (int16_t)((uint32_t)1 << 0U),
        (int16_t)((uint32_t)1 << 4U)));
  __m256i coefficients1 = mm256_srli_epi16(4, coefficients0, __m256i);
  return mm256_and_si256(coefficients1, mm256_set1_epi16((int16_t)((uint32_t)1 << 12U) - 1));
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes)
{
  __m128i
  lower_coefficients =
    mm_loadu_si128(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })));
  __m128i
  upper_coefficients =
    mm_loadu_si128(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)24U })));
  return
    libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(lower_coefficients,
      upper_coefficients);
}

KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_serialize_deserialize_12(bytes);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE __m256i
libcrux_ml_kem_vector_avx2_deserialize_12_f5(Eurydice_mut_borrow_slice_u8 bytes)
{
  return libcrux_ml_kem_vector_avx2_deserialize_12(bytes);
}

KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_avx2_sampling_rejection_sample(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
)
{
  __m256i field_modulus = mm256_set1_epi16(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i potential_coefficients = libcrux_ml_kem_vector_avx2_serialize_deserialize_12(input);
  __m256i compare_with_field_modulus = mm256_cmpgt_epi16(field_modulus, potential_coefficients);
  Eurydice_array_u8x2
  good = libcrux_ml_kem_vector_avx2_serialize_serialize_1(compare_with_field_modulus);
  Eurydice_arr_b2
  lower_shuffles =
    LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE.data[(size_t)good.data[0U]];
  __m128i lower_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_mut_29(&lower_shuffles));
  __m128i lower_coefficients = mm256_castsi256_si128(potential_coefficients);
  __m128i lower_coefficients0 = mm_shuffle_epi8(lower_coefficients, lower_shuffles0);
  mm_storeu_si128(output, lower_coefficients0);
  size_t sampled_count = (size_t)core_num__u8__count_ones(good.data[0U]);
  Eurydice_arr_b2
  upper_shuffles =
    LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE.data[(size_t)good.data[1U]];
  __m128i upper_shuffles0 = mm_loadu_si128(Eurydice_array_to_slice_mut_29(&upper_shuffles));
  __m128i upper_coefficients = mm256_extracti128_si256(1, potential_coefficients, __m128i);
  __m128i upper_coefficients0 = mm_shuffle_epi8(upper_coefficients, upper_shuffles0);
  mm_storeu_si128(Eurydice_slice_subslice_mut_a6(output,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = sampled_count,
          .end = sampled_count + (size_t)8U
        }
      )),
    upper_coefficients0);
  size_t uu____0 = sampled_count;
  return uu____0 + (size_t)core_num__u8__count_ones(good.data[1U]);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_avx2_rej_sample_f5(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
)
{
  return libcrux_ml_kem_vector_avx2_sampling_rejection_sample(input, output);
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
inline __m256i libcrux_ml_kem_vector_avx2_clone_fd(__m256i *self)
{
  return self[0U];
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static Eurydice_arr_13 ZERO_d6_84(void)
{
  Eurydice_arr_13 lit;
  __m256i repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_avx2_ZERO_f5(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (__m256i));
  return lit;
}

/**
 Only use with public values.

 This MUST NOT be used with secret inputs, like its caller `deserialize_ring_elements_reduced`.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_reduced_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_to_reduced_ring_element_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_12_f5(bytes);
    re.data[i0] = libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(coefficient);
  }
  return re;
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_e3(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_60 *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c40 shake128_init_absorb_final_78(Eurydice_arr_81 *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_mut_e9(input->data),
    Eurydice_array_to_slice_mut_e9(&input->data[1U]),
    Eurydice_array_to_slice_mut_e9(&input->data[2U]),
    Eurydice_array_to_slice_mut_e9(input->data));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_78(Eurydice_arr_81 *input)
{
  return shake128_init_absorb_final_78(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_7e
shake128_squeeze_first_three_blocks_78(Eurydice_arr_c40 *st)
{
  Eurydice_arr_7e
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_7e
shake128_squeeze_first_three_blocks_41_78(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_79(
  Eurydice_arr_7e *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_2c shake128_squeeze_next_block_78(Eurydice_arr_c40 *st)
{
  Eurydice_arr_2c
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_2c
shake128_squeeze_next_block_41_78(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_790(
  Eurydice_arr_2c *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static Eurydice_arr_13 ZERO_84(void)
{
  Eurydice_arr_13 lit;
  __m256i repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_avx2_ZERO_f5(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (__m256i));
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13 from_i16_array_84(Eurydice_mut_borrow_slice_i16 a)
{
  Eurydice_arr_13 result = ZERO_84();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    result.data[i0] =
      libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_slice_subslice_mut_a6(a,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * (size_t)16U,
              .end = (i0 + (size_t)1U) * (size_t)16U
            }
          )));
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13 from_i16_array_d6_84(Eurydice_mut_borrow_slice_i16 a)
{
  return from_i16_array_84(a);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0a_281(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60 sample_from_xof_281(Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_78(seeds);
  Eurydice_arr_7e randomness0 = shake128_squeeze_first_three_blocks_41_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_79(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c randomness = shake128_squeeze_next_block_41_78(&xof_state);
      done = sample_from_uniform_distribution_next_790(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_60 arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_281(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_281(Eurydice_arr_ea *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_60 sampled = sample_from_xof_281(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_78(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a1(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_211(public_key, (size_t)1152U);
  deserialize_ring_elements_reduced_e3(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f4(public_key,
        (size_t)1152U));
  Eurydice_arr_ea *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f4(public_key,
        (size_t)1152U));
  sample_matrix_A_281(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_78(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_e3(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return &self->public_key;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.clone_91
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static inline libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
clone_91_e3(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *self)
{
  Eurydice_arr_60
  uu____0 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
      &self->t_as_ntt,
      Eurydice_arr_13,
      Eurydice_arr_60);
  Eurydice_arr_ec
  uu____1 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
      &self->seed_for_A,
      uint8_t,
      Eurydice_arr_ec);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef){
        .t_as_ntt = uu____0,
        .seed_for_A = uu____1,
        .A = core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
          &self->A,
          Eurydice_arr_60,
          Eurydice_arr_ea)
      }
    );
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_clone_d7_e3(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  uu____0 = clone_91_e3(&self->ind_cpa_public_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef){
        .ind_cpa_public_key = uu____0,
        .public_key_hash = core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
          &self->public_key_hash,
          uint8_t,
          Eurydice_arr_ec)
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.to_unsigned_field_modulus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE __m256i to_unsigned_field_modulus_84(__m256i a)
{
  return libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.serialize_uncompressed_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_b20
serialize_uncompressed_ring_element_84(Eurydice_arr_13 *re)
{
  Eurydice_arr_b20 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = to_unsigned_field_modulus_84(re->data[i0]);
    Eurydice_arr_94 bytes = libcrux_ml_kem_vector_avx2_serialize_12_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d413(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)24U * i0,
            .end = (size_t)24U * i0 + (size_t)24U
          }
        )),
      Eurydice_array_to_slice_mut_ed(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
serialize_vector_e3(Eurydice_arr_60 *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_79(
  Eurydice_arr_60 *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_5f *serialized
)
{
  serialize_vector_e3(t_as_ntt,
    Eurydice_array_to_subslice_mut_d417(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f4(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self,
  Eurydice_arr_5f *serialized
)
{
  serialize_public_key_mut_79(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_79(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_79(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialize_public_key_79(Eurydice_arr_60 *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_5f public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_79(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialized_dd_79(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *self)
{
  return
    libcrux_ml_kem_types_from_51_3d(serialize_public_key_79(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_79(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return serialized_dd_79(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair768
serialize_unpacked_secret_key_15(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_60 *private_key
)
{
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_79(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_0e secret_key_serialized = { .data = { 0U } };
  serialize_vector_e3(private_key, Eurydice_array_to_slice_mut_f4(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair768){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 =
    serialize_unpacked_secret_key_15(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(Eurydice_array_to_slice_mut_f4(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_ff(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_d4(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *self
)
{
  Eurydice_arr_7d sk = libcrux_ml_kem_types_default_d3_79();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_d4(self, &sk);
  return sk;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_uncompressed_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_to_uncompressed_ring_element_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_avx2_deserialize_12_f5(bytes);
  }
  return re;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_vector_e3(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_60 *secret_as_ntt)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0a_7e1(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60 sample_from_xof_7e1(Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1b
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(seeds);
  Eurydice_arr_7e
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_79(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(&xof_state);
      done = sample_from_uniform_distribution_next_790(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_60 arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e1(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e1(Eurydice_arr_ea *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_60 sampled = sample_from_xof_7e1(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_101(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_e3(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1152U);
  Eurydice_arr_ea *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e1(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_3e(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_mut_51(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_e3(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_101(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)1152U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_60 default_70_e3(void)
{
  Eurydice_arr_60 lit;
  Eurydice_arr_13 repeat_expression[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef default_8b_e3(void)
{
  Eurydice_arr_60 uu____0;
  Eurydice_arr_13 repeat_expression0[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)3U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_60 repeat_expression1[3U];
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    Eurydice_arr_60 lit;
    Eurydice_arr_13 repeat_expression[3U];
    KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)3U * sizeof (Eurydice_arr_60));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef
libcrux_ml_kem_ind_cca_unpacked_default_30_e3(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef){
        .ind_cpa_public_key = default_8b_e3(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_e3(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_ef
  uu____0 =
    { .ind_cpa_private_key = default_70_e3(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_e3()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_78(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_b6(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)3U;
  return G_41_78(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_58 PRFxN_3b(Eurydice_arr_801 *input)
{
  Eurydice_arr_58
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(&input->data[1U]),
    Eurydice_array_to_slice_mut_b5(&input->data[2U]),
    Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_58 PRFxN_41_3b(Eurydice_arr_801 *input)
{
  return PRFxN_3b(input);
}

/**
 Given a series of uniformly random bytes in `randomness`, for some number `eta`,
 the `sample_from_binomial_distribution_{eta}` functions sample
 a ring element from a binomial distribution centered at 0 that uses two sets
 of `eta` coin flips. If, for example,
 `eta = ETA`, each ring coefficient is a value `v` such
 such that `v ∈ {-ETA, -ETA + 1, ..., 0, ..., ETA + 1, ETA}` and:

 ```plaintext
 - If v < 0, Pr[v] = Pr[-v]
 - If v >= 0, Pr[v] = BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2 ^ (2 * ETA)
 ```

 The values `v < 0` are mapped to the appropriate `KyberFieldElement`.

 The expected value is:

 ```plaintext
 E[X] = (-ETA)Pr[-ETA] + (-(ETA - 1))Pr[-(ETA - 1)] + ... + (ETA - 1)Pr[ETA - 1] + (ETA)Pr[ETA]
      = 0 since Pr[-v] = Pr[v] when v < 0.
 ```

 And the variance is:

 ```plaintext
 Var(X) = E[(X - E[X])^2]
        = E[X^2]
        = sum_(v=-ETA to ETA)v^2 * (BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2^(2 * ETA))
        = ETA / 2
 ```

 This function implements <strong>Algorithm 7</strong> of the NIST FIPS 203 standard, which is
 reproduced below:

 ```plaintext
 Input: byte array B ∈ 𝔹^{64η}.
 Output: array f ∈ ℤ₂₅₆.

 b ← BytesToBits(B)
 for (i ← 0; i < 256; i++)
     x ← ∑(j=0 to η - 1) b[2iη + j]
     y ← ∑(j=0 to η - 1) b[2iη + η + j]
     f[i] ← x−y mod q
 end for
 return f
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_2_84(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)4U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_mut_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_mut_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)4U,
            .end = chunk_number * (size_t)4U + (size_t)4U
          }
        ));
    uint32_t
    random_bits_as_u32 =
      (((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U)
      | (uint32_t)byte_chunk.ptr[3U] << 24U;
    uint32_t even_bits = random_bits_as_u32 & 1431655765U;
    uint32_t odd_bits = random_bits_as_u32 >> 1U & 1431655765U;
    uint32_t coin_toss_outcomes = even_bits + odd_bits;
    for (uint32_t i = 0U; i < 32U / 4U; i++)
    {
      uint32_t outcome_set = i;
      uint32_t outcome_set0 = outcome_set * 4U;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 3U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 2U) & 3U);
      size_t offset = (size_t)(outcome_set0 >> 2U);
      sampled_i16s.data[(size_t)8U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_84(Eurydice_array_to_slice_mut_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_3_84(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)3U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_mut_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_mut_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)3U,
            .end = chunk_number * (size_t)3U + (size_t)3U
          }
        ));
    uint32_t
    random_bits_as_u24 =
      ((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U;
    uint32_t first_bits = random_bits_as_u24 & 2396745U;
    uint32_t second_bits = random_bits_as_u24 >> 1U & 2396745U;
    uint32_t third_bits = random_bits_as_u24 >> 2U & 2396745U;
    uint32_t coin_toss_outcomes = first_bits + second_bits + third_bits;
    for (int32_t i = 0; i < 24 / 6; i++)
    {
      int32_t outcome_set = i;
      int32_t outcome_set0 = outcome_set * 6;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 7U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 3) & 7U);
      size_t offset = (size_t)(outcome_set0 / 6);
      sampled_i16s.data[(size_t)4U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_84(Eurydice_array_to_slice_mut_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- ETA= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_16(Eurydice_mut_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_2_84(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_7
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_7_84(Eurydice_arr_13 *re)
{
  size_t step = LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT / (size_t)2U;
  for (size_t i = (size_t)0U; i < step; i++)
  {
    size_t j = i;
    __m256i t = libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(re->data[j + step], -1600);
    re->data[j + step] = libcrux_ml_kem_vector_avx2_sub_f5(re->data[j], &t);
    re->data[j] = libcrux_ml_kem_vector_avx2_add_f5(re->data[j], &t);
  }
}

typedef struct libcrux_ml_kem_vector_avx2_SIMD256Vector_x2_s
{
  __m256i fst;
  __m256i snd;
}
libcrux_ml_kem_vector_avx2_SIMD256Vector_x2;

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_layer_int_vec_step
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
ntt_layer_int_vec_step_84(__m256i a, __m256i b, int16_t zeta_r)
{
  __m256i t = libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(b, zeta_r);
  b = libcrux_ml_kem_vector_avx2_sub_f5(a, &t);
  a = libcrux_ml_kem_vector_avx2_add_f5(a, &t);
  return (KRML_CLITERAL(libcrux_ml_kem_vector_avx2_SIMD256Vector_x2){ .fst = a, .snd = b });
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
ntt_at_layer_4_plus_84(size_t *zeta_i, Eurydice_arr_13 *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]++;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / (size_t)16U;
    size_t step_vec = step / (size_t)16U;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
      uu____0 =
        ntt_layer_int_vec_step_84(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      __m256i x = uu____0.fst;
      __m256i y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_3_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U])););
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_2_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U));
    zeta_i[0U]++;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_1_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)3U));
    zeta_i[0U] += (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_84(Eurydice_arr_13 *myself)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(myself->data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_d6_84(Eurydice_arr_13 *self)
{
  poly_barrett_reduce_84(self);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_binomially_sampled_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void ntt_binomially_sampled_ring_element_84(Eurydice_arr_13 *re)
{
  ntt_at_layer_7_84(re);
  size_t zeta_i = (size_t)1U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d61(
  Eurydice_arr_60 *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_41_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_73_ab1(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two `KyberPolynomialRingElement`s in their NTT representations,
 compute their product. Given two polynomials in the NTT domain `f^` and `ĵ`,
 the `iᵗʰ` coefficient of the product `k̂` is determined by the calculation:

 ```plaintext
 ĥ[2·i] + ĥ[2·i + 1]X = (f^[2·i] + f^[2·i + 1]X)·(ĝ[2·i] + ĝ[2·i + 1]X) mod (X² - ζ^(2·BitRev₇(i) + 1))
 ```

 This function almost implements <strong>Algorithm 10</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input: Two arrays fˆ ∈ ℤ₂₅₆ and ĝ ∈ ℤ₂₅₆.
 Output: An array ĥ ∈ ℤq.

 for(i ← 0; i < 128; i++)
     (ĥ[2i], ĥ[2i+1]) ← BaseCaseMultiply(fˆ[2i], fˆ[2i+1], ĝ[2i], ĝ[2i+1], ζ^(2·BitRev₇(i) + 1))
 end for
 return ĥ
 ```
 We say "almost" because the coefficients of the ring element output by
 this function are in the Montgomery domain.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
ntt_multiply_84(Eurydice_arr_13 *myself, Eurydice_arr_13 *rhs)
{
  Eurydice_arr_13 out = ZERO_84();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    out.data[i0] =
      libcrux_ml_kem_vector_avx2_ntt_multiply_f5(&myself->data[i0],
        &rhs->data[i0],
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)3U));
  }
  return out;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
ntt_multiply_d6_84(Eurydice_arr_13 *self, Eurydice_arr_13 *rhs)
{
  return ntt_multiply_84(self, rhs);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_e3(Eurydice_arr_13 *myself, Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_e3(Eurydice_arr_13 *self, Eurydice_arr_13 *rhs)
{
  add_to_ring_element_e3(self, rhs);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.to_standard_domain
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE __m256i to_standard_domain_84(__m256i vector)
{
  return
    libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(vector,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_84(Eurydice_arr_13 *myself, Eurydice_arr_13 *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    __m256i coefficient_normal_form = to_standard_domain_84(myself->data[j]);
    __m256i sum = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &error->data[j]);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_d6_84(Eurydice_arr_13 *self, Eurydice_arr_13 *error)
{
  add_standard_error_reduce_84(self, error);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
compute_As_plus_e_e3(
  Eurydice_arr_60 *t_as_ntt,
  Eurydice_arr_ea *matrix_A,
  Eurydice_arr_60 *s_as_ntt,
  Eurydice_arr_60 *error_as_ntt
)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_60 *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR3(i1,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_e3(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab1(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_60 *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_b6(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_ea *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_281(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d61(private_key, &prf_input, 0U);
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab1(&lvalue););
  Eurydice_arr_60 error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d61(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_e3(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_b4_e3(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_60 call_mut_22_e3(void **_)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_e3(&lvalue););
  return arr_struct;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.clone_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static inline Eurydice_arr_13 clone_c1_84(Eurydice_arr_13 *self)
{
  return
    core_array__core__clone__Clone_for__T__N___clone((size_t)16U,
      self,
      __m256i,
      Eurydice_arr_13);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_ea transpose_a_e3(Eurydice_arr_ea ind_cpa_a)
{
  Eurydice_arr_ea arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_e3(&lvalue););
  Eurydice_arr_ea A = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db1(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab1(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_ea A = transpose_a_e3(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_5f
  pk_serialized =
    serialize_public_key_79(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_78(Eurydice_array_to_slice_mut_ff(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static Eurydice_arr_c7
encaps_prepare_b6(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_78(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_60, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_7f_s
{
  Eurydice_arr_60 fst;
  Eurydice_arr_13 snd;
}
tuple_7f;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_781(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_781(void **_)
{
  return ZERO_d6_84();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d61(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_60 *error_1
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_41_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF
with const generics
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_ec(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_89 digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 3
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_3b0(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_a8_e3(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_1_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)3U));
    zeta_i[0U] -= (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_2_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U));
    zeta_i[0U]--;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_3
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_3_84(size_t *zeta_i, Eurydice_arr_13 *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U])););
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.inv_ntt_layer_int_vec_step_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
inv_ntt_layer_int_vec_step_reduce_84(__m256i a, __m256i b, int16_t zeta_r)
{
  __m256i a_minus_b = libcrux_ml_kem_vector_avx2_sub_f5(b, &a);
  a = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(libcrux_ml_kem_vector_avx2_add_f5(a, &b));
  b = libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(a_minus_b, zeta_r);
  return (KRML_CLITERAL(libcrux_ml_kem_vector_avx2_SIMD256Vector_x2){ .fst = a, .snd = b });
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
invert_ntt_at_layer_4_plus_84(size_t *zeta_i, Eurydice_arr_13 *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]--;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    size_t step_vec = step / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_avx2_SIMD256Vector_x2
      uu____0 =
        inv_ntt_layer_int_vec_step_reduce_84(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      __m256i x = uu____0.fst;
      __m256i y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_e3(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_84(Eurydice_arr_13 *myself, Eurydice_arr_13 *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(myself->data[j],
        1441);
    __m256i sum = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &error->data[j]);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_d6_84(Eurydice_arr_13 *self, Eurydice_arr_13 *error)
{
  add_error_reduce_84(self, error);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60
compute_vector_u_e3(
  Eurydice_arr_ea *a_as_ntt,
  Eurydice_arr_60 *r_as_ntt,
  Eurydice_arr_60 *error_1
)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_e3(&lvalue););
  Eurydice_arr_60 result = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_60 *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_e3(&result.data[i1], &product););
    invert_ntt_montgomery_e3(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_ef(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)10) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(10, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(10, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_ef(__m256i vector)
{
  return compress_ciphertext_coefficient_ef(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i compress_f5_ef(__m256i vector)
{
  return compress_ef(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_10
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0 compress_then_serialize_10_03(Eurydice_arr_13 *re)
{
  Eurydice_arr_b0 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = compress_f5_ef(to_unsigned_field_modulus_84(re->data[i0]));
    Eurydice_arr_fc bytes = libcrux_ml_kem_vector_avx2_serialize_10_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)20U * i0,
            .end = (size_t)20U * i0 + (size_t)20U
          }
        )),
      Eurydice_array_to_slice_mut_8f(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_c4(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)11) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(11, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(11, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_c4(__m256i vector)
{
  return compress_ciphertext_coefficient_c4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i compress_f5_c4(__m256i vector)
{
  return compress_c4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 10
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0
compress_then_serialize_ring_element_u_81(Eurydice_arr_13 *re)
{
  return compress_then_serialize_10_03(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- OUT_LEN= 960
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_d4(Eurydice_arr_60 input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)960U / (size_t)3U),
            .end = (i0 + (size_t)1U) * ((size_t)960U / (size_t)3U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_81(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_7f
encrypt_c1_781(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_ea *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_60 arr_struct0;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_781(&lvalue););
  Eurydice_arr_60 r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d61(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_781(&lvalue););
  Eurydice_arr_60 error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_d61(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_3b0(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_60 u = compute_vector_u_e3(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_d4(u, ciphertext);
  return (KRML_CLITERAL(tuple_7f){ .fst = r_as_ntt, .snd = error_2 });
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_message_84(Eurydice_arr_ec *serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    __m256i
    coefficient_compressed =
      libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_array_to_subslice_mut_d44(serialized,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = (size_t)2U * i0,
              .end = (size_t)2U * i0 + (size_t)2U
            }
          )));
    re.data[i0] = libcrux_ml_kem_vector_avx2_decompress_1_f5(coefficient_compressed););
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
add_message_error_reduce_84(
  Eurydice_arr_13 *myself,
  Eurydice_arr_13 *message,
  Eurydice_arr_13 result
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(result.data[i0],
        1441);
    __m256i sum1 = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &message->data[i0]);
    __m256i sum2 = libcrux_ml_kem_vector_avx2_add_f5(coefficient_normal_form, &sum1);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(sum2);
    result.data[i0] = red;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
add_message_error_reduce_d6_84(
  Eurydice_arr_13 *self,
  Eurydice_arr_13 *message,
  Eurydice_arr_13 result
)
{
  return add_message_error_reduce_84(self, message, result);
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_e3(
  Eurydice_arr_60 *t_as_ntt,
  Eurydice_arr_60 *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_e3(&result, &product););
  invert_ntt_montgomery_e3(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_d1(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)4) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(4, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(4, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_d1(__m256i vector)
{
  return compress_ciphertext_coefficient_d1(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i compress_f5_d1(__m256i vector)
{
  return compress_d1(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_4_84(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i coefficient = compress_f5_d1(to_unsigned_field_modulus_84(re.data[i0]));
    Eurydice_array_u8x8 bytes = libcrux_ml_kem_vector_avx2_serialize_4_f5(coefficient);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)8U * i0,
            .end = (size_t)8U * i0 + (size_t)8U
          }
        )),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.compress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_ciphertext_coefficient_f4(__m256i vector)
{
  __m256i
  field_modulus_halved =
    mm256_set1_epi32(((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS - 1) / 2);
  __m256i compression_factor = mm256_set1_epi32(10321340);
  __m256i coefficient_bits_mask = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)5) - 1);
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i compressed_low = mm256_slli_epi32(5, coefficients_low0, __m256i);
  __m256i compressed_low0 = mm256_add_epi32(compressed_low, field_modulus_halved);
  __m256i
  compressed_low1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_low0,
      compression_factor);
  __m256i compressed_low2 = mm256_srli_epi32(3, compressed_low1, __m256i);
  __m256i compressed_low3 = mm256_and_si256(compressed_low2, coefficient_bits_mask);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i compressed_high = mm256_slli_epi32(5, coefficients_high0, __m256i);
  __m256i compressed_high0 = mm256_add_epi32(compressed_high, field_modulus_halved);
  __m256i
  compressed_high1 =
    libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(compressed_high0,
      compression_factor);
  __m256i compressed_high2 = mm256_srli_epi32(3, compressed_high1, __m256i);
  __m256i compressed_high3 = mm256_and_si256(compressed_high2, coefficient_bits_mask);
  __m256i compressed = mm256_packs_epi32(compressed_low3, compressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_f4(__m256i vector)
{
  return compress_ciphertext_coefficient_f4(vector);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress_f5
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i compress_f5_f4(__m256i vector)
{
  return compress_f4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_5
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_5_84(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficients =
      compress_f5_f4(libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(re.data[i0]));
    Eurydice_arr_6d bytes = libcrux_ml_kem_vector_avx2_serialize_5_f5(coefficients);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)10U * i0,
            .end = (size_t)10U * i0 + (size_t)10U
          }
        )),
      Eurydice_array_to_slice_mut_30(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_15(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_15(
  Eurydice_arr_60 *t_as_ntt,
  Eurydice_arr_60 *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_e3(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_15(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_unpacked_281(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_2b ciphertext = { .data = { 0U } };
  tuple_7f
  uu____0 =
    encrypt_c1_781(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d415(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)960U })));
  Eurydice_arr_60 r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_15(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f2(&ciphertext, (size_t)960U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a81(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_ef *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_b6(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_unpacked_281(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_f4){
        .fst = libcrux_ml_kem_types_from_19_52(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_13 call_mut_35_15(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_ef(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)10));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(10, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(10, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_ef(__m256i vector)
{
  return decompress_ciphertext_coefficient_ef(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_10
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_10_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)20U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)20U,
            .end = i0 * (size_t)20U + (size_t)20U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_10_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_ef(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_c4(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)11));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(11, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(11, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_c4(__m256i vector)
{
  return decompress_ciphertext_coefficient_c4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_11_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)22U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)22U,
            .end = i0 * (size_t)22U + (size_t)22U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_11_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_c4(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_u_d0(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_10_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE void ntt_vector_u_d0(Eurydice_arr_13 *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_60
deserialize_then_decompress_u_15(Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_15(&lvalue););
  Eurydice_arr_60 u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1088U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d415(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_d0(u_bytes);
    ntt_vector_u_d0(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_d1(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)4));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(4, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(4, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_d1(__m256i vector)
{
  return decompress_ciphertext_coefficient_d1(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_4_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)8U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)8U,
            .end = i0 * (size_t)8U + (size_t)8U
          }
        ));
    __m256i coefficient = libcrux_ml_kem_vector_avx2_deserialize_4_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_d1(coefficient);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f4(__m256i vector)
{
  __m256i field_modulus = mm256_set1_epi32((int32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  __m256i two_pow_coefficient_bits = mm256_set1_epi32((int32_t)((uint32_t)1 << (uint32_t)5));
  __m128i coefficients_low = mm256_castsi256_si128(vector);
  __m256i coefficients_low0 = mm256_cvtepi16_epi32(coefficients_low);
  __m256i decompressed_low = mm256_mullo_epi32(coefficients_low0, field_modulus);
  __m256i decompressed_low0 = mm256_slli_epi32(1, decompressed_low, __m256i);
  __m256i decompressed_low1 = mm256_add_epi32(decompressed_low0, two_pow_coefficient_bits);
  __m256i decompressed_low2 = mm256_srli_epi32(5, decompressed_low1, __m256i);
  __m256i decompressed_low3 = mm256_srli_epi32(1, decompressed_low2, __m256i);
  __m128i coefficients_high = mm256_extracti128_si256(1, vector, __m128i);
  __m256i coefficients_high0 = mm256_cvtepi16_epi32(coefficients_high);
  __m256i decompressed_high = mm256_mullo_epi32(coefficients_high0, field_modulus);
  __m256i decompressed_high0 = mm256_slli_epi32(1, decompressed_high, __m256i);
  __m256i decompressed_high1 = mm256_add_epi32(decompressed_high0, two_pow_coefficient_bits);
  __m256i decompressed_high2 = mm256_srli_epi32(5, decompressed_high1, __m256i);
  __m256i decompressed_high3 = mm256_srli_epi32(1, decompressed_high2, __m256i);
  __m256i compressed = mm256_packs_epi32(decompressed_low3, decompressed_high3);
  return mm256_permute4x64_epi64(216, compressed, __m256i);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.avx2.decompress_ciphertext_coefficient_f5
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE __m256i decompress_ciphertext_coefficient_f5_f4(__m256i vector)
{
  return decompress_ciphertext_coefficient_f4(vector);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_5
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_5_84(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_13 re = ZERO_d6_84();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)10U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)10U,
            .end = i0 * (size_t)10U + (size_t)10U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_avx2_deserialize_5_f5(bytes);
    re.data[i0] = decompress_ciphertext_coefficient_f5_f4(re.data[i0]);
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_79(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
subtract_reduce_84(Eurydice_arr_13 *myself, Eurydice_arr_13 b)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient_normal_form =
      libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(b.data[i0],
        1441);
    __m256i diff = libcrux_ml_kem_vector_avx2_sub_f5(myself->data[i0], &coefficient_normal_form);
    __m256i red = libcrux_ml_kem_vector_avx2_barrett_reduce_f5(diff);
    b.data[i0] = red;
  }
  return b;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_13
subtract_reduce_d6_84(Eurydice_arr_13 *self, Eurydice_arr_13 b)
{
  return subtract_reduce_84(self, b);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_e3(
  Eurydice_arr_13 *v,
  Eurydice_arr_60 *secret_as_ntt,
  Eurydice_arr_60 *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_e3(&result, &product););
  invert_ntt_montgomery_e3(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_ec compress_then_serialize_message_84(Eurydice_arr_13 re)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    __m256i coefficient = to_unsigned_field_modulus_84(re.data[i0]);
    __m256i coefficient_compressed = libcrux_ml_kem_vector_avx2_compress_1_f5(coefficient);
    Eurydice_array_u8x2 bytes = libcrux_ml_kem_vector_avx2_serialize_1_f5(coefficient_compressed);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)2U * i0,
            .end = (size_t)2U * i0 + (size_t)2U
          }
        )),
      Eurydice_array_to_slice_mut_82(&bytes),
      uint8_t););
  return serialized;
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_3e(Eurydice_arr_60 *secret_key, Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 u_as_ntt = deserialize_then_decompress_u_15(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_79(Eurydice_array_to_subslice_from_mut_5f2(ciphertext,
        (size_t)960U));
  Eurydice_arr_13 message = compute_message_e3(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF
with const generics
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_ce(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 3
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_3b(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d91(
  libcrux_ml_kem_mlkem768_avx2_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_3e(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_66(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f3(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_3b(Eurydice_array_to_slice_mut_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext =
    encrypt_unpacked_281(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_06(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static Eurydice_arr_13 call_mut_0b_e3(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_60
deserialize_ring_elements_reduced_out_e3(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_e3(&lvalue););
  Eurydice_arr_60 deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_e3(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_79(Eurydice_arr_5f *public_key)
{
  Eurydice_arr_60
  deserialized_pk =
    deserialize_ring_elements_reduced_out_e3(Eurydice_array_to_subslice_to_mut_211(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_79(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f4(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  return Eurydice_array_eq((size_t)1184U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_a4(Eurydice_arr_7d *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_78(Eurydice_array_to_subslice_mut_d418(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)3U,
            .end = (size_t)768U * (size_t)3U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d418(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)3U + (size_t)32U,
          .end = (size_t)768U * (size_t)3U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d50(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_a4(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair768
generate_keypair_cc1(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_60 private_key = default_70_e3();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef public_key = default_8b_e3();
  generate_keypair_unpacked_ab1(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_15(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_a4(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_78(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE Eurydice_arr_7d
serialize_kem_secret_key_a4(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_7d out = { .data = { 0U } };
  serialize_kem_secret_key_mut_a4(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db1(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 = generate_keypair_cc1(ind_cpa_keypair_randomness);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f public_key = uu____0.snd;
  Eurydice_arr_7d
  secret_key_serialized =
    serialize_kem_secret_key_a4(Eurydice_array_to_slice_mut_f4(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_ff(&public_key),
      implicit_rejection_value);
  Eurydice_arr_7d private_key = libcrux_ml_kem_types_from_b2_79(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_bc(private_key,
      libcrux_ml_kem_types_from_51_3d(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_b6(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_911(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_e3(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1152U);
  Eurydice_arr_ea *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_281(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
build_unpacked_public_key_911(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  unpacked_public_key = default_8b_e3();
  build_unpacked_public_key_mut_911(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_281(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_ef
  unpacked_public_key = build_unpacked_public_key_911(public_key);
  return encrypt_unpacked_281(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_a4(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_a11(
  Eurydice_arr_5f *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_b6(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_78(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_281(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_2b uu____2 = libcrux_ml_kem_types_from_19_52(ciphertext);
  return (KRML_CLITERAL(tuple_f4){ .fst = uu____2, .snd = kdf_39_a4(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_13 call_mut_0b_3e(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_3e(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_60 arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_3e(&lvalue););
  Eurydice_arr_60 secret_key_unpacked = arr_struct;
  deserialize_vector_e3(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_3e(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_661(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_mut_51(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_3e(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_78(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af to_hash = libcrux_ml_kem_utils_into_padded_array_66(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f3(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_3b(Eurydice_array_to_slice_mut_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext = encrypt_281(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_a4(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_a4(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_06(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_5b(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_3b *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40 shake128_init_absorb_final_23(Eurydice_arr_56 *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_mut_e9(input->data),
    Eurydice_array_to_slice_mut_e9(&input->data[1U]),
    Eurydice_array_to_slice_mut_e9(&input->data[2U]),
    Eurydice_array_to_slice_mut_e9(&input->data[3U]));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_23(Eurydice_arr_56 *input)
{
  return shake128_init_absorb_final_23(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_7c0
shake128_squeeze_first_three_blocks_23(Eurydice_arr_c40 *st)
{
  Eurydice_arr_7c0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_7c0
shake128_squeeze_first_three_blocks_41_23(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_74(
  Eurydice_arr_7c0 *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9c shake128_squeeze_next_block_23(Eurydice_arr_c40 *st)
{
  Eurydice_arr_9c
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9c
shake128_squeeze_next_block_41_23(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_740(
  Eurydice_arr_9c *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0a_280(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b sample_from_xof_280(Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_23(seeds);
  Eurydice_arr_7c0 randomness0 = shake128_squeeze_first_three_blocks_41_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_74(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c randomness = shake128_squeeze_next_block_41_23(&xof_state);
      done = sample_from_uniform_distribution_next_740(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_3b arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_280(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_280(Eurydice_arr_cd *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_3b sampled = sample_from_xof_280(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_23(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a0(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_212(public_key, (size_t)1536U);
  deserialize_ring_elements_reduced_5b(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f5(public_key,
        (size_t)1536U));
  Eurydice_arr_cd *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f5(public_key,
        (size_t)1536U));
  sample_matrix_A_280(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_23(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
serialize_vector_5b(Eurydice_arr_3b *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_74(
  Eurydice_arr_3b *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_d1 *serialized
)
{
  serialize_vector_5b(t_as_ntt,
    Eurydice_array_to_subslice_mut_d419(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f5(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self,
  Eurydice_arr_d1 *serialized
)
{
  serialize_public_key_mut_74(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_74(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_74(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialize_public_key_74(Eurydice_arr_3b *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_d1 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_74(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialized_dd_74(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *self)
{
  return
    libcrux_ml_kem_types_from_51_d9(serialize_public_key_74(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_74(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  return serialized_dd_74(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair1024
serialize_unpacked_secret_key_72(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_3b *private_key
)
{
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_74(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_df secret_key_serialized = { .data = { 0U } };
  serialize_vector_5b(private_key, Eurydice_array_to_slice_mut_2f(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair1024){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 =
    serialize_unpacked_secret_key_72(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(Eurydice_array_to_slice_mut_2f(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_b50(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_f8(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  Eurydice_arr_a8 sk = libcrux_ml_kem_types_default_d3_0e();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_f8(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_vector_5b(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_3b *secret_as_ntt)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0a_7e0(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b sample_from_xof_7e0(Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_4a
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(seeds);
  Eurydice_arr_7c0
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_74(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(&xof_state);
      done = sample_from_uniform_distribution_next_740(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_3b arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e0(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e0(Eurydice_arr_cd *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_3b sampled = sample_from_xof_7e0(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_100(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_5b(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1536U);
  Eurydice_arr_cd *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e0(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_b2(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_mut_68(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_5b(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_100(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)1536U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_3b default_70_5b(void)
{
  Eurydice_arr_3b lit;
  Eurydice_arr_13 repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 default_8b_5b(void)
{
  Eurydice_arr_3b uu____0;
  Eurydice_arr_13 repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_3b repeat_expression1[4U];
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    Eurydice_arr_3b lit;
    Eurydice_arr_13 repeat_expression[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_3b));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4
libcrux_ml_kem_ind_cca_unpacked_default_30_5b(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4){
        .ind_cpa_public_key = default_8b_5b(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_5b(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_d4
  uu____0 =
    { .ind_cpa_private_key = default_70_5b(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_5b()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_23(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_39(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)4U;
  return G_41_23(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_3b0 PRFxN_f5(Eurydice_arr_890 *input)
{
  Eurydice_arr_3b0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(&input->data[1U]),
    Eurydice_array_to_slice_mut_b5(&input->data[2U]),
    Eurydice_array_to_slice_mut_b5(&input->data[3U]),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  out.data[2U] = out2;
  out.data[3U] = out3;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_3b0 PRFxN_41_f5(Eurydice_arr_890 *input)
{
  return PRFxN_f5(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d60(
  Eurydice_arr_3b *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_41_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_73_ab0(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_5b(Eurydice_arr_13 *myself, Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_5b(Eurydice_arr_13 *self, Eurydice_arr_13 *rhs)
{
  add_to_ring_element_5b(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
compute_As_plus_e_5b(
  Eurydice_arr_3b *t_as_ntt,
  Eurydice_arr_cd *matrix_A,
  Eurydice_arr_3b *s_as_ntt,
  Eurydice_arr_3b *error_as_ntt
)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_3b *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR4(i1,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_5b(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab0(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_3b *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_39(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_cd *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_280(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d60(private_key, &prf_input, 0U);
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab0(&lvalue););
  Eurydice_arr_3b error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d60(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_5b(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_b4_5b(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_3b call_mut_22_5b(void **_)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_5b(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_cd transpose_a_5b(Eurydice_arr_cd ind_cpa_a)
{
  Eurydice_arr_cd arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_5b(&lvalue););
  Eurydice_arr_cd A = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db0(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab0(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_cd A = transpose_a_5b(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_d1
  pk_serialized =
    serialize_public_key_74(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_23(Eurydice_array_to_slice_mut_b50(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static Eurydice_arr_c7
encaps_prepare_39(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_23(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_3b, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_03_s
{
  Eurydice_arr_3b fst;
  Eurydice_arr_13 snd;
}
tuple_03;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_780(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_780(void **_)
{
  return ZERO_d6_84();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d60(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_3b *error_1
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_41_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 4
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_f50(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_a8_5b(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_5b(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b
compute_vector_u_5b(
  Eurydice_arr_cd *a_as_ntt,
  Eurydice_arr_3b *r_as_ntt,
  Eurydice_arr_3b *error_1
)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_5b(&lvalue););
  Eurydice_arr_3b result = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_3b *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_5b(&result.data[i1], &product););
    invert_ntt_montgomery_5b(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7 compress_then_serialize_11_fe(Eurydice_arr_13 *re)
{
  Eurydice_arr_e7 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    __m256i
    coefficient =
      compress_f5_c4(libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(re->data[i0]));
    Eurydice_arr_80 bytes = libcrux_ml_kem_vector_avx2_serialize_11_f5(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d421(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)22U * i0,
            .end = (size_t)22U * i0 + (size_t)22U
          }
        )),
      Eurydice_array_to_slice_mut_98(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 11
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7
compress_then_serialize_ring_element_u_d4(Eurydice_arr_13 *re)
{
  return compress_then_serialize_11_fe(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- OUT_LEN= 1408
- COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_f8(Eurydice_arr_3b input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)1408U / (size_t)4U),
            .end = (i0 + (size_t)1U) * ((size_t)1408U / (size_t)4U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_e7 lvalue = compress_then_serialize_ring_element_u_d4(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_25(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_03
encrypt_c1_780(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_cd *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_3b arr_struct0;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_780(&lvalue););
  Eurydice_arr_3b r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d60(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_780(&lvalue););
  Eurydice_arr_3b error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_d60(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_f50(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_3b u = compute_vector_u_5b(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_f8(u, ciphertext);
  return (KRML_CLITERAL(tuple_03){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_5b(
  Eurydice_arr_3b *t_as_ntt,
  Eurydice_arr_3b *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_5b(&result, &product););
  invert_ntt_montgomery_5b(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
- OUT_LEN= 160
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_72(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_5_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- V_COMPRESSION_FACTOR= 5
- C2_LEN= 160
*/
static KRML_MUSTINLINE void
encrypt_c2_72(
  Eurydice_arr_3b *t_as_ntt,
  Eurydice_arr_3b *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_5b(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_72(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_unpacked_280(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d1 ciphertext = { .data = { 0U } };
  tuple_03
  uu____0 =
    encrypt_c1_780(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d419(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)1408U })));
  Eurydice_arr_3b r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_72(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f5(&ciphertext, (size_t)1408U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a80(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_d4 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_39(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_unpacked_280(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_25){
        .fst = libcrux_ml_kem_types_from_19_d9(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static Eurydice_arr_13 call_mut_35_72(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_u_95(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_11_84(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE void ntt_vector_u_95(Eurydice_arr_13 *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_84(&zeta_i, re);
  ntt_at_layer_2_84(&zeta_i, re);
  ntt_at_layer_1_84(&zeta_i, re);
  poly_barrett_reduce_d6_84(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_3b
deserialize_then_decompress_u_72(Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_72(&lvalue););
  Eurydice_arr_3b u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1568U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d419(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_95(u_bytes);
    ntt_vector_u_95(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_74(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_5_84(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_5b(
  Eurydice_arr_13 *v,
  Eurydice_arr_3b *secret_as_ntt,
  Eurydice_arr_3b *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_5b(&result, &product););
  invert_ntt_montgomery_5b(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_b2(Eurydice_arr_3b *secret_key, Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b u_as_ntt = deserialize_then_decompress_u_72(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_74(Eurydice_array_to_subslice_from_mut_5f5(ciphertext,
        (size_t)1408U));
  Eurydice_arr_13 message = compute_message_5b(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 4
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_f5(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d90(
  libcrux_ml_kem_mlkem1024_avx2_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_b2(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_49(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f6(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_f5(Eurydice_array_to_slice_mut_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext =
    encrypt_unpacked_280(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_b50(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static Eurydice_arr_13 call_mut_0b_5b(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_3b
deserialize_ring_elements_reduced_out_5b(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_5b(&lvalue););
  Eurydice_arr_3b deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_5b(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_74(Eurydice_arr_d1 *public_key)
{
  Eurydice_arr_3b
  deserialized_pk =
    deserialize_ring_elements_reduced_out_5b(Eurydice_array_to_subslice_to_mut_212(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_74(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f5(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  return Eurydice_array_eq((size_t)1568U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_f8(Eurydice_arr_a8 *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_23(Eurydice_array_to_subslice_mut_d422(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)4U,
            .end = (size_t)768U * (size_t)4U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d422(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)4U + (size_t)32U,
          .end = (size_t)768U * (size_t)4U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_b3(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_f8(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair1024
generate_keypair_cc0(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_3b private_key = default_70_5b();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 public_key = default_8b_5b();
  generate_keypair_unpacked_ab0(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_72(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_f8(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_23(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE Eurydice_arr_a8
serialize_kem_secret_key_f8(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_a8 out = { .data = { 0U } };
  serialize_kem_secret_key_mut_f8(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_db0(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 = generate_keypair_cc0(ind_cpa_keypair_randomness);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 public_key = uu____0.snd;
  Eurydice_arr_a8
  secret_key_serialized =
    serialize_kem_secret_key_f8(Eurydice_array_to_slice_mut_2f(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_b50(&public_key),
      implicit_rejection_value);
  Eurydice_arr_a8 private_key = libcrux_ml_kem_types_from_b2_0e(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_70(private_key,
      libcrux_ml_kem_types_from_51_d9(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_39(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_910(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_5b(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1536U);
  Eurydice_arr_cd *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_280(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
build_unpacked_public_key_910(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
  unpacked_public_key = default_8b_5b();
  build_unpacked_public_key_mut_910(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_280(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_d4
  unpacked_public_key = build_unpacked_public_key_910(public_key);
  return encrypt_unpacked_280(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_f8(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_a10(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_39(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_23(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_280(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d1 uu____2 = libcrux_ml_kem_types_from_19_d9(ciphertext);
  return (KRML_CLITERAL(tuple_25){ .fst = uu____2, .snd = kdf_39_f8(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static Eurydice_arr_13 call_mut_0b_b2(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_b2(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_3b arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_b2(&lvalue););
  Eurydice_arr_3b secret_key_unpacked = arr_struct;
  deserialize_vector_5b(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_b2(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_660(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_mut_68(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_b2(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_23(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14 to_hash = libcrux_ml_kem_utils_into_padded_array_49(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f6(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_f5(Eurydice_array_to_slice_mut_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext = encrypt_280(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_f8(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_f8(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_b50(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_16(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ee *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_13 uu____0 = deserialize_to_reduced_ring_element_84(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c40 shake128_init_absorb_final_af(Eurydice_arr_bf *input)
{
  Eurydice_arr_c40 state = libcrux_sha3_avx2_x4_incremental_init();
  libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(&state,
    Eurydice_array_to_slice_mut_e9(input->data),
    Eurydice_array_to_slice_mut_e9(&input->data[1U]),
    Eurydice_array_to_slice_mut_e9(input->data),
    Eurydice_array_to_slice_mut_e9(input->data));
  return state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_init_absorb_final_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c40
shake128_init_absorb_final_41_af(Eurydice_arr_bf *input)
{
  return shake128_init_absorb_final_af(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_b8
shake128_squeeze_first_three_blocks_af(Eurydice_arr_c40 *st)
{
  Eurydice_arr_b8 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_79 out0 = { .data = { 0U } };
  Eurydice_arr_79 out1 = { .data = { 0U } };
  Eurydice_arr_79 out2 = { .data = { 0U } };
  Eurydice_arr_79 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(st,
    Eurydice_array_to_slice_mut_48(&out0),
    Eurydice_array_to_slice_mut_48(&out1),
    Eurydice_array_to_slice_mut_48(&out2),
    Eurydice_array_to_slice_mut_48(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_first_three_blocks_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_b8
shake128_squeeze_first_three_blocks_41_af(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_first_three_blocks_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_ce(
  Eurydice_arr_b8 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_5b0 shake128_squeeze_next_block_af(Eurydice_arr_c40 *st)
{
  Eurydice_arr_5b0 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c5 out0 = { .data = { 0U } };
  Eurydice_arr_c5 out1 = { .data = { 0U } };
  Eurydice_arr_c5 out2 = { .data = { 0U } };
  Eurydice_arr_c5 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(st,
    Eurydice_array_to_slice_mut_2c(&out0),
    Eurydice_array_to_slice_mut_2c(&out1),
    Eurydice_array_to_slice_mut_2c(&out2),
    Eurydice_array_to_slice_mut_2c(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.shake128_squeeze_next_block_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_5b0
shake128_squeeze_next_block_41_af(Eurydice_arr_c40 *self)
{
  return shake128_squeeze_next_block_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_ce0(
  Eurydice_arr_5b0 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_avx2_rej_sample_f5(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0a_28(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee sample_from_xof_28(Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_c40 xof_state = shake128_init_absorb_final_41_af(seeds);
  Eurydice_arr_b8 randomness0 = shake128_squeeze_first_three_blocks_41_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_ce(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0 randomness = shake128_squeeze_next_block_41_af(&xof_state);
      done = sample_from_uniform_distribution_next_ce0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_ee arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_28(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_28(Eurydice_arr_e2 *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_ee sampled = sample_from_xof_28(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.H_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec H_41_af(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_2a(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_210(public_key, (size_t)768U);
  deserialize_ring_elements_reduced_16(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f1(public_key,
        (size_t)768U));
  Eurydice_arr_e2 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f1(public_key,
        (size_t)768U));
  sample_matrix_A_28(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_41_af(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
serialize_vector_16(Eurydice_arr_ee *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_84(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_ce(
  Eurydice_arr_ee *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_03 *serialized
)
{
  serialize_vector_16(t_as_ntt,
    Eurydice_array_to_subslice_mut_d48(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f1(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self,
  Eurydice_arr_03 *serialized
)
{
  serialize_public_key_mut_ce(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_ce(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_ce(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialize_public_key_ce(Eurydice_arr_ee *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_03 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_ce(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialized_dd_ce(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *self)
{
  return
    libcrux_ml_kem_types_from_51_df(serialize_public_key_ce(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_ce(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
)
{
  return serialized_dd_ce(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair512
serialize_unpacked_secret_key_e5(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ee *private_key
)
{
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_ce(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_d2 secret_key_serialized = { .data = { 0U } };
  serialize_vector_16(private_key, Eurydice_array_to_slice_mut_27(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair512){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 =
    serialize_unpacked_secret_key_e5(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(Eurydice_array_to_slice_mut_27(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_3b(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_4e(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *self
)
{
  Eurydice_arr_ab0 sk = libcrux_ml_kem_types_default_d3_be();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_4e(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_vector_16(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_ee *secret_as_ntt)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      deserialize_to_uncompressed_ring_element_84(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0a_7e(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_84(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee sample_from_xof_7e(Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_e3
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(seeds);
  Eurydice_arr_b8
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_ce(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(&xof_state);
      done = sample_from_uniform_distribution_next_ce0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_ee arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_7e(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_7e(Eurydice_arr_e2 *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_ee sampled = sample_from_xof_7e(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_10(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_16(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)768U);
  Eurydice_arr_e2 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_7e(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_a4(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_mut_99(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_16(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_10(ind_cpa_public_key, &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)768U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_ee default_70_16(void)
{
  Eurydice_arr_ee lit;
  Eurydice_arr_13 repeat_expression[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
  memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_13));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 default_8b_16(void)
{
  Eurydice_arr_ee uu____0;
  Eurydice_arr_13 repeat_expression0[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression0[i] = ZERO_d6_84(););
  memcpy(uu____0.data, repeat_expression0, (size_t)2U * sizeof (Eurydice_arr_13));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_ee repeat_expression1[2U];
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    Eurydice_arr_ee lit;
    Eurydice_arr_13 repeat_expression[2U];
    KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_84(););
    memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_13));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)2U * sizeof (Eurydice_arr_ee));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7
libcrux_ml_kem_ind_cca_unpacked_default_30_16(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7){
        .ind_cpa_public_key = default_8b_16(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_16(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_c7
  uu____0 =
    { .ind_cpa_private_key = default_70_16(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_16()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.G_41
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7 G_41_af(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_avx2_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_b1(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)2U;
  return G_41_af(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 2
- LEN= 192
*/
static KRML_MUSTINLINE Eurydice_arr_eb PRFxN_d5(Eurydice_arr_4d *input)
{
  Eurydice_arr_eb out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1c out0 = { .data = { 0U } };
  Eurydice_arr_1c out1 = { .data = { 0U } };
  Eurydice_arr_1c out2 = { .data = { 0U } };
  Eurydice_arr_1c out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(&input->data[1U]),
    Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_d9(&out0),
    Eurydice_array_to_slice_mut_d9(&out1),
    Eurydice_array_to_slice_mut_d9(&out2),
    Eurydice_array_to_slice_mut_d9(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 2
- LEN= 192
*/
static KRML_MUSTINLINE Eurydice_arr_eb PRFxN_41_d5(Eurydice_arr_4d *input)
{
  return PRFxN_d5(input);
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- ETA= 3
*/
static KRML_MUSTINLINE Eurydice_arr_13
sample_from_binomial_distribution_e3(Eurydice_mut_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_3_84(randomness);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- ETA= 3
- ETA_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_d6(
  Eurydice_arr_ee *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_eb prf_outputs = PRFxN_41_d5(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_e3(Eurydice_array_to_slice_mut_d9(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_84(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static Eurydice_arr_13 call_mut_73_ab(void **_)
{
  return ZERO_d6_84();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_16(Eurydice_arr_13 *myself, Eurydice_arr_13 *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    myself->data[i0] = libcrux_ml_kem_vector_avx2_add_f5(myself->data[i0], &rhs->data[i0]););
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_16(Eurydice_arr_13 *self, Eurydice_arr_13 *rhs)
{
  add_to_ring_element_16(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
compute_As_plus_e_16(
  Eurydice_arr_ee *t_as_ntt,
  Eurydice_arr_e2 *matrix_A,
  Eurydice_arr_ee *s_as_ntt,
  Eurydice_arr_ee *error_as_ntt
)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_ee *row = &matrix_A->data[i0];
    Eurydice_arr_13 uu____0 = ZERO_d6_84();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR2(i1,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_13 *matrix_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_16(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_84(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_ab(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_ee *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_b1(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_e2 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_28(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_d6(private_key, &prf_input, 0U);
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_ab(&lvalue););
  Eurydice_arr_ee error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_d6(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_16(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_b4_16(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_ee call_mut_22_16(void **_)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_16(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_e2 transpose_a_16(Eurydice_arr_e2 ind_cpa_a)
{
  Eurydice_arr_e2 arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_16(&lvalue););
  Eurydice_arr_e2 A = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 uu____0 = clone_c1_84(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_db(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_ab(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_e2 A = transpose_a_16(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_03
  pk_serialized =
    serialize_public_key_ce(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_41_af(Eurydice_array_to_slice_mut_3b(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static Eurydice_arr_c7
encaps_prepare_b1(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_41_af(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_ee, libcrux_ml_kem_polynomial_PolynomialRingElement_f6

*/
typedef struct tuple_91_s
{
  Eurydice_arr_ee fst;
  Eurydice_arr_13 snd;
}
tuple_91;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_f1_78(void **_)
{
  return ZERO_d6_84();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_13 call_mut_dd_78(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_f3 PRFxN_d50(Eurydice_arr_4d *input)
{
  Eurydice_arr_f3 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_89 out0 = { .data = { 0U } };
  Eurydice_arr_89 out1 = { .data = { 0U } };
  Eurydice_arr_89 out2 = { .data = { 0U } };
  Eurydice_arr_89 out3 = { .data = { 0U } };
  libcrux_sha3_avx2_x4_shake256(Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(&input->data[1U]),
    Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_b5(input->data),
    Eurydice_array_to_slice_mut_78(&out0),
    Eurydice_array_to_slice_mut_78(&out1),
    Eurydice_array_to_slice_mut_78(&out2),
    Eurydice_array_to_slice_mut_78(&out3));
  out.data[0U] = out0;
  out.data[1U] = out1;
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRFxN_41
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_f3 PRFxN_41_d50(Eurydice_arr_4d *input)
{
  return PRFxN_d50(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_d6(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_ee *error_1
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_f3 prf_outputs = PRFxN_41_d50(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13
    uu____0 =
      sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 2
- LEN= 128
*/
static KRML_MUSTINLINE Eurydice_arr_89 PRF_41_d50(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_a8_16(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_16(Eurydice_arr_13 *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_84(&zeta_i, re);
  invert_ntt_at_layer_2_84(&zeta_i, re);
  invert_ntt_at_layer_3_84(&zeta_i, re);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_84(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_84(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee
compute_vector_u_16(
  Eurydice_arr_e2 *a_as_ntt,
  Eurydice_arr_ee *r_as_ntt,
  Eurydice_arr_ee *error_1
)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_16(&lvalue););
  Eurydice_arr_ee result = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_ee *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_13 *a_element = &row->data[j];
      Eurydice_arr_13 product = ntt_multiply_d6_84(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_16(&result.data[i1], &product););
    invert_ntt_montgomery_16(&result.data[i1]);
    add_error_reduce_d6_84(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- OUT_LEN= 640
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_4e(Eurydice_arr_ee input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)640U / (size_t)2U),
            .end = (i0 + (size_t)1U) * ((size_t)640U / (size_t)2U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_81(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_91
encrypt_c1_78(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_e2 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_ee arr_struct0;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_78(&lvalue););
  Eurydice_arr_ee r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_d6(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_78(&lvalue););
  Eurydice_arr_ee error_1 = arr_struct;
  uint8_t domain_separator = sample_ring_element_cbd_d6(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_41_d50(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_13
  error_2 = sample_from_binomial_distribution_16(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_ee u = compute_vector_u_16(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_4e(u, ciphertext);
  return (KRML_CLITERAL(tuple_91){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_ring_element_v_16(
  Eurydice_arr_ee *t_as_ntt,
  Eurydice_arr_ee *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_13 *message
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_16(&result, &product););
  invert_ntt_montgomery_16(&result);
  return add_message_error_reduce_d6_84(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_e5(Eurydice_arr_13 re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_84(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_e5(
  Eurydice_arr_ee *t_as_ntt,
  Eurydice_arr_ee *r_as_ntt,
  Eurydice_arr_13 *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_13 message_as_ring_element = deserialize_then_decompress_message_84(message);
  Eurydice_arr_13
  v = compute_ring_element_v_16(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_e5(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_unpacked_28(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d2 ciphertext = { .data = { 0U } };
  tuple_91
  uu____0 =
    encrypt_c1_78(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d46(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)640U })));
  Eurydice_arr_ee r_as_ntt = uu____0.fst;
  Eurydice_arr_13 error_2 = uu____0.snd;
  encrypt_c2_e5(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f(&ciphertext, (size_t)640U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a8(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_c7 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_b1(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d2
  ciphertext = encrypt_unpacked_28(&public_key->ind_cpa_public_key, randomness, pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_ab){
        .fst = libcrux_ml_kem_types_from_19_80(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_13 call_mut_35_e5(void **_)
{
  return ZERO_d6_84();
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_ee
deserialize_then_decompress_u_e5(Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_e5(&lvalue););
  Eurydice_arr_ee u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)768U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d46(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_d0(u_bytes);
    ntt_vector_u_d0(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_13
deserialize_then_decompress_ring_element_v_ce(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_84(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_13
compute_message_16(
  Eurydice_arr_13 *v,
  Eurydice_arr_ee *secret_as_ntt,
  Eurydice_arr_ee *u_as_ntt
)
{
  Eurydice_arr_13 result = ZERO_d6_84();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_13 product = ntt_multiply_d6_84(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_16(&result, &product););
  invert_ntt_montgomery_16(&result);
  return subtract_reduce_d6_84(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_a4(Eurydice_arr_ee *secret_key, Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee u_as_ntt = deserialize_then_decompress_u_e5(ciphertext);
  Eurydice_arr_13
  v =
    deserialize_then_decompress_ring_element_v_ce(Eurydice_array_to_subslice_from_mut_5f(ciphertext,
        (size_t)640U));
  Eurydice_arr_13 message = compute_message_16(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_84(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::avx2::Simd256Hash}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.avx2.PRF_41
with const generics
- K= 2
- LEN= 32
*/
static KRML_MUSTINLINE Eurydice_arr_ec PRF_41_d5(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_d9(
  libcrux_ml_kem_mlkem512_avx2_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_a4(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_df(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f1(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_d5(Eurydice_array_to_slice_mut_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext =
    encrypt_unpacked_28(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_27(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static Eurydice_arr_13 call_mut_0b_16(void **_)
{
  return ZERO_d6_84();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ee
deserialize_ring_elements_reduced_out_16(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_16(&lvalue););
  Eurydice_arr_ee deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_16(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_ce(Eurydice_arr_03 *public_key)
{
  Eurydice_arr_ee
  deserialized_pk =
    deserialize_ring_elements_reduced_out_16(Eurydice_array_to_subslice_to_mut_210(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_ce(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f1(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  return Eurydice_array_eq((size_t)800U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_37(Eurydice_arr_ab0 *private_key)
{
  Eurydice_arr_ec
  t =
    H_41_af(Eurydice_array_to_subslice_mut_d414(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)2U,
            .end = (size_t)768U * (size_t)2U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d414(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)2U + (size_t)32U,
          .end = (size_t)768U * (size_t)2U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_85(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_37(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair512
generate_keypair_cc(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_ee private_key = default_70_16();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 public_key = default_8b_16();
  generate_keypair_unpacked_ab(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_e5(&public_key, &private_key);
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE void
serialize_kem_secret_key_mut_37(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_41_af(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE Eurydice_arr_ab0
serialize_kem_secret_key_37(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_ab0 out = { .data = { 0U } };
  serialize_kem_secret_key_mut_37(private_key, public_key, implicit_rejection_value, &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_db(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 = generate_keypair_cc(ind_cpa_keypair_randomness);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 public_key = uu____0.snd;
  Eurydice_arr_ab0
  secret_key_serialized =
    serialize_kem_secret_key_37(Eurydice_array_to_slice_mut_27(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_3b(&public_key),
      implicit_rejection_value);
  Eurydice_arr_ab0 private_key = libcrux_ml_kem_types_from_b2_be(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_d6(private_key,
      libcrux_ml_kem_types_from_51_df(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_b1(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_91(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_16(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)768U);
  Eurydice_arr_e2 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_28(uu____0, &lvalue, false);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
build_unpacked_public_key_91(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
  unpacked_public_key = default_8b_16();
  build_unpacked_public_key_mut_91(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_28(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_c7
  unpacked_public_key = build_unpacked_public_key_91(public_key);
  return encrypt_unpacked_28(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_avx2_Simd256Hash
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_37(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_a1(Eurydice_arr_03 *public_key, Eurydice_arr_ec *randomness)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_b1(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_41_af(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_28(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d2 uu____2 = libcrux_ml_kem_types_from_19_80(ciphertext);
  return (KRML_CLITERAL(tuple_ab){ .fst = uu____2, .snd = kdf_39_37(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_13 call_mut_0b_a4(void **_)
{
  return ZERO_d6_84();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_avx2_SIMD256Vector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_a4(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_ee arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_a4(&lvalue););
  Eurydice_arr_ee secret_key_unpacked = arr_struct;
  deserialize_vector_16(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_a4(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_avx2_SIMD256Vector, libcrux_ml_kem_hash_functions_avx2_Simd256Hash, libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_66(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_mut_99(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_a4(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_41_af(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03 to_hash = libcrux_ml_kem_utils_into_padded_array_df(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f1(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_41_d5(Eurydice_array_to_slice_mut_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext = encrypt_28(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_37(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_37(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_27(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem_avx2_H
#define libcrux_mlkem_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

#include "libcrux_sha3_avx2.h"
#include "libcrux_core.h"

Eurydice_arr_c7 libcrux_ml_kem_hash_functions_avx2_G(Eurydice_mut_borrow_slice_u8 input);

Eurydice_arr_ec libcrux_ml_kem_hash_functions_avx2_H(Eurydice_mut_borrow_slice_u8 input);

typedef libcrux_sha3_avx2_x4_incremental_KeccakState
libcrux_ml_kem_hash_functions_avx2_Simd256Hash;

typedef __m256i libcrux_ml_kem_vector_avx2_SIMD256Vector;

__m256i libcrux_ml_kem_vector_avx2_vec_zero(void);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_ZERO_f5(void);

__m256i libcrux_ml_kem_vector_avx2_vec_from_i16_array(Eurydice_mut_borrow_slice_i16 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_from_i16_array_f5(Eurydice_mut_borrow_slice_i16 array);

Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_vec_to_i16_array(__m256i v);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_avx2_to_i16_array_f5(__m256i x);

__m256i libcrux_ml_kem_vector_avx2_from_bytes(Eurydice_mut_borrow_slice_u8 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_from_bytes_f5(Eurydice_mut_borrow_slice_u8 array);

void libcrux_ml_kem_vector_avx2_to_bytes(__m256i x, Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
void libcrux_ml_kem_vector_avx2_to_bytes_f5(__m256i x, Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_add(__m256i lhs, __m256i rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_add_f5(__m256i lhs, __m256i *rhs);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_sub(__m256i lhs, __m256i rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_sub_f5(__m256i lhs, __m256i *rhs);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_multiply_by_constant(__m256i vector, int16_t constant);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_multiply_by_constant_f5(__m256i vec, int16_t c);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_cond_subtract_3329(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_cond_subtract_3329_f5(__m256i vector);

#define LIBCRUX_ML_KEM_VECTOR_AVX2_ARITHMETIC_BARRETT_MULTIPLIER (20159)

/**
 See Section 3.2 of the implementation notes document for an explanation
 of this code.
*/
__m256i libcrux_ml_kem_vector_avx2_arithmetic_barrett_reduce(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_barrett_reduce_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constant(
  __m256i vector,
  int16_t constant
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_montgomery_multiply_by_constant_f5(__m256i vector, int16_t constant);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_bitwise_and_with_constant(
  __m256i vector,
  int16_t constant
);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_to_unsigned_representative(__m256i a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_to_unsigned_representative_f5(__m256i a);

__m256i libcrux_ml_kem_vector_avx2_compress_compress_message_coefficient(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_compress_1(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_compress_1_f5(__m256i vector);

__m256i libcrux_ml_kem_vector_avx2_compress_mulhi_mm256_epi32(__m256i lhs, __m256i rhs);

__m256i libcrux_ml_kem_vector_avx2_compress_decompress_1(__m256i a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_decompress_1_f5(__m256i a);

__m256i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_by_constants(
  __m256i vec,
  __m256i constants
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_layer_2_step_f5(__m256i vector, int16_t zeta0, int16_t zeta1);

__m128i
libcrux_ml_kem_vector_avx2_arithmetic_montgomery_multiply_m128i_by_constants(
  __m128i vec,
  __m128i constants
);

__m256i libcrux_ml_kem_vector_avx2_ntt_ntt_layer_3_step(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_ntt_layer_3_step(__m256i vector, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_ntt_layer_3_step_f5(__m256i vector, int16_t zeta);

__m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_1_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_2_step(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
);

__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step(__m256i vector, int16_t zeta0, int16_t zeta1);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_inv_ntt_layer_2_step_f5(
  __m256i vector,
  int16_t zeta0,
  int16_t zeta1
);

__m256i libcrux_ml_kem_vector_avx2_ntt_inv_ntt_layer_3_step(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step(__m256i vector, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_inv_ntt_layer_3_step_f5(__m256i vector, int16_t zeta);

__m256i libcrux_ml_kem_vector_avx2_arithmetic_montgomery_reduce_i32s(__m256i vec);

__m256i
libcrux_ml_kem_vector_avx2_ntt_ntt_multiply(
  __m256i lhs,
  __m256i rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

__m256i
libcrux_ml_kem_vector_avx2_ntt_multiply(
  __m256i *lhs,
  __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i
libcrux_ml_kem_vector_avx2_ntt_multiply_f5(
  __m256i *lhs,
  __m256i *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_serialize_1(__m256i vector);

Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_avx2_serialize_1_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_i16s(int16_t a, int16_t b);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_1_deserialize_1_u8s(uint8_t a, uint8_t b);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_1(Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_1(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_1_f5(Eurydice_mut_borrow_slice_u8 bytes);

/**
 `mm256_concat_pairs_n(n, x)` is then a sequence of 32 bits packets
 of the shape `0b0…0b₁…bₙa₁…aₙ`, if `x` is a sequence of pairs of
 16 bits, of the shape `(0b0…0a₁…aₙ, 0b0…0b₁…bₙ)` (where the last
 `n` bits are non-zero).
*/
__m256i libcrux_ml_kem_vector_avx2_serialize_mm256_concat_pairs_n(uint8_t n, __m256i x);

Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_serialize_4(__m256i vector);

Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_avx2_serialize_4_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_i16s(
  int16_t b0,
  int16_t b1,
  int16_t b2,
  int16_t b3,
  int16_t b4,
  int16_t b5,
  int16_t b6,
  int16_t b7
);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_4_deserialize_4_u8s(
  uint8_t b0,
  uint8_t b1,
  uint8_t b2,
  uint8_t b3,
  uint8_t b4,
  uint8_t b5,
  uint8_t b6,
  uint8_t b7
);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_4_f5(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_serialize_5(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_avx2_serialize_5_f5(__m256i vector);

/**
 We cannot model `mm256_inserti128_si256` on its own: it produces a
 Vec256 where the upper 128 bits are undefined. Thus
 `mm256_inserti128_si256` is not pure.

 Luckily, we always call `mm256_castsi128_si256` right after
 `mm256_inserti128_si256`: this composition sets the upper bits,
 making the whole computation pure again.
*/
__m256i
libcrux_ml_kem_vector_avx2_serialize_mm256_si256_from_two_si128(__m128i lower, __m128i upper);

__m256i libcrux_ml_kem_vector_avx2_serialize_deserialize_5(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_5_f5(Eurydice_mut_borrow_slice_u8 bytes);

typedef struct core_core_arch_x86___m128i_x2_s
{
  __m128i fst;
  __m128i snd;
}
core_core_arch_x86___m128i_x2;

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_10_serialize_10_vec(__m256i vector);

Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_serialize_10(__m256i vector);

Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_avx2_serialize_10_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10_deserialize_10_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_10_f5(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_serialize_11(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_avx2_serialize_11_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_11(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_11_f5(Eurydice_mut_borrow_slice_u8 bytes);

core_core_arch_x86___m128i_x2
libcrux_ml_kem_vector_avx2_serialize_serialize_12_serialize_12_vec(__m256i vector);

Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_serialize_12(__m256i vector);

Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12(__m256i vector);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_avx2_serialize_12_f5(__m256i vector);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12_deserialize_12_vec(
  __m128i lower_coefficients0,
  __m128i upper_coefficients0
);

__m256i
libcrux_ml_kem_vector_avx2_serialize_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes);

__m256i libcrux_ml_kem_vector_avx2_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_deserialize_12_f5(Eurydice_mut_borrow_slice_u8 bytes);

size_t
libcrux_ml_kem_vector_avx2_sampling_rejection_sample(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
size_t
libcrux_ml_kem_vector_avx2_rej_sample_f5(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_i16 output
);

#define LIBCRUX_ML_KEM_VECTOR_AVX2_NTT_NTT_MULTIPLY_PERMUTE_WITH (216)

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::avx2::SIMD256Vector}
*/
__m256i libcrux_ml_kem_vector_avx2_clone_fd(__m256i *self);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem_avx2_H_DEFINED
#endif /* libcrux_mlkem_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "internal/libcrux_mlkem_portable.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_core.h"

inline Eurydice_arr_c7
libcrux_ml_kem_hash_functions_portable_G(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_c7 digest = { .data = { 0U } };
  libcrux_sha3_portable_sha512(Eurydice_array_to_slice_mut_17(&digest), input);
  return digest;
}

inline Eurydice_arr_ec
libcrux_ml_kem_hash_functions_portable_H(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_sha256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

#define ZETAS_TIMES_MONTGOMERY_R ((KRML_CLITERAL(Eurydice_arr_34){ .data = { -1044, -758, -359, -1517, 1493, 1422, 287, 202, -171, 622, 1577, 182, 962, -1202, -1474, 1468, 573, -1325, 264, 383, -829, 1458, -1602, -130, -681, 1017, 732, 608, -1542, 411, -205, -1571, 1223, 652, -552, 1015, -1293, 1491, -282, -1544, 516, -8, -320, -666, -1618, -1162, 126, 1469, -853, -90, -271, 830, 107, -1421, -247, -951, -398, 961, -1508, -725, 448, -1065, 677, -1275, -1103, 430, 555, 843, -1251, 871, 1550, 105, 422, 587, 177, -235, -291, -460, 1574, 1653, -246, 778, 1159, -147, -777, 1483, -602, 1119, -1590, 644, -872, 349, 418, 329, -156, -75, 817, 1097, 603, 610, 1322, -1285, -1465, 384, -1215, -136, 1218, -1335, -874, 220, -1187, -1659, -1185, -1530, -1278, 794, -1510, -854, -870, 478, -108, -308, 996, 991, 958, -1460, 1522, 1628 } }))

int16_t libcrux_ml_kem_polynomial_zeta(size_t i)
{
  return ZETAS_TIMES_MONTGOMERY_R.data[i];
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_i16_array(Eurydice_mut_borrow_slice_i16 array)
{
  Eurydice_arr_d6 arr;
  memcpy(arr.data,
    Eurydice_slice_subslice_mut_a6(array,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)16U })).ptr,
    (size_t)16U * sizeof (int16_t));
  return
    core_result_unwrap_26_d3((
        KRML_CLITERAL(core_result_Result_ec){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_mut_borrow_slice_i16 array)
{
  return
    libcrux_ml_kem_vector_portable_vector_type_from_i16_array(libcrux_secrets_int_classify_public_classify_ref_6d_39(array));
}

KRML_MUSTINLINE uint8_t_x11
libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_mut_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U]);
  uint8_t
  r1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] & 31) << 3U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U);
  uint8_t
  r2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] & 3) << 6U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 5U);
  uint8_t r3 = libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 2U & 255);
  uint8_t
  r4 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] & 127) << 1U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 10U);
  uint8_t
  r5 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U] & 15) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 7U);
  uint8_t
  r6 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U] & 1) << 7U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U] >> 4U);
  uint8_t r7 = libcrux_secrets_int_as_u8_f5(v.ptr[5U] >> 1U & 255);
  uint8_t
  r8 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U] & 63) << 2U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U] >> 9U);
  uint8_t
  r9 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[7U] & 7) << 5U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U] >> 6U);
  uint8_t r10 = libcrux_secrets_int_as_u8_f5(v.ptr[7U] >> 3U);
  return
    (
      KRML_CLITERAL(uint8_t_x11){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7,
        .f8 = r8,
        .f9 = r9,
        .f10 = r10
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_80
libcrux_ml_kem_vector_portable_serialize_serialize_11(Eurydice_arr_d6 v)
{
  uint8_t_x11
  r0_10 =
    libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x11
  r11_21 =
    libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_80){
        .data = {
          r0_10.fst, r0_10.snd, r0_10.thd, r0_10.f3, r0_10.f4, r0_10.f5, r0_10.f6, r0_10.f7,
          r0_10.f8, r0_10.f9, r0_10.f10, r11_21.fst, r11_21.snd, r11_21.thd, r11_21.f3, r11_21.f4,
          r11_21.f5, r11_21.f6, r11_21.f7, r11_21.f8, r11_21.f9, r11_21.f10
        }
      }
    );
}

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_0b(libcrux_ml_kem_vector_portable_serialize_serialize_11(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_11(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t
  r0 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) & 7) << 8U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[0U]);
  int16_t
  r1 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) & 63) << 5U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) >> 3U;
  int16_t
  r2 =
    ((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[4U]) & 1) << 10U) |
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[3U]) << 2U))
    | libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) >> 6U;
  int16_t
  r3 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) & 15) << 7U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[4U]) >> 1U;
  int16_t
  r4 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) & 127) << 4U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) >> 4U;
  int16_t
  r5 =
    ((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) & 3) << 9U) |
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[7U]) << 1U))
    | libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) >> 7U;
  int16_t
  r6 =
    (int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[9U]) & 31) << 6U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) >> 2U;
  int16_t
  r7 =
    (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[10U]) << 3U) |
      libcrux_secrets_int_as_i16_59(bytes.ptr[9U]) >> 5U;
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_11(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)11U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)11U, .end = (size_t)22U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_11(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_11_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_11(a);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_to_i16_array(Eurydice_arr_d6 x)
{
  return x;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_i16_array_b8(Eurydice_arr_d6 x)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_4b(libcrux_ml_kem_vector_portable_vector_type_to_i16_array(x));
}

KRML_MUSTINLINE Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_zero(void)
{
  return
    libcrux_secrets_int_public_integers_classify_27_4b((
        KRML_CLITERAL(Eurydice_arr_d6){ .data = { 0U } }
      ));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_ZERO_b8(void)
{
  return libcrux_ml_kem_vector_portable_vector_type_zero();
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_bytes(Eurydice_mut_borrow_slice_u8 array)
{
  Eurydice_arr_d6 elements;
  int16_t repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_secrets_int_I16(0););
  memcpy(elements.data, repeat_expression, (size_t)16U * sizeof (int16_t));
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    elements.data[i0] =
      (int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(array.ptr[(size_t)2U * i0 + (size_t)1U]) <<
        8U)
      | libcrux_secrets_int_as_i16_59(array.ptr[(size_t)2U * i0]);
  }
  return elements;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_bytes_b8(Eurydice_mut_borrow_slice_u8 array)
{
  return
    libcrux_ml_kem_vector_portable_vector_type_from_bytes(libcrux_secrets_int_classify_public_classify_ref_6d_90(array));
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_vector_type_to_bytes(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    bytes.ptr[(size_t)2U * i0 + (size_t)1U] = libcrux_secrets_int_as_u8_f5(x.data[i0] >> 8U);
    bytes.ptr[(size_t)2U * i0] = libcrux_secrets_int_as_u8_f5(x.data[i0]);
  }
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
void
libcrux_ml_kem_vector_portable_to_bytes_b8(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
)
{
  libcrux_ml_kem_vector_portable_vector_type_to_bytes(x,
    libcrux_secrets_int_public_integers_classify_mut_slice_75(bytes));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_add(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs.data[uu____0] += rhs->data[i0];
  }
  return lhs;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_add_b8(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs)
{
  return libcrux_ml_kem_vector_portable_arithmetic_add(lhs, rhs);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_sub(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    lhs.data[uu____0] -= rhs->data[i0];
  }
  return lhs;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_sub_b8(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs)
{
  return libcrux_ml_kem_vector_portable_arithmetic_sub(lhs, rhs);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(Eurydice_arr_d6 vec, int16_t c)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    vec.data[uu____0] *= c;
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_multiply_by_constant_b8(Eurydice_arr_d6 vec, int16_t c)
{
  return libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(vec, c);
}

/**
 Note: This function is not secret independent
 Only use with public values.
*/
KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    if (libcrux_secrets_int_public_integers_declassify_d8_39(vec.data[i0]) >= 3329)
    {
      size_t uu____0 = i0;
      vec.data[uu____0] -= 3329;
    }
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(Eurydice_arr_d6 v)
{
  return libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(v);
}

/**
 Signed Barrett Reduction

 Given an input `value`, `barrett_reduce` outputs a representative `result`
 such that:

 - result ≡ value (mod FIELD_MODULUS)
 - the absolute value of `result` is bound as follows:

 `|result| ≤ FIELD_MODULUS / 2 · (|value|/BARRETT_R + 1)

 Note: The input bound is 28296 to prevent overflow in the multiplication of quotient by FIELD_MODULUS

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(int16_t value)
{
  int32_t
  t =
    libcrux_secrets_int_as_i32_f5(value) *
      LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_BARRETT_MULTIPLIER
    + (LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_R >> 1U);
  int16_t
  quotient =
    libcrux_secrets_int_as_i16_36(t >> (uint32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT);
  return value - quotient * LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t vi = libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(vec.data[i0]);
    vec.data[i0] = vi;
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_barrett_reduce_b8(Eurydice_arr_d6 vector)
{
  return libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(vector);
}

/**
 Signed Montgomery Reduction

 Given an input `value`, `montgomery_reduce` outputs a representative `o`
 such that:

 - o ≡ value · MONTGOMERY_R^(-1) (mod FIELD_MODULUS)
 - the absolute value of `o` is bound as follows:

 `|result| ≤ ceil(|value| / MONTGOMERY_R) + 1665

 In particular, if `|value| ≤ FIELD_MODULUS-1 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS-1`.
 And, if `|value| ≤ pow2 16 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS + 1664

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(int32_t value)
{
  int32_t
  k =
    libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_as_i16_36(value)) *
      libcrux_secrets_int_as_i32_b8(libcrux_secrets_int_public_integers_classify_27_df(LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R));
  int32_t
  k_times_modulus =
    libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_as_i16_36(k)) *
      libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
  int16_t
  c =
    libcrux_secrets_int_as_i16_36(k_times_modulus >>
        (uint32_t)LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT);
  int16_t
  value_high =
    libcrux_secrets_int_as_i16_36(value >>
        (uint32_t)LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT);
  return value_high - c;
}

/**
 If `fe` is some field element 'x' of the Kyber field and `fer` is congruent to
 `y · MONTGOMERY_R`, this procedure outputs a value that is congruent to
 `x · y`, as follows:

    `fe · fer ≡ x · y · MONTGOMERY_R (mod FIELD_MODULUS)`

 `montgomery_reduce` takes the value `x · y · MONTGOMERY_R` and outputs a representative
 `x · y · MONTGOMERY_R * MONTGOMERY_R^{-1} ≡ x · y (mod FIELD_MODULUS)`.
*/
KRML_MUSTINLINE int16_t
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(
  int16_t fe,
  int16_t fer
)
{
  int32_t product = libcrux_secrets_int_as_i32_f5(fe) * libcrux_secrets_int_as_i32_f5(fer);
  return libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(product);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(
  Eurydice_arr_d6 vec,
  int16_t c
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    vec.data[i0] =
      libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(vec.data[i0],
        c);
  }
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(
  Eurydice_arr_d6 vector,
  int16_t constant
)
{
  return
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(vector,
      libcrux_secrets_int_public_integers_classify_27_39(constant));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(
  Eurydice_arr_d6 vec,
  int16_t c
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    size_t uu____0 = i0;
    vec.data[uu____0] &= c;
  }
  return vec;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.arithmetic.shift_right
with const generics
- SHIFT_BY= 15
*/
static KRML_MUSTINLINE Eurydice_arr_d6 shift_right_ef(Eurydice_arr_d6 vec)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    vec.data[i0] >>= (uint32_t)15;
  }
  return vec;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(Eurydice_arr_d6 a)
{
  Eurydice_arr_d6 t = shift_right_ef(a);
  Eurydice_arr_d6
  fm =
    libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(t,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS);
  return libcrux_ml_kem_vector_portable_arithmetic_add(a, &fm);
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(a);
}

/**
 The `compress_*` functions implement the `Compress` function specified in the NIST FIPS
 203 standard (Page 18, Expression 4.5), which is defined as:

 ```plaintext
 Compress_d: ℤq -> ℤ_{2ᵈ}
 Compress_d(x) = ⌈(2ᵈ/q)·x⌋
 ```

 Since `⌈x⌋ = ⌊x + 1/2⌋` we have:

 ```plaintext
 Compress_d(x) = ⌊(2ᵈ/q)·x + 1/2⌋
               = ⌊(2^{d+1}·x + q) / 2q⌋
 ```

 For further information about the function implementations, consult the
 `implementation_notes.pdf` document in this directory.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
uint8_t libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(uint16_t fe)
{
  int16_t
  shifted =
    libcrux_secrets_int_public_integers_classify_27_39(1664) - libcrux_secrets_int_as_i16_ca(fe);
  int16_t mask = shifted >> 15U;
  int16_t shifted_to_positive = mask ^ shifted;
  int16_t shifted_positive_in_range = shifted_to_positive - 832;
  int16_t r0 = shifted_positive_in_range >> 15U;
  int16_t r1 = r0 & 1;
  return libcrux_secrets_int_as_u8_f5(r1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_compress_compress_1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    a.data[i0] =
      libcrux_secrets_int_as_i16_59(libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(libcrux_secrets_int_as_u16_f5(a.data[i0])));
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_compress_compress_1(a);
}

KRML_MUSTINLINE uint32_t
libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(
  uint8_t n,
  uint32_t value
)
{
  return value & ((1U << (uint32_t)n) - 1U);
}

int16_t
libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient(
  uint8_t coefficient_bits,
  uint16_t fe
)
{
  uint64_t compressed = libcrux_secrets_int_as_u64_ca(fe) << (uint32_t)coefficient_bits;
  compressed += 1664ULL;
  compressed *= 10321340ULL;
  compressed >>= 35U;
  return
    libcrux_secrets_int_as_i16_b8(libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(coefficient_bits,
        libcrux_secrets_int_as_u32_a3(compressed)));
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_compress_decompress_1(Eurydice_arr_d6 a)
{
  Eurydice_arr_d6 z = libcrux_ml_kem_vector_portable_vector_type_zero();
  Eurydice_arr_d6 s = libcrux_ml_kem_vector_portable_arithmetic_sub(z, &a);
  Eurydice_arr_d6
  res = libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(s, 1665);
  return res;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_decompress_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_compress_decompress_1(a);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
)
{
  int16_t
  t =
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(vec->data[j],
      libcrux_secrets_int_public_integers_classify_27_39(zeta));
  int16_t a_minus_t = vec->data[i] - t;
  int16_t a_plus_t = vec->data[i] + t;
  vec->data[j] = a_minus_t;
  vec->data[i] = a_plus_t;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)0U, (size_t)2U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)1U, (size_t)3U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)4U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)5U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta2, (size_t)8U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta2, (size_t)9U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta3, (size_t)12U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta3, (size_t)13U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(a, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)0U, (size_t)4U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)1U, (size_t)5U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)2U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta0, (size_t)3U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)8U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)9U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)10U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta1, (size_t)11U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(a, zeta0, zeta1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta)
{
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)0U, (size_t)8U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)1U, (size_t)9U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)2U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)3U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)4U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)5U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)6U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_ntt_step(&vec, zeta, (size_t)7U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(a, zeta);
}

KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
)
{
  int16_t a_minus_b = vec->data[j] - vec->data[i];
  int16_t a_plus_b = vec->data[j] + vec->data[i];
  int16_t o0 = libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(a_plus_b);
  int16_t
  o1 =
    libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(a_minus_b,
      libcrux_secrets_int_public_integers_classify_27_39(zeta));
  vec->data[i] = o0;
  vec->data[j] = o1;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)0U, (size_t)2U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)1U, (size_t)3U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)4U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)5U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta2, (size_t)8U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta2, (size_t)9U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta3, (size_t)12U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta3, (size_t)13U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(a, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)0U, (size_t)4U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)1U, (size_t)5U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)2U, (size_t)6U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta0, (size_t)3U, (size_t)7U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)8U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)9U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)10U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta1, (size_t)11U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(a, zeta0, zeta1);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta)
{
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)0U, (size_t)8U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)1U, (size_t)9U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)2U, (size_t)10U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)3U, (size_t)11U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)4U, (size_t)12U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)5U, (size_t)13U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)6U, (size_t)14U);
  libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(&vec, zeta, (size_t)7U, (size_t)15U);
  return vec;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta)
{
  return libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(a, zeta);
}

/**
 Compute the product of two Kyber binomials with respect to the
 modulus `X² - zeta`.

 This function almost implements <strong>Algorithm 11</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input:  a₀, a₁, b₀, b₁ ∈ ℤq.
 Input: γ ∈ ℤq.
 Output: c₀, c₁ ∈ ℤq.

 c₀ ← a₀·b₀ + a₁·b₁·γ
 c₁ ← a₀·b₁ + a₁·b₀
 return c₀, c₁
 ```
 We say "almost" because the coefficients output by this function are in
 the Montgomery domain (unlike in the specification).

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
KRML_MUSTINLINE void
libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(
  Eurydice_arr_d6 *a,
  Eurydice_arr_d6 *b,
  int16_t zeta,
  size_t i,
  Eurydice_arr_d6 *out
)
{
  int16_t ai = a->data[(size_t)2U * i];
  int16_t bi = b->data[(size_t)2U * i];
  int16_t aj = a->data[(size_t)2U * i + (size_t)1U];
  int16_t bj = b->data[(size_t)2U * i + (size_t)1U];
  int32_t ai_bi = libcrux_secrets_int_as_i32_f5(ai) * libcrux_secrets_int_as_i32_f5(bi);
  int32_t aj_bj_ = libcrux_secrets_int_as_i32_f5(aj) * libcrux_secrets_int_as_i32_f5(bj);
  int16_t aj_bj = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(aj_bj_);
  int32_t
  aj_bj_zeta = libcrux_secrets_int_as_i32_f5(aj_bj) * libcrux_secrets_int_as_i32_f5(zeta);
  int32_t ai_bi_aj_bj = ai_bi + aj_bj_zeta;
  int16_t o0 = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(ai_bi_aj_bj);
  int32_t ai_bj = libcrux_secrets_int_as_i32_f5(ai) * libcrux_secrets_int_as_i32_f5(bj);
  int32_t aj_bi = libcrux_secrets_int_as_i32_f5(aj) * libcrux_secrets_int_as_i32_f5(bi);
  int32_t ai_bj_aj_bi = ai_bj + aj_bi;
  int16_t o1 = libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(ai_bj_aj_bi);
  out->data[(size_t)2U * i] = o0;
  out->data[(size_t)2U * i + (size_t)1U] = o1;
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_multiply(
  Eurydice_arr_d6 *lhs,
  Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  int16_t nzeta0 = -zeta0;
  int16_t nzeta1 = -zeta1;
  int16_t nzeta2 = -zeta2;
  int16_t nzeta3 = -zeta3;
  Eurydice_arr_d6 out = libcrux_ml_kem_vector_portable_vector_type_zero();
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta0),
    (size_t)0U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta0),
    (size_t)1U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta1),
    (size_t)2U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta1),
    (size_t)3U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta2),
    (size_t)4U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta2),
    (size_t)5U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(zeta3),
    (size_t)6U,
    &out);
  libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(lhs,
    rhs,
    libcrux_secrets_int_public_integers_classify_27_39(nzeta3),
    (size_t)7U,
    &out);
  return out;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_multiply_b8(
  Eurydice_arr_d6 *lhs,
  Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
)
{
  return libcrux_ml_kem_vector_portable_ntt_ntt_multiply(lhs, rhs, zeta0, zeta1, zeta2, zeta3);
}

KRML_MUSTINLINE Eurydice_array_u8x2
libcrux_ml_kem_vector_portable_serialize_serialize_1(Eurydice_arr_d6 v)
{
  uint8_t
  result0 =
    (((((((uint32_t)libcrux_secrets_int_as_u8_f5(v.data[0U]) |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[1U]) << 1U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[2U]) << 2U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[3U]) << 3U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[4U]) << 4U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[5U]) << 5U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[6U]) << 6U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[7U]) << 7U;
  uint8_t
  result1 =
    (((((((uint32_t)libcrux_secrets_int_as_u8_f5(v.data[8U]) |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[9U]) << 1U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[10U]) << 2U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[11U]) << 3U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[12U]) << 4U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[13U]) << 5U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[14U]) << 6U)
    | (uint32_t)libcrux_secrets_int_as_u8_f5(v.data[15U]) << 7U;
  return (KRML_CLITERAL(Eurydice_array_u8x2){ .data = { result0, result1 } });
}

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_75(libcrux_ml_kem_vector_portable_serialize_serialize_1(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_1(a);
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_1(Eurydice_mut_borrow_slice_u8 v)
{
  int16_t result0 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] & 1U);
  int16_t result1 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 1U & 1U);
  int16_t result2 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 2U & 1U);
  int16_t result3 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 3U & 1U);
  int16_t result4 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 4U & 1U);
  int16_t result5 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 5U & 1U);
  int16_t result6 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 6U & 1U);
  int16_t result7 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[0U] >> 7U & 1U);
  int16_t result8 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] & 1U);
  int16_t result9 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 1U & 1U);
  int16_t result10 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 2U & 1U);
  int16_t result11 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 3U & 1U);
  int16_t result12 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 4U & 1U);
  int16_t result13 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 5U & 1U);
  int16_t result14 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 6U & 1U);
  int16_t result15 = libcrux_secrets_int_as_i16_59((uint32_t)v.ptr[1U] >> 7U & 1U);
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          result0, result1, result2, result3, result4, result5, result6, result7, result8, result9,
          result10, result11, result12, result13, result14, result15
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_1(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_1(a);
}

KRML_MUSTINLINE uint8_t_x4
libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_mut_borrow_slice_i16 v)
{
  uint8_t
  result0 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U]);
  uint8_t
  result1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U]);
  uint8_t
  result2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[5U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[4U]);
  uint8_t
  result3 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[7U]) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[6U]);
  return
    (KRML_CLITERAL(uint8_t_x4){ .fst = result0, .snd = result1, .thd = result2, .f3 = result3 });
}

KRML_MUSTINLINE Eurydice_array_u8x8
libcrux_ml_kem_vector_portable_serialize_serialize_4(Eurydice_arr_d6 v)
{
  uint8_t_x4
  result0_3 =
    libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x4
  result4_7 =
    libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_array_u8x8){
        .data = {
          result0_3.fst, result0_3.snd, result0_3.thd, result0_3.f3, result4_7.fst, result4_7.snd,
          result4_7.thd, result4_7.f3
        }
      }
    );
}

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_52(libcrux_ml_kem_vector_portable_serialize_serialize_4(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_4(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t v0 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] & 15U);
  int16_t v1 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] >> 4U & 15U);
  int16_t v2 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] & 15U);
  int16_t v3 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] >> 4U & 15U);
  int16_t v4 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[2U] & 15U);
  int16_t v5 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[2U] >> 4U & 15U);
  int16_t v6 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] & 15U);
  int16_t v7 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] >> 4U & 15U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = v0,
        .snd = v1,
        .thd = v2,
        .f3 = v3,
        .f4 = v4,
        .f5 = v5,
        .f6 = v6,
        .f7 = v7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)4U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)8U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_4(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_4(a);
}

KRML_MUSTINLINE uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_mut_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] | (int16_t)((uint32_t)v.ptr[1U] << 5U));
  uint8_t
  r1 =
    libcrux_secrets_int_as_u8_f5((v.ptr[1U] >> 3U | (int16_t)((uint32_t)v.ptr[2U] << 2U)) |
        (int16_t)((uint32_t)v.ptr[3U] << 7U));
  uint8_t
  r2 = libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 1U | (int16_t)((uint32_t)v.ptr[4U] << 4U));
  uint8_t
  r3 =
    libcrux_secrets_int_as_u8_f5((v.ptr[4U] >> 4U | (int16_t)((uint32_t)v.ptr[5U] << 1U)) |
        (int16_t)((uint32_t)v.ptr[6U] << 6U));
  uint8_t
  r4 = libcrux_secrets_int_as_u8_f5(v.ptr[6U] >> 2U | (int16_t)((uint32_t)v.ptr[7U] << 3U));
  return (KRML_CLITERAL(uint8_t_x5){ .fst = r0, .snd = r1, .thd = r2, .f3 = r3, .f4 = r4 });
}

KRML_MUSTINLINE Eurydice_arr_6d
libcrux_ml_kem_vector_portable_serialize_serialize_5(Eurydice_arr_d6 v)
{
  uint8_t_x5
  r0_4 =
    libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })));
  uint8_t_x5
  r5_9 =
    libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_6d){
        .data = {
          r0_4.fst, r0_4.snd, r0_4.thd, r0_4.f3, r0_4.f4, r5_9.fst, r5_9.snd, r5_9.thd, r5_9.f3,
          r5_9.f4
        }
      }
    );
}

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_37(libcrux_ml_kem_vector_portable_serialize_serialize_5(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_5(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t v0 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[0U] & 31U);
  int16_t
  v1 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[1U] & 3U) << 3U |
        (uint32_t)bytes.ptr[0U] >> 5U);
  int16_t v2 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[1U] >> 2U & 31U);
  int16_t
  v3 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[2U] & 15U) << 1U |
        (uint32_t)bytes.ptr[1U] >> 7U);
  int16_t
  v4 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[3U] & 1U) << 4U |
        (uint32_t)bytes.ptr[2U] >> 4U);
  int16_t v5 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[3U] >> 1U & 31U);
  int16_t
  v6 =
    libcrux_secrets_int_as_i16_59(((uint32_t)bytes.ptr[4U] & 7U) << 2U |
        (uint32_t)bytes.ptr[3U] >> 6U);
  int16_t v7 = libcrux_secrets_int_as_i16_59((uint32_t)bytes.ptr[4U] >> 3U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = v0,
        .snd = v1,
        .thd = v2,
        .f3 = v3,
        .f4 = v4,
        .f5 = v5,
        .f6 = v6,
        .f7 = v7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_5(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)5U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)5U, .end = (size_t)10U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_5(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_5(a);
}

KRML_MUSTINLINE uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_mut_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] & 255);
  uint8_t
  r1 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] & 63) << 2U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U & 3);
  uint8_t
  r2 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] & 15) << 4U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 6U & 15);
  uint8_t
  r3 =
    (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[3U] & 3) << 6U |
      (uint32_t)libcrux_secrets_int_as_u8_f5(v.ptr[2U] >> 4U & 63);
  uint8_t r4 = libcrux_secrets_int_as_u8_f5(v.ptr[3U] >> 2U & 255);
  return (KRML_CLITERAL(uint8_t_x5){ .fst = r0, .snd = r1, .thd = r2, .f3 = r3, .f4 = r4 });
}

KRML_MUSTINLINE Eurydice_arr_fc
libcrux_ml_kem_vector_portable_serialize_serialize_10(Eurydice_arr_d6 v)
{
  uint8_t_x5
  r0_4 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)4U })));
  uint8_t_x5
  r5_9 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)8U })));
  uint8_t_x5
  r10_14 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)12U })));
  uint8_t_x5
  r15_19 =
    libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_fc){
        .data = {
          r0_4.fst, r0_4.snd, r0_4.thd, r0_4.f3, r0_4.f4, r5_9.fst, r5_9.snd, r5_9.thd, r5_9.f3,
          r5_9.f4, r10_14.fst, r10_14.snd, r10_14.thd, r10_14.f3, r10_14.f4, r15_19.fst, r15_19.snd,
          r15_19.thd, r15_19.f3, r15_19.f4
        }
      }
    );
}

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_2b(libcrux_ml_kem_vector_portable_serialize_serialize_10(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_10(a);
}

KRML_MUSTINLINE int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t
  r0 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[1U])
      & 3)
      << 8U)
      | (libcrux_secrets_int_as_i16_59(bytes.ptr[0U]) & 255));
  int16_t
  r1 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[2U])
      & 15)
      << 6U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[1U]) >> 2U);
  int16_t
  r2 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[3U])
      & 63)
      << 4U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[2U]) >> 4U);
  int16_t
  r3 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[4U])
      << 2U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[3U]) >> 6U);
  int16_t
  r4 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[6U])
      & 3)
      << 8U)
      | (libcrux_secrets_int_as_i16_59(bytes.ptr[5U]) & 255));
  int16_t
  r5 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[7U])
      & 15)
      << 6U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[6U]) >> 2U);
  int16_t
  r6 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)(libcrux_secrets_int_as_i16_59(bytes.ptr[8U])
      & 63)
      << 4U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[7U]) >> 4U);
  int16_t
  r7 =
    libcrux_secrets_int_as_i16_f5((int16_t)((uint32_t)libcrux_secrets_int_as_i16_59(bytes.ptr[9U])
      << 2U)
      | libcrux_secrets_int_as_i16_59(bytes.ptr[8U]) >> 6U);
  return
    (
      KRML_CLITERAL(int16_t_x8){
        .fst = r0,
        .snd = r1,
        .thd = r2,
        .f3 = r3,
        .f4 = r4,
        .f5 = r5,
        .f6 = r6,
        .f7 = r7
      }
    );
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t_x8
  v0_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)10U })));
  int16_t_x8
  v8_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)20U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_7.fst, v0_7.snd, v0_7.thd, v0_7.f3, v0_7.f4, v0_7.f5, v0_7.f6, v0_7.f7, v8_15.fst,
          v8_15.snd, v8_15.thd, v8_15.f3, v8_15.f4, v8_15.f5, v8_15.f6, v8_15.f7
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_10(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_10_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_10(a);
}

KRML_MUSTINLINE uint8_t_x3
libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_mut_borrow_slice_i16 v)
{
  uint8_t r0 = libcrux_secrets_int_as_u8_f5(v.ptr[0U] & 255);
  uint8_t
  r1 =
    libcrux_secrets_int_as_u8_f5(v.ptr[0U] >> 8U | (int16_t)((uint32_t)(v.ptr[1U] & 15) << 4U));
  uint8_t r2 = libcrux_secrets_int_as_u8_f5(v.ptr[1U] >> 4U & 255);
  return (KRML_CLITERAL(uint8_t_x3){ .fst = r0, .snd = r1, .thd = r2 });
}

KRML_MUSTINLINE Eurydice_arr_94
libcrux_ml_kem_vector_portable_serialize_serialize_12(Eurydice_arr_d6 v)
{
  uint8_t_x3
  r0_2 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)2U })));
  uint8_t_x3
  r3_5 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)2U, .end = (size_t)4U })));
  uint8_t_x3
  r6_8 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)4U, .end = (size_t)6U })));
  uint8_t_x3
  r9_11 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)6U, .end = (size_t)8U })));
  uint8_t_x3
  r12_14 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)10U })));
  uint8_t_x3
  r15_17 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)10U, .end = (size_t)12U })));
  uint8_t_x3
  r18_20 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)14U })));
  uint8_t_x3
  r21_23 =
    libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_array_to_subslice_mut_e7(&v,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)14U, .end = (size_t)16U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_94){
        .data = {
          r0_2.fst, r0_2.snd, r0_2.thd, r3_5.fst, r3_5.snd, r3_5.thd, r6_8.fst, r6_8.snd, r6_8.thd,
          r9_11.fst, r9_11.snd, r9_11.thd, r12_14.fst, r12_14.snd, r12_14.thd, r15_17.fst,
          r15_17.snd, r15_17.thd, r18_20.fst, r18_20.snd, r18_20.thd, r21_23.fst, r21_23.snd,
          r21_23.thd
        }
      }
    );
}

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12(Eurydice_arr_d6 a)
{
  return
    libcrux_secrets_int_public_integers_declassify_d8_40(libcrux_ml_kem_vector_portable_serialize_serialize_12(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12_b8(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_serialize_12(a);
}

KRML_MUSTINLINE int16_t_x2
libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t byte0 = libcrux_secrets_int_as_i16_59(bytes.ptr[0U]);
  int16_t byte1 = libcrux_secrets_int_as_i16_59(bytes.ptr[1U]);
  int16_t byte2 = libcrux_secrets_int_as_i16_59(bytes.ptr[2U]);
  int16_t r0 = (int16_t)((uint32_t)(byte1 & 15) << 8U) | (byte0 & 255);
  int16_t r1 = (int16_t)((uint32_t)byte2 << 4U) | (byte1 >> 4U & 15);
  return (KRML_CLITERAL(int16_t_x2){ .fst = r0, .snd = r1 });
}

KRML_MUSTINLINE Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes)
{
  int16_t_x2
  v0_1 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)3U })));
  int16_t_x2
  v2_3 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)3U, .end = (size_t)6U })));
  int16_t_x2
  v4_5 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)6U, .end = (size_t)9U })));
  int16_t_x2
  v6_7 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)9U, .end = (size_t)12U })));
  int16_t_x2
  v8_9 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)12U, .end = (size_t)15U })));
  int16_t_x2
  v10_11 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)15U, .end = (size_t)18U })));
  int16_t_x2
  v12_13 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)18U, .end = (size_t)21U })));
  int16_t_x2
  v14_15 =
    libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_slice_subslice_mut_c8(bytes,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)21U, .end = (size_t)24U })));
  return
    (
      KRML_CLITERAL(Eurydice_arr_d6){
        .data = {
          v0_1.fst, v0_1.snd, v2_3.fst, v2_3.snd, v4_5.fst, v4_5.snd, v6_7.fst, v6_7.snd, v8_9.fst,
          v8_9.snd, v10_11.fst, v10_11.snd, v12_13.fst, v12_13.snd, v14_15.fst, v14_15.snd
        }
      }
    );
}

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12(Eurydice_mut_borrow_slice_u8 a)
{
  return
    libcrux_ml_kem_vector_portable_serialize_deserialize_12(libcrux_secrets_int_classify_public_classify_ref_6d_90(a));
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_12_b8(Eurydice_mut_borrow_slice_u8 a)
{
  return libcrux_ml_kem_vector_portable_deserialize_12(a);
}

KRML_MUSTINLINE size_t
libcrux_ml_kem_vector_portable_sampling_rej_sample(
  Eurydice_mut_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 result
)
{
  size_t sampled = (size_t)0U;
  for (size_t i = (size_t)0U; i < a.meta / (size_t)3U; i++)
  {
    size_t i0 = i;
    int16_t b1 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)0U];
    int16_t b2 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)1U];
    int16_t b3 = (int16_t)a.ptr[i0 * (size_t)3U + (size_t)2U];
    int16_t d1 = (int16_t)((uint32_t)(b2 & 15) << 8U) | b1;
    int16_t d2 = (int16_t)((uint32_t)b3 << 4U) | b2 >> 4U;
    if (d1 < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS)
    {
      if (sampled < (size_t)16U)
      {
        result.ptr[sampled] = d1;
        sampled++;
      }
    }
    if (d2 < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS)
    {
      if (sampled < (size_t)16U)
      {
        result.ptr[sampled] = d2;
        sampled++;
      }
    }
  }
  return sampled;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
size_t
libcrux_ml_kem_vector_portable_rej_sample_b8(
  Eurydice_mut_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 out
)
{
  return libcrux_ml_kem_vector_portable_sampling_rej_sample(a, out);
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
inline Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_clone_9c(Eurydice_arr_d6 *self)
{
  return self[0U];
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static Eurydice_arr_9e ZERO_d6_ea(void)
{
  Eurydice_arr_9e lit;
  Eurydice_arr_d6 repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_portable_ZERO_b8(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_d6));
  return lit;
}

/**
 Only use with public values.

 This MUST NOT be used with secret inputs, like its caller `deserialize_ring_elements_reduced`.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_reduced_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_to_reduced_ring_element_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_12_b8(bytes);
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_ee(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_d20 *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 4
*/
static inline Eurydice_arr_4a shake128_init_absorb_final_23(Eurydice_arr_56 *input)
{
  Eurydice_arr_4a shake128_state;
  Eurydice_arr_7c repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_mut_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 4
*/
Eurydice_arr_4a
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(Eurydice_arr_56 *input)
{
  return shake128_init_absorb_final_23(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 4
*/
static inline Eurydice_arr_7c0 shake128_squeeze_first_three_blocks_23(Eurydice_arr_4a *st)
{
  Eurydice_arr_7c0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 4
*/
Eurydice_arr_7c0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(
  Eurydice_arr_4a *self
)
{
  return shake128_squeeze_first_three_blocks_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_1c(
  Eurydice_arr_7c0 *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 4
*/
static inline Eurydice_arr_9c shake128_squeeze_next_block_23(Eurydice_arr_4a *st)
{
  Eurydice_arr_9c
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 4
*/
Eurydice_arr_9c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(Eurydice_arr_4a *self)
{
  return shake128_squeeze_next_block_23(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_1c0(
  Eurydice_arr_9c *randomness,
  Eurydice_arr_cc *sampled_coefficients,
  Eurydice_arr_24 *out
)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.ZERO
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static Eurydice_arr_9e ZERO_ea(void)
{
  Eurydice_arr_9e lit;
  Eurydice_arr_d6 repeat_expression[16U];
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    repeat_expression[i] = libcrux_ml_kem_vector_portable_ZERO_b8(););
  memcpy(lit.data, repeat_expression, (size_t)16U * sizeof (Eurydice_arr_d6));
  return lit;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e from_i16_array_ea(Eurydice_mut_borrow_slice_i16 a)
{
  Eurydice_arr_9e result = ZERO_ea();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_slice_subslice_mut_a6(a,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * (size_t)16U,
              .end = (i0 + (size_t)1U) * (size_t)16U
            }
          )));
    result.data[i0] = uu____0;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.from_i16_array_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e from_i16_array_d6_ea(Eurydice_mut_borrow_slice_i16 a)
{
  return from_i16_array_ea(a);
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_0a_911(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20 sample_from_xof_911(Eurydice_arr_56 *seeds)
{
  Eurydice_arr_cc sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_24
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_4a
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_23(seeds);
  Eurydice_arr_7c0
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_23(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_1c(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_9c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_23(&xof_state);
      done = sample_from_uniform_distribution_next_1c0(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_d20 arr_mapped_str;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_911(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
sample_matrix_A_911(Eurydice_arr_600 *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_56 seeds;
    Eurydice_arr_31 repeat_expression[4U];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_d20 sampled = sample_from_xof_911(&seeds);
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 4
*/
static inline Eurydice_arr_ec H_4a_23(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_29(
  Eurydice_arr_d1 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_212(public_key, (size_t)1536U);
  deserialize_ring_elements_reduced_ee(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f5(public_key,
        (size_t)1536U));
  Eurydice_arr_600 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f5(public_key,
        (size_t)1536U));
  sample_matrix_A_911(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_23(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.to_unsigned_field_modulus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_d6 to_unsigned_field_modulus_ea(Eurydice_arr_d6 a)
{
  return libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.serialize_uncompressed_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_b20
serialize_uncompressed_ring_element_ea(Eurydice_arr_9e *re)
{
  Eurydice_arr_b20 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = to_unsigned_field_modulus_ea(re->data[i0]);
    Eurydice_arr_94 bytes = libcrux_ml_kem_vector_portable_serialize_12_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d413(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)24U * i0,
            .end = (size_t)24U * i0 + (size_t)24U
          }
        )),
      Eurydice_array_to_slice_mut_ed(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
serialize_vector_ee(Eurydice_arr_d20 *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_1c(
  Eurydice_arr_d20 *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_d1 *serialized
)
{
  serialize_vector_ee(t_as_ntt,
    Eurydice_array_to_subslice_mut_d419(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f5(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self,
  Eurydice_arr_d1 *serialized
)
{
  serialize_public_key_mut_1c(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_1c(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_d1 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_1c(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialize_public_key_1c(Eurydice_arr_d20 *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_d1 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_1c(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_d1
serialized_dd_1c(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *self)
{
  return
    libcrux_ml_kem_types_from_51_d9(serialize_public_key_1c(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_d1
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_1c(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  return serialized_dd_1c(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair1024
serialize_unpacked_secret_key_1c(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_d20 *private_key
)
{
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_1c(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_df secret_key_serialized = { .data = { 0U } };
  serialize_vector_ee(private_key, Eurydice_array_to_slice_mut_2f(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair1024){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_a8 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_23(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d422(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self,
  Eurydice_arr_a8 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 =
    serialize_unpacked_secret_key_1c(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(Eurydice_array_to_slice_mut_2f(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_b50(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
*/
Eurydice_arr_a8
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_2e(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *self
)
{
  Eurydice_arr_a8 sk = libcrux_ml_kem_types_default_d3_0e();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_2e(self, &sk);
  return sk;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_to_uncompressed_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_to_uncompressed_ring_element_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)24U,
            .end = i0 * (size_t)24U + (size_t)24U
          }
        ));
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_deserialize_12_b8(bytes);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
deserialize_vector_ee(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_d20 *secret_as_ntt)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_051(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_ee(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1536U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1536U);
  Eurydice_arr_600 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_911(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_38(
  Eurydice_arr_a8 *private_key,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_mut_68(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_ee(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_051(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)1536U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_d20 default_70_ee(void)
{
  Eurydice_arr_d20 lit;
  Eurydice_arr_9e repeat_expression[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 default_8b_ee(void)
{
  Eurydice_arr_d20 uu____0;
  Eurydice_arr_9e repeat_expression0[4U];
  KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)4U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_d20 repeat_expression1[4U];
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    Eurydice_arr_d20 lit;
    Eurydice_arr_9e repeat_expression[4U];
    KRML_MAYBE_FOR4(i, (size_t)0U, (size_t)4U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)4U * sizeof (Eurydice_arr_d20));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94
libcrux_ml_kem_ind_cca_unpacked_default_30_ee(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94){
        .ind_cpa_public_key = default_8b_ee(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_ee(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_94
  uu____0 =
    { .ind_cpa_private_key = default_70_ee(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_ee()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 4
*/
static inline Eurydice_arr_c7 G_4a_23(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_fe(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)4U;
  return G_4a_23(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_3b0 PRFxN_f5(Eurydice_arr_890 *input)
{
  Eurydice_arr_3b0
  out =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_mut_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_3b0 PRFxN_4a_f5(Eurydice_arr_890 *input)
{
  return PRFxN_f5(input);
}

/**
 Given a series of uniformly random bytes in `randomness`, for some number `eta`,
 the `sample_from_binomial_distribution_{eta}` functions sample
 a ring element from a binomial distribution centered at 0 that uses two sets
 of `eta` coin flips. If, for example,
 `eta = ETA`, each ring coefficient is a value `v` such
 such that `v ∈ {-ETA, -ETA + 1, ..., 0, ..., ETA + 1, ETA}` and:

 ```plaintext
 - If v < 0, Pr[v] = Pr[-v]
 - If v >= 0, Pr[v] = BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2 ^ (2 * ETA)
 ```

 The values `v < 0` are mapped to the appropriate `KyberFieldElement`.

 The expected value is:

 ```plaintext
 E[X] = (-ETA)Pr[-ETA] + (-(ETA - 1))Pr[-(ETA - 1)] + ... + (ETA - 1)Pr[ETA - 1] + (ETA)Pr[ETA]
      = 0 since Pr[-v] = Pr[v] when v < 0.
 ```

 And the variance is:

 ```plaintext
 Var(X) = E[(X - E[X])^2]
        = E[X^2]
        = sum_(v=-ETA to ETA)v^2 * (BINOMIAL_COEFFICIENT(2 * ETA; ETA - v) / 2^(2 * ETA))
        = ETA / 2
 ```

 This function implements <strong>Algorithm 7</strong> of the NIST FIPS 203 standard, which is
 reproduced below:

 ```plaintext
 Input: byte array B ∈ 𝔹^{64η}.
 Output: array f ∈ ℤ₂₅₆.

 b ← BytesToBits(B)
 for (i ← 0; i < 256; i++)
     x ← ∑(j=0 to η - 1) b[2iη + j]
     y ← ∑(j=0 to η - 1) b[2iη + η + j]
     f[i] ← x−y mod q
 end for
 return f
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_2_ea(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)4U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_mut_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_mut_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)4U,
            .end = chunk_number * (size_t)4U + (size_t)4U
          }
        ));
    uint32_t
    random_bits_as_u32 =
      (((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U)
      | (uint32_t)byte_chunk.ptr[3U] << 24U;
    uint32_t even_bits = random_bits_as_u32 & 1431655765U;
    uint32_t odd_bits = random_bits_as_u32 >> 1U & 1431655765U;
    uint32_t coin_toss_outcomes = even_bits + odd_bits;
    for (uint32_t i = 0U; i < 32U / 4U; i++)
    {
      uint32_t outcome_set = i;
      uint32_t outcome_set0 = outcome_set * 4U;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 3U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 2U) & 3U);
      size_t offset = (size_t)(outcome_set0 >> 2U);
      sampled_i16s.data[(size_t)8U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_ea(Eurydice_array_to_slice_mut_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_3_ea(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_04 sampled_i16s = { .data = { 0U } };
  for (size_t i0 = (size_t)0U; i0 < randomness.meta / (size_t)3U; i0++)
  {
    size_t chunk_number = i0;
    Eurydice_mut_borrow_slice_u8
    byte_chunk =
      Eurydice_slice_subslice_mut_c8(randomness,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = chunk_number * (size_t)3U,
            .end = chunk_number * (size_t)3U + (size_t)3U
          }
        ));
    uint32_t
    random_bits_as_u24 =
      ((uint32_t)byte_chunk.ptr[0U] | (uint32_t)byte_chunk.ptr[1U] << 8U) |
        (uint32_t)byte_chunk.ptr[2U] << 16U;
    uint32_t first_bits = random_bits_as_u24 & 2396745U;
    uint32_t second_bits = random_bits_as_u24 >> 1U & 2396745U;
    uint32_t third_bits = random_bits_as_u24 >> 2U & 2396745U;
    uint32_t coin_toss_outcomes = first_bits + second_bits + third_bits;
    for (int32_t i = 0; i < 24 / 6; i++)
    {
      int32_t outcome_set = i;
      int32_t outcome_set0 = outcome_set * 6;
      int16_t outcome_1 = (int16_t)(coin_toss_outcomes >> (uint32_t)outcome_set0 & 7U);
      int16_t outcome_2 = (int16_t)(coin_toss_outcomes >> (uint32_t)(outcome_set0 + 3) & 7U);
      size_t offset = (size_t)(outcome_set0 / 6);
      sampled_i16s.data[(size_t)4U * chunk_number + offset] = outcome_1 - outcome_2;
    }
  }
  return from_i16_array_d6_ea(Eurydice_array_to_slice_mut_990(&sampled_i16s));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- ETA= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_66(Eurydice_mut_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_2_ea(randomness);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_7_ea(Eurydice_arr_9e *re)
{
  size_t step = LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT / (size_t)2U;
  for (size_t i = (size_t)0U; i < step; i++)
  {
    size_t j = i;
    Eurydice_arr_d6
    t = libcrux_ml_kem_vector_portable_multiply_by_constant_b8(re->data[j + step], -1600);
    re->data[j + step] = libcrux_ml_kem_vector_portable_sub_b8(re->data[j], &t);
    Eurydice_arr_d6 uu____1 = libcrux_ml_kem_vector_portable_add_b8(re->data[j], &t);
    re->data[j] = uu____1;
  }
}

typedef struct libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2_s
{
  Eurydice_arr_d6 fst;
  Eurydice_arr_d6 snd;
}
libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2;

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_layer_int_vec_step
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
ntt_layer_int_vec_step_ea(Eurydice_arr_d6 a, Eurydice_arr_d6 b, int16_t zeta_r)
{
  Eurydice_arr_d6
  t = libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(b, zeta_r);
  b = libcrux_ml_kem_vector_portable_sub_b8(a, &t);
  a = libcrux_ml_kem_vector_portable_add_b8(a, &t);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2){
        .fst = a,
        .snd = b
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
ntt_at_layer_4_plus_ea(size_t *zeta_i, Eurydice_arr_9e *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]++;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / (size_t)16U;
    size_t step_vec = step / (size_t)16U;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
      uu____0 =
        ntt_layer_int_vec_step_ea(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      Eurydice_arr_d6 x = uu____0.fst;
      Eurydice_arr_d6 y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_3_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
    re->data[round] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_2_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U));
    zeta_i[0U]++;);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_at_layer_1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_at_layer_1_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]++;
    re->data[round] =
      libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] + (size_t)3U));
    zeta_i[0U] += (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_ea(Eurydice_arr_9e *myself)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 uu____0 = libcrux_ml_kem_vector_portable_barrett_reduce_b8(myself->data[i0]);
    myself->data[i0] = uu____0;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.poly_barrett_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void poly_barrett_reduce_d6_ea(Eurydice_arr_9e *self)
{
  poly_barrett_reduce_ea(self);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_binomially_sampled_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void ntt_binomially_sampled_ring_element_ea(Eurydice_arr_9e *re)
{
  ntt_at_layer_7_ea(re);
  size_t zeta_i = (size_t)1U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf1(
  Eurydice_arr_d20 *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_4a_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_73_391(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two `KyberPolynomialRingElement`s in their NTT representations,
 compute their product. Given two polynomials in the NTT domain `f^` and `ĵ`,
 the `iᵗʰ` coefficient of the product `k̂` is determined by the calculation:

 ```plaintext
 ĥ[2·i] + ĥ[2·i + 1]X = (f^[2·i] + f^[2·i + 1]X)·(ĝ[2·i] + ĝ[2·i + 1]X) mod (X² - ζ^(2·BitRev₇(i) + 1))
 ```

 This function almost implements <strong>Algorithm 10</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input: Two arrays fˆ ∈ ℤ₂₅₆ and ĝ ∈ ℤ₂₅₆.
 Output: An array ĥ ∈ ℤq.

 for(i ← 0; i < 128; i++)
     (ĥ[2i], ĥ[2i+1]) ← BaseCaseMultiply(fˆ[2i], fˆ[2i+1], ĝ[2i], ĝ[2i+1], ζ^(2·BitRev₇(i) + 1))
 end for
 return ĥ
 ```
 We say "almost" because the coefficients of the ring element output by
 this function are in the Montgomery domain.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
ntt_multiply_ea(Eurydice_arr_9e *myself, Eurydice_arr_9e *rhs)
{
  Eurydice_arr_9e out = ZERO_ea();
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_ntt_multiply_b8(&myself->data[i0],
        &rhs->data[i0],
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)1U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)2U),
        libcrux_ml_kem_polynomial_zeta((size_t)64U + (size_t)4U * i0 + (size_t)3U));
    out.data[i0] = uu____0;
  }
  return out;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.ntt_multiply_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
ntt_multiply_d6_ea(Eurydice_arr_9e *self, Eurydice_arr_9e *rhs)
{
  return ntt_multiply_ea(self, rhs);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_ee(Eurydice_arr_9e *myself, Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_ee(Eurydice_arr_9e *self, Eurydice_arr_9e *rhs)
{
  add_to_ring_element_ee(self, rhs);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.to_standard_domain
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_d6 to_standard_domain_ea(Eurydice_arr_d6 vector)
{
  return
    libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(vector,
      LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_ea(Eurydice_arr_9e *myself, Eurydice_arr_9e *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    Eurydice_arr_d6 coefficient_normal_form = to_standard_domain_ea(myself->data[j]);
    Eurydice_arr_d6
    sum = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &error->data[j]);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_standard_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_standard_error_reduce_d6_ea(Eurydice_arr_9e *self, Eurydice_arr_9e *error)
{
  add_standard_error_reduce_ea(self, error);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void
compute_As_plus_e_ee(
  Eurydice_arr_d20 *t_as_ntt,
  Eurydice_arr_600 *matrix_A,
  Eurydice_arr_d20 *s_as_ntt,
  Eurydice_arr_d20 *error_as_ntt
)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d20 *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR4(i1,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_ee(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_391(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_d20 *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_fe(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_600 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_911(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf1(private_key, &prf_input, 0U);
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_391(&lvalue););
  Eurydice_arr_d20 error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf1(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_ee(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_b4_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_d20 call_mut_22_ee(void **_)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_ee(&lvalue););
  return arr_struct;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.clone_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static inline Eurydice_arr_9e clone_c1_ea(Eurydice_arr_9e *self)
{
  return
    core_array__core__clone__Clone_for__T__N___clone((size_t)16U,
      self,
      Eurydice_arr_d6,
      Eurydice_arr_9e);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_600 transpose_a_ee(Eurydice_arr_600 ind_cpa_a)
{
  Eurydice_arr_600 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_ee(&lvalue););
  Eurydice_arr_600 A = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b81(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_391(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_600 A = transpose_a_ee(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_d1
  pk_serialized =
    serialize_public_key_1c(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_23(Eurydice_array_to_slice_mut_b50(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static Eurydice_arr_c7
encaps_prepare_fe(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_23(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_d20, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_12_s
{
  Eurydice_arr_d20 fst;
  Eurydice_arr_9e snd;
}
tuple_12;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_871(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_871(void **_)
{
  return ZERO_d6_ea();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf1(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_d20 *error_1
)
{
  Eurydice_arr_890 prf_inputs;
  Eurydice_arr_fa repeat_expression[4U];
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)4U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_23(&prf_inputs, domain_separator);
  Eurydice_arr_3b0 prf_outputs = PRFxN_4a_f5(&prf_inputs);
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF
with const generics
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_ec(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_89 digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 4
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_f50(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_a8_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_1_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)2U),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)3U));
    zeta_i[0U] -= (size_t)3U;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_2_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    re->data[round] =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]),
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U] - (size_t)1U));
    zeta_i[0U]--;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_3
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void invert_ntt_at_layer_3_ea(size_t *zeta_i, Eurydice_arr_9e *re)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t round = i;
    zeta_i[0U]--;
    Eurydice_arr_d6
    uu____0 =
      libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(re->data[round],
        libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
    re->data[round] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.inv_ntt_layer_int_vec_step_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
inv_ntt_layer_int_vec_step_reduce_ea(Eurydice_arr_d6 a, Eurydice_arr_d6 b, int16_t zeta_r)
{
  Eurydice_arr_d6 a_minus_b = libcrux_ml_kem_vector_portable_sub_b8(b, &a);
  a =
    libcrux_ml_kem_vector_portable_barrett_reduce_b8(libcrux_ml_kem_vector_portable_add_b8(a, &b));
  b = libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(a_minus_b, zeta_r);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2){
        .fst = a,
        .snd = b
      }
    );
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_at_layer_4_plus
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
invert_ntt_at_layer_4_plus_ea(size_t *zeta_i, Eurydice_arr_9e *re, size_t layer)
{
  size_t step = (size_t)1U << (uint32_t)layer;
  for (size_t i0 = (size_t)0U; i0 < (size_t)128U >> (uint32_t)layer; i0++)
  {
    size_t round = i0;
    zeta_i[0U]--;
    size_t offset = round * step * (size_t)2U;
    size_t offset_vec = offset / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    size_t step_vec = step / LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR;
    for (size_t i = offset_vec; i < offset_vec + step_vec; i++)
    {
      size_t j = i;
      libcrux_ml_kem_vector_portable_vector_type_PortableVector_x2
      uu____0 =
        inv_ntt_layer_int_vec_step_reduce_ea(re->data[j],
          re->data[j + step_vec],
          libcrux_ml_kem_polynomial_zeta(zeta_i[0U]));
      Eurydice_arr_d6 x = uu____0.fst;
      Eurydice_arr_d6 y = uu____0.snd;
      re->data[j] = x;
      re->data[j + step_vec] = y;
    }
  }
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_ee(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_ea(Eurydice_arr_9e *myself, Eurydice_arr_9e *error)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t j = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(myself->data[j],
        1441);
    Eurydice_arr_d6
    sum = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &error->data[j]);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum);
    myself->data[j] = red;
  }
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
add_error_reduce_d6_ea(Eurydice_arr_9e *self, Eurydice_arr_9e *error)
{
  add_error_reduce_ea(self, error);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20
compute_vector_u_ee(
  Eurydice_arr_600 *a_as_ntt,
  Eurydice_arr_d20 *r_as_ntt,
  Eurydice_arr_d20 *error_1
)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_ee(&lvalue););
  Eurydice_arr_d20 result = arr_struct;
  KRML_MAYBE_FOR4(i0,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_d20 *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR4(i,
      (size_t)0U,
      (size_t)4U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_ee(&result.data[i1], &product););
    invert_ntt_montgomery_ee(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_ef(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)10,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 10
*/
static Eurydice_arr_d6 compress_b8_ef(Eurydice_arr_d6 a)
{
  return compress_ef(a);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_c4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)11,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 11
*/
static Eurydice_arr_d6 compress_b8_c4(Eurydice_arr_d6 a)
{
  return compress_c4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7 compress_then_serialize_11_bd(Eurydice_arr_9e *re)
{
  Eurydice_arr_e7 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient =
      compress_b8_c4(libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(re->data[i0]));
    Eurydice_arr_80 bytes = libcrux_ml_kem_vector_portable_serialize_11_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d421(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)22U * i0,
            .end = (size_t)22U * i0 + (size_t)22U
          }
        )),
      Eurydice_array_to_slice_mut_98(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 11
- OUT_LEN= 352
*/
static KRML_MUSTINLINE Eurydice_arr_e7
compress_then_serialize_ring_element_u_86(Eurydice_arr_9e *re)
{
  return compress_then_serialize_11_bd(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- OUT_LEN= 1408
- COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_2e(Eurydice_arr_d20 input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)1408U / (size_t)4U),
            .end = (i0 + (size_t)1U) * ((size_t)1408U / (size_t)4U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_e7 lvalue = compress_then_serialize_ring_element_u_86(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_25(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- C1_LEN= 1408
- U_COMPRESSION_FACTOR= 11
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_12
encrypt_c1_871(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_600 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_d20 arr_struct0;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_871(&lvalue););
  Eurydice_arr_d20 r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf1(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_871(&lvalue););
  Eurydice_arr_d20 error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_bf1(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_f50(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_d20 u = compute_vector_u_ee(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_2e(u, ciphertext);
  return (KRML_CLITERAL(tuple_12){ .fst = r_as_ntt, .snd = error_2 });
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_message_ea(Eurydice_arr_ec *serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_compressed =
      libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_array_to_subslice_mut_d44(serialized,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = (size_t)2U * i0,
              .end = (size_t)2U * i0 + (size_t)2U
            }
          )));
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_decompress_1_b8(coefficient_compressed);
    re.data[i0] = uu____0;);
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
add_message_error_reduce_ea(
  Eurydice_arr_9e *myself,
  Eurydice_arr_9e *message,
  Eurydice_arr_9e result
)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(result.data[i0],
        1441);
    Eurydice_arr_d6
    sum1 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &message->data[i0]);
    Eurydice_arr_d6 sum2 = libcrux_ml_kem_vector_portable_add_b8(coefficient_normal_form, &sum1);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(sum2);
    result.data[i0] = red;
  }
  return result;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_message_error_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
add_message_error_reduce_d6_ea(
  Eurydice_arr_9e *self,
  Eurydice_arr_9e *message,
  Eurydice_arr_9e result
)
{
  return add_message_error_reduce_ea(self, message, result);
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_ee(
  Eurydice_arr_d20 *t_as_ntt,
  Eurydice_arr_d20 *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_ee(&result, &product););
  invert_ntt_montgomery_ee(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_d1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)4,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 4
*/
static Eurydice_arr_d6 compress_b8_d1(Eurydice_arr_d6 a)
{
  return compress_d1(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_4_ea(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = compress_b8_d1(to_unsigned_field_modulus_ea(re.data[i0]));
    Eurydice_array_u8x8 bytes = libcrux_ml_kem_vector_portable_serialize_4_b8(coefficient);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)8U * i0,
            .end = (size_t)8U * i0 + (size_t)8U
          }
        )),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.compress
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE Eurydice_arr_d6 compress_f4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int16_t
    uu____0 =
      libcrux_secrets_int_as_i16_f5(libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient((uint8_t)5,
          libcrux_secrets_int_as_u16_f5(a.data[i0])));
    a.data[i0] = uu____0;
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress_b8
with const generics
- COEFFICIENT_BITS= 5
*/
static Eurydice_arr_d6 compress_b8_f4(Eurydice_arr_d6 a)
{
  return compress_f4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_5
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE void
compress_then_serialize_5_ea(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 serialized)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficients =
      compress_b8_f4(libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(re.data[i0]));
    Eurydice_arr_6d bytes = libcrux_ml_kem_vector_portable_serialize_5_b8(coefficients);
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)10U * i0,
            .end = (size_t)10U * i0 + (size_t)10U
          }
        )),
      Eurydice_array_to_slice_mut_30(&bytes),
      uint8_t);
  }
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
- OUT_LEN= 160
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_1c(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_5_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- V_COMPRESSION_FACTOR= 5
- C2_LEN= 160
*/
static KRML_MUSTINLINE void
encrypt_c2_1c(
  Eurydice_arr_d20 *t_as_ntt,
  Eurydice_arr_d20 *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_ee(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_1c(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_unpacked_d51(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d1 ciphertext = { .data = { 0U } };
  tuple_12
  uu____0 =
    encrypt_c1_871(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d419(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)1408U })));
  Eurydice_arr_d20 r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_1c(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f5(&ciphertext, (size_t)1408U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- VECTOR_U_BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a71(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_94 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_fe(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_unpacked_d51(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_25){
        .fst = libcrux_ml_kem_types_from_19_d9(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static Eurydice_arr_9e call_mut_35_1c(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 10
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_ef(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)10);
    decompressed >>= (uint32_t)(10 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 10
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_ef(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_ef(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_10
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_10_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)20U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)20U,
            .end = i0 * (size_t)20U + (size_t)20U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_10_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_ef(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_c4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)11);
    decompressed >>= (uint32_t)(11 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 11
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_c4(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_c4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_11_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)22U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)22U,
            .end = i0 * (size_t)22U + (size_t)22U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_11_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_c4(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_u_ee(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_11_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE void ntt_vector_u_ee(Eurydice_arr_9e *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- U_COMPRESSION_FACTOR= 11
*/
static KRML_MUSTINLINE Eurydice_arr_d20
deserialize_then_decompress_u_1c(Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_1c(&lvalue););
  Eurydice_arr_d20 u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1568U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d419(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)11U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_ee(u_bytes);
    ntt_vector_u_ee(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_d1(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)4);
    decompressed >>= (uint32_t)(4 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 4
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_d1(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_d1(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_4_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)8U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)8U,
            .end = i0 * (size_t)8U + (size_t)8U
          }
        ));
    Eurydice_arr_d6 coefficient = libcrux_ml_kem_vector_portable_deserialize_4_b8(bytes);
    Eurydice_arr_d6 uu____0 = decompress_ciphertext_coefficient_b8_d1(coefficient);
    re.data[i0] = uu____0;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.vector.portable.compress.decompress_ciphertext_coefficient
with const generics
- COEFFICIENT_BITS= 5
*/
static KRML_MUSTINLINE Eurydice_arr_d6 decompress_ciphertext_coefficient_f4(Eurydice_arr_d6 a)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR; i++)
  {
    size_t i0 = i;
    int32_t
    decompressed =
      libcrux_secrets_int_as_i32_f5(a.data[i0]) *
        libcrux_secrets_int_as_i32_f5(libcrux_secrets_int_public_integers_classify_27_39(LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS));
    decompressed = (int32_t)((uint32_t)decompressed << 1U) + (int32_t)((uint32_t)1 << (uint32_t)5);
    decompressed >>= (uint32_t)(5 + 1);
    a.data[i0] = libcrux_secrets_int_as_i16_36(decompressed);
  }
  return a;
}

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
/**
A monomorphic instance of libcrux_ml_kem.vector.portable.decompress_ciphertext_coefficient_b8
with const generics
- COEFFICIENT_BITS= 5
*/
static Eurydice_arr_d6 decompress_ciphertext_coefficient_b8_f4(Eurydice_arr_d6 a)
{
  return decompress_ciphertext_coefficient_f4(a);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_5
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_5_ea(Eurydice_mut_borrow_slice_u8 serialized)
{
  Eurydice_arr_9e re = ZERO_d6_ea();
  for (size_t i = (size_t)0U; i < serialized.meta / (size_t)10U; i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    bytes =
      Eurydice_slice_subslice_mut_c8(serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * (size_t)10U,
            .end = i0 * (size_t)10U + (size_t)10U
          }
        ));
    re.data[i0] = libcrux_ml_kem_vector_portable_deserialize_5_b8(bytes);
    Eurydice_arr_d6 uu____1 = decompress_ciphertext_coefficient_b8_f4(re.data[i0]);
    re.data[i0] = uu____1;
  }
  return re;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_1c(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_5_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
subtract_reduce_ea(Eurydice_arr_9e *myself, Eurydice_arr_9e b)
{
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6
    coefficient_normal_form =
      libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(b.data[i0],
        1441);
    Eurydice_arr_d6
    diff = libcrux_ml_kem_vector_portable_sub_b8(myself->data[i0], &coefficient_normal_form);
    Eurydice_arr_d6 red = libcrux_ml_kem_vector_portable_barrett_reduce_b8(diff);
    b.data[i0] = red;
  }
  return b;
}

/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.subtract_reduce_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_9e
subtract_reduce_d6_ea(Eurydice_arr_9e *self, Eurydice_arr_9e b)
{
  return subtract_reduce_ea(self, b);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_ee(
  Eurydice_arr_9e *v,
  Eurydice_arr_d20 *secret_as_ntt,
  Eurydice_arr_d20 *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_ee(&result, &product););
  invert_ntt_montgomery_ee(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics

*/
static KRML_MUSTINLINE Eurydice_arr_ec compress_then_serialize_message_ea(Eurydice_arr_9e re)
{
  Eurydice_arr_ec serialized = { .data = { 0U } };
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = to_unsigned_field_modulus_ea(re.data[i0]);
    Eurydice_arr_d6
    coefficient_compressed = libcrux_ml_kem_vector_portable_compress_1_b8(coefficient);
    Eurydice_array_u8x2
    bytes = libcrux_ml_kem_vector_portable_serialize_1_b8(coefficient_compressed);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)2U * i0,
            .end = (size_t)2U * i0 + (size_t)2U
          }
        )),
      Eurydice_array_to_slice_mut_82(&bytes),
      uint8_t););
  return serialized;
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_38(Eurydice_arr_d20 *secret_key, Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 u_as_ntt = deserialize_then_decompress_u_1c(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_1c(Eurydice_array_to_subslice_from_mut_5f5(ciphertext,
        (size_t)1408U));
  Eurydice_arr_9e message = compute_message_ee(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF
with const generics
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_ce(Eurydice_mut_borrow_slice_u8 input)
{
  Eurydice_arr_ec digest = { .data = { 0U } };
  libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_01(&digest), input);
  return digest;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 4
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_f5(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c1(
  libcrux_ml_kem_mlkem1024_portable_unpacked_MlKem1024KeyPairUnpacked *key_pair,
  Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_38(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_49(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f6(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_f5(Eurydice_array_to_slice_mut_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext =
    encrypt_unpacked_d51(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_b50(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static Eurydice_arr_9e call_mut_0b_ee(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_d20
deserialize_ring_elements_reduced_out_ee(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_ee(&lvalue););
  Eurydice_arr_d20 deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_ee(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- PUBLIC_KEY_SIZE= 1568
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_1c(Eurydice_arr_d1 *public_key)
{
  Eurydice_arr_d20
  deserialized_pk =
    deserialize_ring_elements_reduced_out_ee(Eurydice_array_to_subslice_to_mut_212(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  Eurydice_arr_d1
  public_key_serialized =
    serialize_public_key_1c(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f5(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)4U)));
  return Eurydice_array_eq((size_t)1568U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_4c(Eurydice_arr_a8 *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_23(Eurydice_array_to_subslice_mut_d422(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)4U,
            .end = (size_t)768U * (size_t)4U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d422(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)4U + (size_t)32U,
          .end = (size_t)768U * (size_t)4U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CIPHERTEXT_SIZE= 1568
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_79(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_4c(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- PRIVATE_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair1024
generate_keypair_301(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_d20 private_key = default_70_ee();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94 public_key = default_8b_ee();
  generate_keypair_unpacked_391(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_1c(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- SERIALIZED_KEY_LEN= 3168
*/
static KRML_MUSTINLINE Eurydice_arr_a8
serialize_kem_secret_key_4c(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_a8 out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_4c(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CPA_PRIVATE_KEY_SIZE= 1536
- PRIVATE_KEY_SIZE= 3168
- PUBLIC_KEY_SIZE= 1568
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem1024_MlKem1024KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b81(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair1024
  uu____0 = generate_keypair_301(ind_cpa_keypair_randomness);
  Eurydice_arr_df ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_d1 public_key = uu____0.snd;
  Eurydice_arr_a8
  secret_key_serialized =
    serialize_kem_secret_key_4c(Eurydice_array_to_slice_mut_2f(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_b50(&public_key),
      implicit_rejection_value);
  Eurydice_arr_a8 private_key = libcrux_ml_kem_types_from_b2_0e(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_70(private_key,
      libcrux_ml_kem_types_from_51_d9(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_fe(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- T_AS_NTT_ENCODED_SIZE= 1536
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
build_unpacked_public_key_051(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
  unpacked_public_key = default_8b_ee();
  build_unpacked_public_key_mut_051(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_LEN= 1408
- C2_LEN= 160
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
- BLOCK_LEN= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d1
encrypt_d51(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_94
  unpacked_public_key = build_unpacked_public_key_051(public_key);
  return encrypt_unpacked_d51(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]]
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_4c(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- PUBLIC_KEY_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_25
libcrux_ml_kem_ind_cca_encapsulate_991(
  Eurydice_arr_d1 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_fe(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_23(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d1
  ciphertext =
    encrypt_d51(Eurydice_array_to_slice_mut_b50(libcrux_ml_kem_types_as_slice_e6_d9(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d1 uu____2 = libcrux_ml_kem_types_from_19_d9(ciphertext);
  return (KRML_CLITERAL(tuple_25){ .fst = uu____2, .snd = kdf_39_4c(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static Eurydice_arr_9e call_mut_0b_38(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 4
- CIPHERTEXT_SIZE= 1568
- VECTOR_U_ENCODED_SIZE= 1408
- U_COMPRESSION_FACTOR= 11
- V_COMPRESSION_FACTOR= 5
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_38(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_d1 *ciphertext)
{
  Eurydice_arr_d20 arr_struct;
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_38(&lvalue););
  Eurydice_arr_d20 secret_key_unpacked = arr_struct;
  deserialize_vector_ee(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_38(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$4size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 4
- SECRET_KEY_SIZE= 3168
- CPA_SECRET_KEY_SIZE= 1536
- PUBLIC_KEY_SIZE= 1568
- CIPHERTEXT_SIZE= 1568
- T_AS_NTT_ENCODED_SIZE= 1536
- C1_SIZE= 1408
- C2_SIZE= 160
- VECTOR_U_COMPRESSION_FACTOR= 11
- VECTOR_V_COMPRESSION_FACTOR= 5
- C1_BLOCK_SIZE= 352
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1600
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd1(
  Eurydice_arr_a8 *private_key,
  Eurydice_arr_d1 *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e3(Eurydice_array_to_slice_mut_68(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_38(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_23(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_14 to_hash = libcrux_ml_kem_utils_into_padded_array_49(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f6(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_d9(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_f5(Eurydice_array_to_slice_mut_720(&to_hash));
  Eurydice_arr_d1
  expected_ciphertext = encrypt_d51(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_4c(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_4c(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_d9(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_b50(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_66(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_1e *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 2
*/
static inline Eurydice_arr_e3 shake128_init_absorb_final_af(Eurydice_arr_bf *input)
{
  Eurydice_arr_e3 shake128_state;
  Eurydice_arr_7c repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_mut_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 2
*/
Eurydice_arr_e3
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(Eurydice_arr_bf *input)
{
  return shake128_init_absorb_final_af(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 2
*/
static inline Eurydice_arr_b8 shake128_squeeze_first_three_blocks_af(Eurydice_arr_e3 *st)
{
  Eurydice_arr_b8 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 2
*/
Eurydice_arr_b8
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(
  Eurydice_arr_e3 *self
)
{
  return shake128_squeeze_first_three_blocks_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_53(
  Eurydice_arr_b8 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 2
*/
static inline Eurydice_arr_5b0 shake128_squeeze_next_block_af(Eurydice_arr_e3 *st)
{
  Eurydice_arr_5b0 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 2
*/
Eurydice_arr_5b0
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(Eurydice_arr_e3 *self)
{
  return shake128_squeeze_next_block_af(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_530(
  Eurydice_arr_5b0 *randomness,
  Eurydice_arr_85 *sampled_coefficients,
  Eurydice_arr_800 *out
)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_0a_910(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e sample_from_xof_910(Eurydice_arr_bf *seeds)
{
  Eurydice_arr_85 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_800 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_e3
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_af(seeds);
  Eurydice_arr_b8
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_af(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_53(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_5b0
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_af(&xof_state);
      done = sample_from_uniform_distribution_next_530(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_1e arr_mapped_str;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_910(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
sample_matrix_A_910(Eurydice_arr_df0 *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bf seeds;
    Eurydice_arr_31 repeat_expression[2U];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_1e sampled = sample_from_xof_910(&seeds);
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 2
*/
static inline Eurydice_arr_ec H_4a_af(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_e0(
  Eurydice_arr_03 *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_210(public_key, (size_t)768U);
  deserialize_ring_elements_reduced_66(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f1(public_key,
        (size_t)768U));
  Eurydice_arr_df0 *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f1(public_key,
        (size_t)768U));
  sample_matrix_A_910(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_af(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
serialize_vector_66(Eurydice_arr_1e *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_53(
  Eurydice_arr_1e *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_03 *serialized
)
{
  serialize_vector_66(t_as_ntt,
    Eurydice_array_to_subslice_mut_d48(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f1(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self,
  Eurydice_arr_03 *serialized
)
{
  serialize_public_key_mut_53(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_53(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_03 *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_53(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialize_public_key_53(Eurydice_arr_1e *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_03 public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_53(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
static KRML_MUSTINLINE Eurydice_arr_03
serialized_dd_53(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *self)
{
  return
    libcrux_ml_kem_types_from_51_df(serialize_public_key_53(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_03
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_53(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
)
{
  return serialized_dd_53(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair512
serialize_unpacked_secret_key_44(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_1e *private_key
)
{
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_53(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_d2 secret_key_serialized = { .data = { 0U } };
  serialize_vector_66(private_key, Eurydice_array_to_slice_mut_27(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair512){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_ab0 *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_af(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d414(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self,
  Eurydice_arr_ab0 *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 =
    serialize_unpacked_secret_key_44(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(Eurydice_array_to_slice_mut_27(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_3b(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
*/
Eurydice_arr_ab0
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_a3(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *self
)
{
  Eurydice_arr_ab0 sk = libcrux_ml_kem_types_default_d3_be();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_a3(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
deserialize_vector_66(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_1e *secret_as_ntt)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_050(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_66(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)768U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)768U);
  Eurydice_arr_df0 *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_910(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_71(
  Eurydice_arr_ab0 *private_key,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_mut_99(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_66(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_050(ind_cpa_public_key,
    &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)768U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_1e default_70_66(void)
{
  Eurydice_arr_1e lit;
  Eurydice_arr_9e repeat_expression[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b default_8b_66(void)
{
  Eurydice_arr_1e uu____0;
  Eurydice_arr_9e repeat_expression0[2U];
  KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)2U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_1e repeat_expression1[2U];
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    Eurydice_arr_1e lit;
    Eurydice_arr_9e repeat_expression[2U];
    KRML_MAYBE_FOR2(i, (size_t)0U, (size_t)2U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)2U * sizeof (Eurydice_arr_1e));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b
libcrux_ml_kem_ind_cca_unpacked_default_30_66(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b){
        .ind_cpa_public_key = default_8b_66(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_66(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_3b
  uu____0 =
    { .ind_cpa_private_key = default_70_66(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_66()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 2
*/
static inline Eurydice_arr_c7 G_4a_af(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_10(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)2U;
  return G_4a_af(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 2
- LEN= 192
*/
static inline Eurydice_arr_eb PRFxN_d5(Eurydice_arr_4d *input)
{
  Eurydice_arr_eb out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_d9(&out.data[i0]),
      Eurydice_array_to_slice_mut_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 2
- LEN= 192
*/
static inline Eurydice_arr_eb PRFxN_4a_d5(Eurydice_arr_4d *input)
{
  return PRFxN_d5(input);
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_binomial_distribution
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- ETA= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
sample_from_binomial_distribution_68(Eurydice_mut_borrow_slice_u8 randomness)
{
  return sample_from_binomial_distribution_3_ea(randomness);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- ETA= 3
- ETA_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf0(
  Eurydice_arr_1e *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_eb prf_outputs = PRFxN_4a_d5(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_68(Eurydice_array_to_slice_mut_d9(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static Eurydice_arr_9e call_mut_73_390(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_66(Eurydice_arr_9e *myself, Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_66(Eurydice_arr_9e *self, Eurydice_arr_9e *rhs)
{
  add_to_ring_element_66(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void
compute_As_plus_e_66(
  Eurydice_arr_1e *t_as_ntt,
  Eurydice_arr_df0 *matrix_A,
  Eurydice_arr_1e *s_as_ntt,
  Eurydice_arr_1e *error_as_ntt
)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_1e *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR2(i1,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_66(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_390(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_1e *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_10(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_df0 *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_910(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf0(private_key, &prf_input, 0U);
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_390(&lvalue););
  Eurydice_arr_1e error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf0(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_66(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_b4_66(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_1e call_mut_22_66(void **_)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_66(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_df0 transpose_a_66(Eurydice_arr_df0 ind_cpa_a)
{
  Eurydice_arr_df0 arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_66(&lvalue););
  Eurydice_arr_df0 A = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b80(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_390(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_df0 A = transpose_a_66(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_03
  pk_serialized =
    serialize_public_key_53(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_af(Eurydice_array_to_slice_mut_3b(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static Eurydice_arr_c7
encaps_prepare_10(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_af(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_1e, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_77_s
{
  Eurydice_arr_1e fst;
  Eurydice_arr_9e snd;
}
tuple_77;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_870(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_870(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_f3 PRFxN_d50(Eurydice_arr_4d *input)
{
  Eurydice_arr_f3 out = { .data = { { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_mut_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_f3 PRFxN_4a_d50(Eurydice_arr_4d *input)
{
  return PRFxN_d50(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf0(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_1e *error_1
)
{
  Eurydice_arr_4d prf_inputs;
  Eurydice_arr_fa repeat_expression[2U];
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)2U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_af(&prf_inputs, domain_separator);
  Eurydice_arr_f3 prf_outputs = PRFxN_4a_d50(&prf_inputs);
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 2
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_d50(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_a8_66(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_66(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e
compute_vector_u_66(
  Eurydice_arr_df0 *a_as_ntt,
  Eurydice_arr_1e *r_as_ntt,
  Eurydice_arr_1e *error_1
)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_66(&lvalue););
  Eurydice_arr_1e result = arr_struct;
  KRML_MAYBE_FOR2(i0,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_1e *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR2(i,
      (size_t)0U,
      (size_t)2U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_66(&result.data[i1], &product););
    invert_ntt_montgomery_66(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_10
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0 compress_then_serialize_10_e1(Eurydice_arr_9e *re)
{
  Eurydice_arr_b0 serialized = { .data = { 0U } };
  for (size_t i = (size_t)0U; i < LIBCRUX_ML_KEM_POLYNOMIAL_VECTORS_IN_RING_ELEMENT; i++)
  {
    size_t i0 = i;
    Eurydice_arr_d6 coefficient = compress_b8_ef(to_unsigned_field_modulus_ea(re->data[i0]));
    Eurydice_arr_fc bytes = libcrux_ml_kem_vector_portable_serialize_10_b8(coefficient);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d412(&serialized,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)20U * i0,
            .end = (size_t)20U * i0 + (size_t)20U
          }
        )),
      Eurydice_array_to_slice_mut_8f(&bytes),
      uint8_t);
  }
  return serialized;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 10
- OUT_LEN= 320
*/
static KRML_MUSTINLINE Eurydice_arr_b0
compress_then_serialize_ring_element_u_f7(Eurydice_arr_9e *re)
{
  return compress_then_serialize_10_e1(re);
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- OUT_LEN= 640
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_a3(Eurydice_arr_1e input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)640U / (size_t)2U),
            .end = (i0 + (size_t)1U) * ((size_t)640U / (size_t)2U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_f7(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- C1_LEN= 640
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_77
encrypt_c1_870(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_df0 *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_1e arr_struct0;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_870(&lvalue););
  Eurydice_arr_1e r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf0(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_870(&lvalue););
  Eurydice_arr_1e error_1 = arr_struct;
  uint8_t
  domain_separator = sample_ring_element_cbd_bf0(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_d50(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_1e u = compute_vector_u_66(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_a3(u, ciphertext);
  return (KRML_CLITERAL(tuple_77){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_66(
  Eurydice_arr_1e *t_as_ntt,
  Eurydice_arr_1e *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_66(&result, &product););
  invert_ntt_montgomery_66(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_44(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_44(
  Eurydice_arr_1e *t_as_ntt,
  Eurydice_arr_1e *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_66(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_44(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_unpacked_d50(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_d2 ciphertext = { .data = { 0U } };
  tuple_77
  uu____0 =
    encrypt_c1_870(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d46(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)640U })));
  Eurydice_arr_1e r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_44(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f(&ciphertext, (size_t)640U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a70(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_3b *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_10(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_unpacked_d50(&public_key->ind_cpa_public_key,
      randomness,
      pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_ab){
        .fst = libcrux_ml_kem_types_from_19_80(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_9e call_mut_35_44(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_u_f7(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_10_ea(serialized);
}

/**
A monomorphic instance of libcrux_ml_kem.ntt.ntt_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- VECTOR_U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE void ntt_vector_u_f7(Eurydice_arr_9e *re)
{
  size_t zeta_i = (size_t)0U;
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  ntt_at_layer_3_ea(&zeta_i, re);
  ntt_at_layer_2_ea(&zeta_i, re);
  ntt_at_layer_1_ea(&zeta_i, re);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_1e
deserialize_then_decompress_u_44(Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_44(&lvalue););
  Eurydice_arr_1e u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)768U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d46(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_f7(u_bytes);
    ntt_vector_u_f7(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_53(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_ea(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_66(
  Eurydice_arr_9e *v,
  Eurydice_arr_1e *secret_as_ntt,
  Eurydice_arr_1e *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_66(&result, &product););
  invert_ntt_montgomery_66(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_71(Eurydice_arr_1e *secret_key, Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e u_as_ntt = deserialize_then_decompress_u_44(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_53(Eurydice_array_to_subslice_from_mut_5f(ciphertext,
        (size_t)640U));
  Eurydice_arr_9e message = compute_message_66(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 2
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_d5(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c0(
  libcrux_ml_kem_mlkem512_portable_unpacked_MlKem512KeyPairUnpacked *key_pair,
  Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_71(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_df(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f1(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_d5(Eurydice_array_to_slice_mut_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext =
    encrypt_unpacked_d50(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_27(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static Eurydice_arr_9e call_mut_0b_66(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_1e
deserialize_ring_elements_reduced_out_66(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_66(&lvalue););
  Eurydice_arr_1e deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_66(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- PUBLIC_KEY_SIZE= 800
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_53(Eurydice_arr_03 *public_key)
{
  Eurydice_arr_1e
  deserialized_pk =
    deserialize_ring_elements_reduced_out_66(Eurydice_array_to_subslice_to_mut_210(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  Eurydice_arr_03
  public_key_serialized =
    serialize_public_key_53(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f1(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)2U)));
  return Eurydice_array_eq((size_t)800U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_e2(Eurydice_arr_ab0 *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_af(Eurydice_array_to_subslice_mut_d414(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)2U,
            .end = (size_t)768U * (size_t)2U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d414(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)2U + (size_t)32U,
          .end = (size_t)768U * (size_t)2U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CIPHERTEXT_SIZE= 768
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_d5(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_e2(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- PRIVATE_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair512
generate_keypair_300(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_1e private_key = default_70_66();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b public_key = default_8b_66();
  generate_keypair_unpacked_390(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_44(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- SERIALIZED_KEY_LEN= 1632
*/
static KRML_MUSTINLINE Eurydice_arr_ab0
serialize_kem_secret_key_e2(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_ab0 out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_e2(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CPA_PRIVATE_KEY_SIZE= 768
- PRIVATE_KEY_SIZE= 1632
- PUBLIC_KEY_SIZE= 800
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
*/
libcrux_ml_kem_types_MlKemKeyPair_0d
libcrux_ml_kem_ind_cca_generate_keypair_b80(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair512
  uu____0 = generate_keypair_300(ind_cpa_keypair_randomness);
  Eurydice_arr_d2 ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_03 public_key = uu____0.snd;
  Eurydice_arr_ab0
  secret_key_serialized =
    serialize_kem_secret_key_e2(Eurydice_array_to_slice_mut_27(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_3b(&public_key),
      implicit_rejection_value);
  Eurydice_arr_ab0 private_key = libcrux_ml_kem_types_from_b2_be(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_d6(private_key,
      libcrux_ml_kem_types_from_51_df(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_10(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- T_AS_NTT_ENCODED_SIZE= 768
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
build_unpacked_public_key_050(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
  unpacked_public_key = default_8b_66();
  build_unpacked_public_key_mut_050(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_LEN= 640
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_d2
encrypt_d50(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_3b
  unpacked_public_key = build_unpacked_public_key_050(public_key);
  return encrypt_unpacked_d50(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]]
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_e2(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_ab
libcrux_ml_kem_ind_cca_encapsulate_990(
  Eurydice_arr_03 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_10(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_af(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_d2
  ciphertext =
    encrypt_d50(Eurydice_array_to_slice_mut_3b(libcrux_ml_kem_types_as_slice_e6_df(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_d2 uu____2 = libcrux_ml_kem_types_from_19_80(ciphertext);
  return (KRML_CLITERAL(tuple_ab){ .fst = uu____2, .snd = kdf_39_e2(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_9e call_mut_0b_71(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 2
- CIPHERTEXT_SIZE= 768
- VECTOR_U_ENCODED_SIZE= 640
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_71(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_d2 *ciphertext)
{
  Eurydice_arr_1e arr_struct;
  KRML_MAYBE_FOR2(i,
    (size_t)0U,
    (size_t)2U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_71(&lvalue););
  Eurydice_arr_1e secret_key_unpacked = arr_struct;
  deserialize_vector_66(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_71(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$2size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 2
- SECRET_KEY_SIZE= 1632
- CPA_SECRET_KEY_SIZE= 768
- PUBLIC_KEY_SIZE= 800
- CIPHERTEXT_SIZE= 768
- T_AS_NTT_ENCODED_SIZE= 768
- C1_SIZE= 640
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 3
- ETA1_RANDOMNESS_SIZE= 192
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 800
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd0(
  Eurydice_arr_ab0 *private_key,
  Eurydice_arr_d2 *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_e0(Eurydice_array_to_slice_mut_99(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_71(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_af(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_03 to_hash = libcrux_ml_kem_utils_into_padded_array_df(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f1(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_80(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_d5(Eurydice_array_to_slice_mut_3b(&to_hash));
  Eurydice_arr_d2
  expected_ciphertext = encrypt_d50(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_e2(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_e2(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_80(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_27(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}

/**
 See [deserialize_ring_elements_reduced_out].
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_ring_elements_reduced_68(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_bb *deserialized_pk
)
{
  for
  (size_t
    i = (size_t)0U;
    i < public_key.meta / LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT;
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    ring_element =
      Eurydice_slice_subslice_mut_c8(public_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT +
              LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    Eurydice_arr_9e uu____0 = deserialize_to_reduced_ring_element_ea(ring_element);
    deserialized_pk->data[i0] = uu____0;
  }
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final
with const generics
- K= 3
*/
static inline Eurydice_arr_1b shake128_init_absorb_final_78(Eurydice_arr_81 *input)
{
  Eurydice_arr_1b shake128_state;
  Eurydice_arr_7c repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] = libcrux_sha3_portable_incremental_shake128_init(););
  memcpy(shake128_state.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_7c));
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_absorb_final(&shake128_state.data[i0],
      Eurydice_array_to_slice_mut_e9(&input->data[i0])););
  return shake128_state;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_init_absorb_final_4a
with const generics
- K= 3
*/
Eurydice_arr_1b
libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(Eurydice_arr_81 *input)
{
  return shake128_init_absorb_final_78(input);
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks
with const generics
- K= 3
*/
static inline Eurydice_arr_7e shake128_squeeze_first_three_blocks_78(Eurydice_arr_1b *st)
{
  Eurydice_arr_7e
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(&st->data[i0],
      Eurydice_array_to_slice_mut_48(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_first_three_blocks_4a
with const generics
- K= 3
*/
Eurydice_arr_7e
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(
  Eurydice_arr_1b *self
)
{
  return shake128_squeeze_first_three_blocks_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- N= 504
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_b6(
  Eurydice_arr_7e *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)504U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d49(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block
with const generics
- K= 3
*/
static inline Eurydice_arr_2c shake128_squeeze_next_block_78(Eurydice_arr_1b *st)
{
  Eurydice_arr_2c
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_incremental_shake128_squeeze_next_block(&st->data[i0],
      Eurydice_array_to_slice_mut_2c(&out.data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.shake128_squeeze_next_block_4a
with const generics
- K= 3
*/
Eurydice_arr_2c
libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(Eurydice_arr_1b *self)
{
  return shake128_squeeze_next_block_78(self);
}

/**
 If `bytes` contains a set of uniformly random bytes, this function
 uniformly samples a ring element `â` that is treated as being the NTT representation
 of the corresponding polynomial `a`.

 Since rejection sampling is used, it is possible the supplied bytes are
 not enough to sample the element, in which case an `Err` is returned and the
 caller must try again with a fresh set of bytes.

 This function <strong>partially</strong> implements <strong>Algorithm 6</strong> of the NIST FIPS 203 standard,
 We say "partially" because this implementation only accepts a finite set of
 bytes as input and returns an error if the set is not enough; Algorithm 6 of
 the FIPS 203 standard on the other hand samples from an infinite stream of bytes
 until the ring element is filled. Algorithm 6 is reproduced below:

 ```plaintext
 Input: byte stream B ∈ 𝔹*.
 Output: array â ∈ ℤ₂₅₆.

 i ← 0
 j ← 0
 while j < 256 do
     d₁ ← B[i] + 256·(B[i+1] mod 16)
     d₂ ← ⌊B[i+1]/16⌋ + 16·B[i+2]
     if d₁ < q then
         â[j] ← d₁
         j ← j + 1
     end if
     if d₂ < q and j < 256 then
         â[j] ← d₂
         j ← j + 1
     end if
     i ← i + 3
 end while
 return â
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_uniform_distribution_next
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- N= 168
*/
static KRML_MUSTINLINE bool
sample_from_uniform_distribution_next_b60(
  Eurydice_arr_2c *randomness,
  Eurydice_arr_eb0 *sampled_coefficients,
  Eurydice_arr_b1 *out
)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)24U; i++)
    {
      size_t r = i;
      if (sampled_coefficients->data[i1] < LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
      {
        size_t
        sampled =
          libcrux_ml_kem_vector_portable_rej_sample_b8(Eurydice_array_to_subslice_mut_d41(&randomness->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = r * (size_t)24U,
                  .end = r * (size_t)24U + (size_t)24U
                }
              )),
            Eurydice_array_to_subslice_mut_e70(&out->data[i1],
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = sampled_coefficients->data[i1],
                  .end = sampled_coefficients->data[i1] + (size_t)16U
                }
              )));
        size_t uu____0 = i1;
        sampled_coefficients->data[uu____0] += sampled;
      }
    });
  bool done = true;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    if (sampled_coefficients->data[i0] >= LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT)
    {
      sampled_coefficients->data[i0] = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT;
    }
    else
    {
      done = false;
    });
  return done;
}

/**
This function found in impl {core::ops::function::FnMut<([i16; 272usize]), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::sampling::sample_from_xof::closure<Vector, Hasher, K>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof.call_mut_0a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_0a_91(Eurydice_arr_5b tupled_args)
{
  Eurydice_arr_5b s = tupled_args;
  return
    from_i16_array_d6_ea(Eurydice_array_to_subslice_mut_e70(&s,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)256U })));
}

/**
A monomorphic instance of libcrux_ml_kem.sampling.sample_from_xof
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb sample_from_xof_91(Eurydice_arr_81 *seeds)
{
  Eurydice_arr_eb0 sampled_coefficients = { .data = { 0U } };
  Eurydice_arr_b1
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_arr_1b
  xof_state = libcrux_ml_kem_hash_functions_portable_shake128_init_absorb_final_4a_78(seeds);
  Eurydice_arr_7e
  randomness0 =
    libcrux_ml_kem_hash_functions_portable_shake128_squeeze_first_three_blocks_4a_78(&xof_state);
  bool
  done = sample_from_uniform_distribution_next_b6(&randomness0, &sampled_coefficients, &out);
  while (true)
  {
    if (done)
    {
      break;
    }
    else
    {
      Eurydice_arr_2c
      randomness =
        libcrux_ml_kem_hash_functions_portable_shake128_squeeze_next_block_4a_78(&xof_state);
      done = sample_from_uniform_distribution_next_b60(&randomness, &sampled_coefficients, &out);
    }
  }
  Eurydice_arr_bb arr_mapped_str;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    arr_mapped_str.data[i] = call_mut_0a_91(out.data[i]););
  return arr_mapped_str;
}

/**
A monomorphic instance of libcrux_ml_kem.matrix.sample_matrix_A
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
sample_matrix_A_91(Eurydice_arr_1d *A_transpose, Eurydice_arr_31 *seed, bool transpose)
{
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_81 seeds;
    Eurydice_arr_31 repeat_expression[3U];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      repeat_expression[i] =
        core_array__core__clone__Clone_for__T__N___clone((size_t)34U,
          seed,
          uint8_t,
          Eurydice_arr_31););
    memcpy(seeds.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_31));
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      seeds.data[j].data[32U] = (uint8_t)i1;
      seeds.data[j].data[33U] = (uint8_t)j;);
    Eurydice_arr_bb sampled = sample_from_xof_91(&seeds);
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e sample = sampled.data[j];
      if (transpose)
      {
        A_transpose->data[j].data[i1] = sample;
      }
      else
      {
        A_transpose->data[i1].data[j] = sample;
      }););
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.H_4a
with const generics
- K= 3
*/
static inline Eurydice_arr_ec H_4a_78(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_H(input);
}

/**
 Generate an unpacked key from a serialized key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.unpack_public_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_unpack_public_key_22(
  Eurydice_arr_5f *public_key,
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *unpacked_public_key
)
{
  Eurydice_mut_borrow_slice_u8
  uu____0 = Eurydice_array_to_subslice_to_mut_211(public_key, (size_t)1152U);
  deserialize_ring_elements_reduced_68(uu____0,
    &unpacked_public_key->ind_cpa_public_key.t_as_ntt);
  unpacked_public_key->ind_cpa_public_key.seed_for_A =
    libcrux_ml_kem_utils_into_padded_array_ce(Eurydice_array_to_subslice_from_mut_5f4(public_key,
        (size_t)1152U));
  Eurydice_arr_1d *uu____2 = &unpacked_public_key->ind_cpa_public_key.A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31
  lvalue =
    libcrux_ml_kem_utils_into_padded_array_de(Eurydice_array_to_subslice_from_mut_5f4(public_key,
        (size_t)1152U));
  sample_matrix_A_91(uu____2, &lvalue, false);
  Eurydice_arr_ec
  uu____3 =
    H_4a_78(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  unpacked_public_key->public_key_hash = uu____3;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
*libcrux_ml_kem_ind_cca_unpacked_public_key_11_68(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return &self->public_key;
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.clone_91
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static inline libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
clone_91_68(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *self)
{
  Eurydice_arr_bb
  uu____0 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
      &self->t_as_ntt,
      Eurydice_arr_9e,
      Eurydice_arr_bb);
  Eurydice_arr_ec
  uu____1 =
    core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
      &self->seed_for_A,
      uint8_t,
      Eurydice_arr_ec);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51){
        .t_as_ntt = uu____0,
        .seed_for_A = uu____1,
        .A = core_array__core__clone__Clone_for__T__N___clone((size_t)3U,
          &self->A,
          Eurydice_arr_bb,
          Eurydice_arr_1d)
      }
    );
}

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@2]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.clone_d7
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_clone_d7_68(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  uu____0 = clone_91_68(&self->ind_cpa_public_key);
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51){
        .ind_cpa_public_key = uu____0,
        .public_key_hash = core_array__core__clone__Clone_for__T__N___clone((size_t)32U,
          &self->public_key_hash,
          uint8_t,
          Eurydice_arr_ec)
      }
    );
}

/**
 Call [`serialize_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
serialize_vector_68(Eurydice_arr_bb *key, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = key->data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
            .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b20 lvalue = serialize_uncompressed_ring_element_ea(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_a9(&lvalue), uint8_t););
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE void
serialize_public_key_mut_b6(
  Eurydice_arr_bb *t_as_ntt,
  Eurydice_mut_borrow_slice_u8 seed_for_a,
  Eurydice_arr_5f *serialized
)
{
  serialize_vector_68(t_as_ntt,
    Eurydice_array_to_subslice_mut_d417(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)
        }
      )));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f4(serialized,
      libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)),
    seed_for_a,
    uint8_t);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self,
  Eurydice_arr_5f *serialized
)
{
  serialize_public_key_mut_b6(&self->ind_cpa_public_key.t_as_ntt,
    Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A),
    serialized);
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_mut_11_b6(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_5f *serialized
)
{
  libcrux_ml_kem_ind_cca_unpacked_serialized_mut_dd_b6(&self->public_key, serialized);
}

/**
 Concatenate `t` and `ρ` into the public key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialize_public_key_b6(Eurydice_arr_bb *t_as_ntt, Eurydice_mut_borrow_slice_u8 seed_for_a)
{
  Eurydice_arr_5f public_key_serialized = { .data = { 0U } };
  serialize_public_key_mut_b6(t_as_ntt, seed_for_a, &public_key_serialized);
  return public_key_serialized;
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
static KRML_MUSTINLINE Eurydice_arr_5f
serialized_dd_b6(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *self)
{
  return
    libcrux_ml_kem_types_from_51_3d(serialize_public_key_b6(&self->ind_cpa_public_key.t_as_ntt,
        Eurydice_array_to_slice_mut_01(&self->ind_cpa_public_key.seed_for_A)));
}

/**
 Get the serialized public key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_public_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_5f
libcrux_ml_kem_ind_cca_unpacked_serialized_public_key_11_b6(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  return serialized_dd_b6(&self->public_key);
}

/**
 Serialize the secret key from the unpacked key pair generation.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.serialize_unpacked_secret_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
*/
static libcrux_ml_kem_utils_extraction_helper_Keypair768
serialize_unpacked_secret_key_30(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_bb *private_key
)
{
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_b6(&public_key->t_as_ntt,
      Eurydice_array_to_slice_mut_01(&public_key->seed_for_A));
  Eurydice_arr_0e secret_key_serialized = { .data = { 0U } };
  serialize_vector_68(private_key, Eurydice_array_to_slice_mut_f4(&secret_key_serialized));
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_utils_extraction_helper_Keypair768){
        .fst = secret_key_serialized,
        .snd = public_key_serialized
      }
    );
}

/**
 Serialize the secret key.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key_mut
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
void
libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value,
  Eurydice_arr_7d *serialized
)
{
  size_t pointer = (size_t)0U;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + private_key.meta
        }
      )),
    private_key,
    uint8_t);
  pointer += private_key.meta;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = pointer, .end = pointer + public_key.meta })),
    public_key,
    uint8_t);
  pointer += public_key.meta;
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE
        }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec lvalue = H_4a_78(public_key);
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  pointer += LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE;
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d418(serialized,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = pointer,
          .end = pointer + implicit_rejection_value.meta
        }
      )),
    implicit_rejection_value,
    uint8_t);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_mut_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
void
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self,
  Eurydice_arr_7d *serialized
)
{
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 =
    serialize_unpacked_secret_key_30(&self->public_key.ind_cpa_public_key,
      &self->private_key.ind_cpa_private_key);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f ind_cpa_public_key = uu____0.snd;
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(Eurydice_array_to_slice_mut_f4(&ind_cpa_private_key),
    Eurydice_array_to_slice_mut_ff(&ind_cpa_public_key),
    Eurydice_array_to_slice_mut_01(&self->private_key.implicit_rejection_value),
    serialized);
}

/**
 Get the serialized private key.
*/
/**
This function found in impl {libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.serialized_private_key_11
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
*/
Eurydice_arr_7d
libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_11_21(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *self
)
{
  Eurydice_arr_7d sk = libcrux_ml_kem_types_default_d3_79();
  libcrux_ml_kem_ind_cca_unpacked_serialized_private_key_mut_11_21(self, &sk);
  return sk;
}

/**
 Call [`deserialize_to_uncompressed_ring_element`] for each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_vector
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
deserialize_vector_68(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_bb *secret_as_ntt)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      deserialize_to_uncompressed_ring_element_ea(Eurydice_slice_subslice_mut_c8(secret_key,
          (
            KRML_CLITERAL(core_ops_range_Range_87){
              .start = i0 * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT,
              .end = (i0 + (size_t)1U) * LIBCRUX_ML_KEM_CONSTANTS_BYTES_PER_RING_ELEMENT
            }
          )));
    secret_as_ntt->data[i0] = uu____0;);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key_mut
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE void
build_unpacked_public_key_mut_05(
  Eurydice_mut_borrow_slice_u8 public_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *unpacked_public_key
)
{
  deserialize_ring_elements_reduced_68(Eurydice_slice_subslice_to_mut_72(public_key,
      (size_t)1152U),
    &unpacked_public_key->t_as_ntt);
  Eurydice_mut_borrow_slice_u8
  seed = Eurydice_slice_subslice_from_mut_6d(public_key, (size_t)1152U);
  Eurydice_arr_1d *uu____0 = &unpacked_public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue = libcrux_ml_kem_utils_into_padded_array_de(seed);
  sample_matrix_A_91(uu____0, &lvalue, false);
}

/**
 Take a serialized private key and generate an unpacked key pair from it.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.keys_from_private_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
*/
void
libcrux_ml_kem_ind_cca_unpacked_keys_from_private_key_01(
  Eurydice_arr_7d *private_key,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_mut_51(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  deserialize_vector_68(ind_cpa_secret_key, &key_pair->private_key.ind_cpa_private_key);
  build_unpacked_public_key_mut_05(ind_cpa_public_key, &key_pair->public_key.ind_cpa_public_key);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value),
    implicit_rejection_value,
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&key_pair->public_key.ind_cpa_public_key.seed_for_A),
    Eurydice_slice_subslice_from_mut_6d(ind_cpa_public_key, (size_t)1152U),
    uint8_t);
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPrivateKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_70
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_bb default_70_68(void)
{
  Eurydice_arr_bb lit;
  Eurydice_arr_9e repeat_expression[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
  memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_9e));
  return lit;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cpa::unpacked::IndCpaPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.unpacked.default_8b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 default_8b_68(void)
{
  Eurydice_arr_bb uu____0;
  Eurydice_arr_9e repeat_expression0[3U];
  KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression0[i] = ZERO_d6_ea(););
  memcpy(uu____0.data, repeat_expression0, (size_t)3U * sizeof (Eurydice_arr_9e));
  Eurydice_arr_ec uu____1 = { .data = { 0U } };
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 lit0;
  lit0.t_as_ntt = uu____0;
  lit0.seed_for_A = uu____1;
  Eurydice_arr_bb repeat_expression1[3U];
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    Eurydice_arr_bb lit;
    Eurydice_arr_9e repeat_expression[3U];
    KRML_MAYBE_FOR3(i, (size_t)0U, (size_t)3U, (size_t)1U, repeat_expression[i] = ZERO_d6_ea(););
    memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_9e));
    repeat_expression1[i0] = lit;);
  memcpy(lit0.A.data, repeat_expression1, (size_t)3U * sizeof (Eurydice_arr_bb));
  return lit0;
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemPublicKeyUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_30
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51
libcrux_ml_kem_ind_cca_unpacked_default_30_68(void)
{
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51){
        .ind_cpa_public_key = default_8b_68(),
        .public_key_hash = { .data = { 0U } }
      }
    );
}

/**
This function found in impl {core::default::Default for libcrux_ml_kem::ind_cca::unpacked::MlKemKeyPairUnpacked<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.default_7b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked
libcrux_ml_kem_ind_cca_unpacked_default_7b_68(void)
{
  libcrux_ml_kem_ind_cca_unpacked_MlKemPrivateKeyUnpacked_51
  uu____0 =
    { .ind_cpa_private_key = default_70_68(), .implicit_rejection_value = { .data = { 0U } } };
  return
    (
      KRML_CLITERAL(libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked){
        .private_key = uu____0,
        .public_key = libcrux_ml_kem_ind_cca_unpacked_default_30_68()
      }
    );
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.G_4a
with const generics
- K= 3
*/
static inline Eurydice_arr_c7 G_4a_78(Eurydice_mut_borrow_slice_u8 input)
{
  return libcrux_ml_kem_hash_functions_portable_G(input);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.cpa_keygen_seed_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_c7
cpa_keygen_seed_39_13(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_fa seed = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d411(&seed,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      )),
    key_generation_seed,
    uint8_t);
  seed.data[LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE] = (uint8_t)(size_t)3U;
  return G_4a_78(Eurydice_array_to_slice_mut_b5(&seed));
}

/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_58 PRFxN_3b(Eurydice_arr_801 *input)
{
  Eurydice_arr_58
  out = { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    libcrux_sha3_portable_shake256(Eurydice_array_to_slice_mut_78(&out.data[i0]),
      Eurydice_array_to_slice_mut_b5(&input->data[i0])););
  return out;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRFxN_4a
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_58 PRFxN_4a_3b(Eurydice_arr_801 *input)
{
  return PRFxN_3b(input);
}

/**
 Sample a vector of ring elements from a centered binomial distribution and
 convert them into their NTT representations.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_vector_cbd_then_ntt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- ETA= 2
- ETA_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE uint8_t
sample_vector_cbd_then_ntt_bf(
  Eurydice_arr_bb *re_as_ntt,
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_4a_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    re_as_ntt->data[i0] = uu____0;
    ntt_binomially_sampled_ring_element_ea(&re_as_ntt->data[i0]););
  return domain_separator;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@3]> for libcrux_ml_kem::ind_cpa::generate_keypair_unpacked::closure<Vector, Hasher, Scheme, K, ETA1, ETA1_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3, TraitClause@4, TraitClause@5]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked.call_mut_73
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_73_39(void **_)
{
  return ZERO_d6_ea();
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_68(Eurydice_arr_9e *myself, Eurydice_arr_9e *rhs)
{
  KRML_MAYBE_FOR16(i,
    (size_t)0U,
    (size_t)16U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_d6
    uu____0 = libcrux_ml_kem_vector_portable_add_b8(myself->data[i0], &rhs->data[i0]);
    myself->data[i0] = uu____0;);
}

/**
 Given two polynomial ring elements `lhs` and `rhs`, compute the pointwise
 sum of their constituent coefficients.
*/
/**
This function found in impl {libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.polynomial.add_to_ring_element_d6
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
add_to_ring_element_d6_68(Eurydice_arr_9e *self, Eurydice_arr_9e *rhs)
{
  add_to_ring_element_68(self, rhs);
}

/**
 Compute  ◦ ŝ + ê
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_As_plus_e
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void
compute_As_plus_e_68(
  Eurydice_arr_bb *t_as_ntt,
  Eurydice_arr_1d *matrix_A,
  Eurydice_arr_bb *s_as_ntt,
  Eurydice_arr_bb *error_as_ntt
)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_bb *row = &matrix_A->data[i0];
    Eurydice_arr_9e uu____0 = ZERO_d6_ea();
    t_as_ntt->data[i0] = uu____0;
    KRML_MAYBE_FOR3(i1,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i1;
      Eurydice_arr_9e *matrix_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(matrix_element, &s_as_ntt->data[j]);
      add_to_ring_element_d6_68(&t_as_ntt->data[i0], &product););
    add_standard_error_reduce_d6_ea(&t_as_ntt->data[i0], &error_as_ntt->data[i0]););
}

/**
 This function implements most of <strong>Algorithm 12</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE key generation algorithm.

 We say "most of" since Algorithm 12 samples the required randomness within
 the function itself, whereas this implementation expects it to be provided
 through the `key_generation_seed` parameter.

 Algorithm 12 is reproduced below:

 ```plaintext
 Output: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Output: decryption key dkₚₖₑ ∈ 𝔹^{384k}.

 d ←$ B
 (ρ,σ) ← G(d)
 N ← 0
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     s[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(σ,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(σ,N))
     N ← N + 1
 end for
 ŝ ← NTT(s)
 ê ← NTT(e)
 t̂ ← Â◦ŝ + ê
 ekₚₖₑ ← ByteEncode₁₂(t̂) ‖ ρ
 dkₚₖₑ ← ByteEncode₁₂(ŝ)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE void
generate_keypair_unpacked_39(
  Eurydice_mut_borrow_slice_u8 key_generation_seed,
  Eurydice_arr_bb *private_key,
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key
)
{
  Eurydice_arr_c7 hashed = cpa_keygen_seed_39_13(key_generation_seed);
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      (size_t)32U,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 seed_for_A = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 seed_for_secret_and_error = uu____0.snd;
  Eurydice_arr_1d *uu____1 = &public_key->A;
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_31 lvalue0 = libcrux_ml_kem_utils_into_padded_array_de(seed_for_A);
  sample_matrix_A_91(uu____1, &lvalue0, true);
  Eurydice_arr_fa
  prf_input = libcrux_ml_kem_utils_into_padded_array_29(seed_for_secret_and_error);
  uint8_t domain_separator = sample_vector_cbd_then_ntt_bf(private_key, &prf_input, 0U);
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_73_39(&lvalue););
  Eurydice_arr_bb error_as_ntt = arr_struct;
  sample_vector_cbd_then_ntt_bf(&error_as_ntt, &prf_input, domain_separator);
  compute_As_plus_e_68(&public_key->t_as_ntt, &public_key->A, private_key, &error_as_ntt);
  Eurydice_arr_ec arr;
  memcpy(arr.data, seed_for_A.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____2 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  public_key->seed_for_A = uu____2;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.closure.call_mut_b4
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_b4_68(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), [libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]; K]> for libcrux_ml_kem::ind_cca::unpacked::transpose_a::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a.call_mut_22
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_bb call_mut_22_68(void **_)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_b4_68(&lvalue););
  return arr_struct;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.transpose_a
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_1d transpose_a_68(Eurydice_arr_1d ind_cpa_a)
{
  Eurydice_arr_1d arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_22_68(&lvalue););
  Eurydice_arr_1d A = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e uu____0 = clone_c1_ea(&ind_cpa_a.data[j].data[i1]);
      A.data[i1].data[j] = uu____0;););
  return A;
}

/**
 Generate Unpacked Keys
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
void
libcrux_ml_kem_ind_cca_unpacked_generate_keypair_b8(
  Eurydice_arr_c7 randomness,
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *out
)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(&randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(&randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  generate_keypair_unpacked_39(ind_cpa_keypair_randomness,
    &out->private_key.ind_cpa_private_key,
    &out->public_key.ind_cpa_public_key);
  Eurydice_arr_1d A = transpose_a_68(out->public_key.ind_cpa_public_key.A);
  out->public_key.ind_cpa_public_key.A = A;
  Eurydice_arr_5f
  pk_serialized =
    serialize_public_key_b6(&out->public_key.ind_cpa_public_key.t_as_ntt,
      Eurydice_array_to_slice_mut_01(&out->public_key.ind_cpa_public_key.seed_for_A));
  Eurydice_arr_ec uu____0 = H_4a_78(Eurydice_array_to_slice_mut_ff(&pk_serialized));
  out->public_key.public_key_hash = uu____0;
  Eurydice_arr_ec arr;
  memcpy(arr.data, implicit_rejection_value.ptr, (size_t)32U * sizeof (uint8_t));
  Eurydice_arr_ec
  uu____1 =
    core_result_unwrap_26_39((
        KRML_CLITERAL(core_result_Result_07){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  out->private_key.implicit_rejection_value = uu____1;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encaps_prepare
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static Eurydice_arr_c7
encaps_prepare_13(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_mut_borrow_slice_u8 pk_hash
)
{
  Eurydice_arr_c7 to_hash = libcrux_ml_kem_utils_into_padded_array_c9(randomness);
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE),
    pk_hash,
    uint8_t);
  return G_4a_78(Eurydice_array_to_slice_mut_17(&to_hash));
}

/**
A monomorphic instance of n-tuple
with types Eurydice_arr_bb, libcrux_ml_kem_polynomial_PolynomialRingElement_1d

*/
typedef struct tuple_5b_s
{
  Eurydice_arr_bb fst;
  Eurydice_arr_9e snd;
}
tuple_5b;

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_f1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_f1_87(void **_)
{
  return ZERO_d6_ea();
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@2]> for libcrux_ml_kem::ind_cpa::encrypt_c1::closure#1<Vector, Hasher, K, C1_LEN, U_COMPRESSION_FACTOR, BLOCK_LEN, ETA1, ETA1_RANDOMNESS_SIZE, ETA2, ETA2_RANDOMNESS_SIZE>[TraitClause@0, TraitClause@1, TraitClause@2, TraitClause@3]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1.call_mut_dd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static Eurydice_arr_9e call_mut_dd_87(void **_)
{
  return ZERO_d6_ea();
}

/**
 Sample a vector of ring elements from a centered binomial distribution.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.sample_ring_element_cbd
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- ETA2_RANDOMNESS_SIZE= 128
- ETA2= 2
*/
static KRML_MUSTINLINE uint8_t
sample_ring_element_cbd_bf(
  Eurydice_arr_fa *prf_input,
  uint8_t domain_separator,
  Eurydice_arr_bb *error_1
)
{
  Eurydice_arr_801 prf_inputs;
  Eurydice_arr_fa repeat_expression[3U];
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    repeat_expression[i] =
      core_array__core__clone__Clone_for__T__N___clone((size_t)33U,
        prf_input,
        uint8_t,
        Eurydice_arr_fa););
  memcpy(prf_inputs.data, repeat_expression, (size_t)3U * sizeof (Eurydice_arr_fa));
  domain_separator = libcrux_ml_kem_utils_prf_input_inc_78(&prf_inputs, domain_separator);
  Eurydice_arr_58 prf_outputs = PRFxN_4a_3b(&prf_inputs);
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e
    uu____0 =
      sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_outputs.data[i0]));
    error_1->data[i0] = uu____0;);
  return domain_separator;
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 3
- LEN= 128
*/
static inline Eurydice_arr_89 PRF_4a_3b0(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ec(input);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::matrix::compute_vector_u::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u.call_mut_a8
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_a8_68(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.invert_ntt.invert_ntt_montgomery
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE void invert_ntt_montgomery_68(Eurydice_arr_9e *re)
{
  size_t zeta_i = LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT / (size_t)2U;
  invert_ntt_at_layer_1_ea(&zeta_i, re);
  invert_ntt_at_layer_2_ea(&zeta_i, re);
  invert_ntt_at_layer_3_ea(&zeta_i, re);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)4U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)5U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)6U);
  invert_ntt_at_layer_4_plus_ea(&zeta_i, re, (size_t)7U);
  poly_barrett_reduce_d6_ea(re);
}

/**
 Compute u := InvertNTT(Aᵀ ◦ r̂) + e₁
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_vector_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb
compute_vector_u_68(
  Eurydice_arr_1d *a_as_ntt,
  Eurydice_arr_bb *r_as_ntt,
  Eurydice_arr_bb *error_1
)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_a8_68(&lvalue););
  Eurydice_arr_bb result = arr_struct;
  KRML_MAYBE_FOR3(i0,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i1 = i0;
    Eurydice_arr_bb *row = &a_as_ntt->data[i1];
    KRML_MAYBE_FOR3(i,
      (size_t)0U,
      (size_t)3U,
      (size_t)1U,
      size_t j = i;
      Eurydice_arr_9e *a_element = &row->data[j];
      Eurydice_arr_9e product = ntt_multiply_d6_ea(a_element, &r_as_ntt->data[j]);
      add_to_ring_element_d6_68(&result.data[i1], &product););
    invert_ntt_montgomery_68(&result.data[i1]);
    add_error_reduce_d6_ea(&result.data[i1], &error_1->data[i1]););
  return result;
}

/**
 Call [`compress_then_serialize_ring_element_u`] on each ring element.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.compress_then_serialize_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- OUT_LEN= 960
- COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
*/
static KRML_MUSTINLINE void
compress_then_serialize_u_21(Eurydice_arr_bb input, Eurydice_mut_borrow_slice_u8 out)
{
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e re = input.data[i0];
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 * ((size_t)960U / (size_t)3U),
            .end = (i0 + (size_t)1U) * ((size_t)960U / (size_t)3U)
          }
        ));
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_b0 lvalue = compress_then_serialize_ring_element_u_f7(&re);
    Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_56(&lvalue), uint8_t););
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c1
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- C1_LEN= 960
- U_COMPRESSION_FACTOR= 10
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE tuple_5b
encrypt_c1_87(
  Eurydice_mut_borrow_slice_u8 randomness,
  Eurydice_arr_1d *matrix,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_fa prf_input = libcrux_ml_kem_utils_into_padded_array_29(randomness);
  Eurydice_arr_bb arr_struct0;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct0.data[i] = call_mut_f1_87(&lvalue););
  Eurydice_arr_bb r_as_ntt = arr_struct0;
  uint8_t domain_separator0 = sample_vector_cbd_then_ntt_bf(&r_as_ntt, &prf_input, 0U);
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_dd_87(&lvalue););
  Eurydice_arr_bb error_1 = arr_struct;
  uint8_t domain_separator = sample_ring_element_cbd_bf(&prf_input, domain_separator0, &error_1);
  prf_input.data[32U] = domain_separator;
  Eurydice_arr_89 prf_output = PRF_4a_3b0(Eurydice_array_to_slice_mut_b5(&prf_input));
  Eurydice_arr_9e
  error_2 = sample_from_binomial_distribution_66(Eurydice_array_to_slice_mut_78(&prf_output));
  Eurydice_arr_bb u = compute_vector_u_68(matrix, &r_as_ntt, &error_1);
  compress_then_serialize_u_21(u, ciphertext);
  return (KRML_CLITERAL(tuple_5b){ .fst = r_as_ntt, .snd = error_2 });
}

/**
 Compute InverseNTT(tᵀ ◦ r̂) + e₂ + message
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_ring_element_v_68(
  Eurydice_arr_bb *t_as_ntt,
  Eurydice_arr_bb *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_9e *message
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&t_as_ntt->data[i0], &r_as_ntt->data[i0]);
    add_to_ring_element_d6_68(&result, &product););
  invert_ntt_montgomery_68(&result);
  return add_message_error_reduce_d6_ea(error_2, message, result);
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.compress_then_serialize_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
- OUT_LEN= 128
*/
static KRML_MUSTINLINE void
compress_then_serialize_ring_element_v_30(Eurydice_arr_9e re, Eurydice_mut_borrow_slice_u8 out)
{
  compress_then_serialize_4_ea(re, out);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_c2
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- V_COMPRESSION_FACTOR= 4
- C2_LEN= 128
*/
static KRML_MUSTINLINE void
encrypt_c2_30(
  Eurydice_arr_bb *t_as_ntt,
  Eurydice_arr_bb *r_as_ntt,
  Eurydice_arr_9e *error_2,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 ciphertext
)
{
  Eurydice_arr_9e message_as_ring_element = deserialize_then_decompress_message_ea(message);
  Eurydice_arr_9e
  v = compute_ring_element_v_68(t_as_ntt, r_as_ntt, error_2, &message_as_ring_element);
  compress_then_serialize_ring_element_v_30(v, ciphertext);
}

/**
 This function implements <strong>Algorithm 13</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE encryption algorithm.

 Algorithm 13 is reproduced below:

 ```plaintext
 Input: encryption key ekₚₖₑ ∈ 𝔹^{384k+32}.
 Input: message m ∈ 𝔹^{32}.
 Input: encryption randomness r ∈ 𝔹^{32}.
 Output: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.

 N ← 0
 t̂ ← ByteDecode₁₂(ekₚₖₑ[0:384k])
 ρ ← ekₚₖₑ[384k: 384k + 32]
 for (i ← 0; i < k; i++)
     for(j ← 0; j < k; j++)
         Â[i,j] ← SampleNTT(XOF(ρ, i, j))
     end for
 end for
 for(i ← 0; i < k; i++)
     r[i] ← SamplePolyCBD_{η₁}(PRF_{η₁}(r,N))
     N ← N + 1
 end for
 for(i ← 0; i < k; i++)
     e₁[i] ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
     N ← N + 1
 end for
 e₂ ← SamplePolyCBD_{η₂}(PRF_{η₂}(r,N))
 r̂ ← NTT(r)
 u ← NTT-¹(Âᵀ ◦ r̂) + e₁
 μ ← Decompress₁(ByteDecode₁(m)))
 v ← NTT-¹(t̂ᵀ ◦ rˆ) + e₂ + μ
 c₁ ← ByteEncode_{dᵤ}(Compress_{dᵤ}(u))
 c₂ ← ByteEncode_{dᵥ}(Compress_{dᵥ}(v))
 return c ← (c₁ ‖ c₂)
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_unpacked_d5(
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  Eurydice_arr_2b ciphertext = { .data = { 0U } };
  tuple_5b
  uu____0 =
    encrypt_c1_87(randomness,
      &public_key->A,
      Eurydice_array_to_subslice_mut_d415(&ciphertext,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)960U })));
  Eurydice_arr_bb r_as_ntt = uu____0.fst;
  Eurydice_arr_9e error_2 = uu____0.snd;
  encrypt_c2_30(&public_key->t_as_ntt,
    &r_as_ntt,
    &error_2,
    message,
    Eurydice_array_to_subslice_from_mut_5f2(&ciphertext, (size_t)960U));
  return ciphertext;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- VECTOR_U_BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_unpacked_encapsulate_a7(
  libcrux_ml_kem_ind_cca_unpacked_MlKemPublicKeyUnpacked_51 *public_key,
  Eurydice_arr_ec *randomness
)
{
  Eurydice_arr_c7
  hashed =
    encaps_prepare_13(Eurydice_array_to_slice_mut_01(randomness),
      Eurydice_array_to_slice_mut_01(&public_key->public_key_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____0 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____0.snd;
  Eurydice_arr_2b
  ciphertext = encrypt_unpacked_d5(&public_key->ind_cpa_public_key, randomness, pseudorandomness);
  Eurydice_arr_ec shared_secret_array = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&shared_secret_array),
    shared_secret,
    uint8_t);
  return
    (
      KRML_CLITERAL(tuple_f4){
        .fst = libcrux_ml_kem_types_from_19_52(ciphertext),
        .snd = shared_secret_array
      }
    );
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::deserialize_then_decompress_u::closure<Vector, K, CIPHERTEXT_SIZE, U_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u.call_mut_35
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static Eurydice_arr_9e call_mut_35_30(void **_)
{
  return ZERO_d6_ea();
}

/**
 Call [`deserialize_then_decompress_ring_element_u`] on each ring element
 in the `ciphertext`.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.deserialize_then_decompress_u
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- U_COMPRESSION_FACTOR= 10
*/
static KRML_MUSTINLINE Eurydice_arr_bb
deserialize_then_decompress_u_30(Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_35_30(&lvalue););
  Eurydice_arr_bb u_as_ntt = arr_struct;
  for
  (size_t
    i = (size_t)0U;
    i <
      (size_t)1088U /
        (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U);
    i++)
  {
    size_t i0 = i;
    Eurydice_mut_borrow_slice_u8
    u_bytes =
      Eurydice_array_to_subslice_mut_d415(ciphertext,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U),
            .end = i0 *
              (LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U)
            + LIBCRUX_ML_KEM_CONSTANTS_COEFFICIENTS_IN_RING_ELEMENT * (size_t)10U / (size_t)8U
          }
        ));
    u_as_ntt.data[i0] = deserialize_then_decompress_ring_element_u_f7(u_bytes);
    ntt_vector_u_f7(&u_as_ntt.data[i0]);
  }
  return u_as_ntt;
}

/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_then_decompress_ring_element_v
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_9e
deserialize_then_decompress_ring_element_v_b6(Eurydice_mut_borrow_slice_u8 serialized)
{
  return deserialize_then_decompress_4_ea(serialized);
}

/**
 The following functions compute various expressions involving
 vectors and matrices. The computation of these expressions has been
 abstracted away into these functions in order to save on loop iterations.
 Compute v − InverseNTT(sᵀ ◦ NTT(u))
*/
/**
A monomorphic instance of libcrux_ml_kem.matrix.compute_message
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_9e
compute_message_68(
  Eurydice_arr_9e *v,
  Eurydice_arr_bb *secret_as_ntt,
  Eurydice_arr_bb *u_as_ntt
)
{
  Eurydice_arr_9e result = ZERO_d6_ea();
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_arr_9e product = ntt_multiply_d6_ea(&secret_as_ntt->data[i0], &u_as_ntt->data[i0]);
    add_to_ring_element_d6_68(&result, &product););
  invert_ntt_montgomery_68(&result);
  return subtract_reduce_d6_ea(v, result);
}

/**
 This function implements <strong>Algorithm 14</strong> of the
 NIST FIPS 203 specification; this is the Kyber CPA-PKE decryption algorithm.

 Algorithm 14 is reproduced below:

 ```plaintext
 Input: decryption key dkₚₖₑ ∈ 𝔹^{384k}.
 Input: ciphertext c ∈ 𝔹^{32(dᵤk + dᵥ)}.
 Output: message m ∈ 𝔹^{32}.

 c₁ ← c[0 : 32dᵤk]
 c₂ ← c[32dᵤk : 32(dᵤk + dᵥ)]
 u ← Decompress_{dᵤ}(ByteDecode_{dᵤ}(c₁))
 v ← Decompress_{dᵥ}(ByteDecode_{dᵥ}(c₂))
 ŝ ← ByteDecode₁₂(dkₚₖₑ)
 w ← v - NTT-¹(ŝᵀ ◦ NTT(u))
 m ← ByteEncode₁(Compress₁(w))
 return m
 ```

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt_unpacked
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_unpacked_01(Eurydice_arr_bb *secret_key, Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb u_as_ntt = deserialize_then_decompress_u_30(ciphertext);
  Eurydice_arr_9e
  v =
    deserialize_then_decompress_ring_element_v_b6(Eurydice_array_to_subslice_from_mut_5f2(ciphertext,
        (size_t)960U));
  Eurydice_arr_9e message = compute_message_68(&v, secret_key, &u_as_ntt);
  return compress_then_serialize_message_ea(message);
}

/**
This function found in impl {libcrux_ml_kem::hash_functions::Hash<K> for libcrux_ml_kem::hash_functions::portable::PortableHash<K>}
*/
/**
A monomorphic instance of libcrux_ml_kem.hash_functions.portable.PRF_4a
with const generics
- K= 3
- LEN= 32
*/
static inline Eurydice_arr_ec PRF_4a_3b(Eurydice_mut_borrow_slice_u8 input)
{
  return PRF_ce(input);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.unpacked.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_unpacked_decapsulate_0c(
  libcrux_ml_kem_mlkem768_portable_unpacked_MlKem768KeyPairUnpacked *key_pair,
  Eurydice_arr_2b *ciphertext
)
{
  Eurydice_arr_ec
  decrypted = decrypt_unpacked_01(&key_pair->private_key.ind_cpa_private_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____0,
    Eurydice_array_to_slice_mut_01(&key_pair->public_key.public_key_hash),
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_66(Eurydice_array_to_slice_mut_01(&key_pair->private_key.implicit_rejection_value));
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f3(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_3b(Eurydice_array_to_slice_mut_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext =
    encrypt_unpacked_d5(&key_pair->public_key.ind_cpa_public_key,
      &decrypted,
      pseudorandomness);
  Eurydice_mut_borrow_slice_u8 uu____3 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  uint8_t
  selector =
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_in_constant_time(uu____3,
      Eurydice_array_to_slice_mut_06(&expected_ciphertext));
  return
    libcrux_ml_kem_constant_time_ops_select_shared_secret_in_constant_time(shared_secret,
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret),
      selector);
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::serialize::deserialize_ring_elements_reduced_out::closure<Vector, K>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static Eurydice_arr_9e call_mut_0b_68(void **_)
{
  return ZERO_d6_ea();
}

/**
 This function deserializes ring elements and reduces the result by the field
 modulus.

 This function MUST NOT be used on secret inputs.
*/
/**
A monomorphic instance of libcrux_ml_kem.serialize.deserialize_ring_elements_reduced_out
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_bb
deserialize_ring_elements_reduced_out_68(Eurydice_mut_borrow_slice_u8 public_key)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_68(&lvalue););
  Eurydice_arr_bb deserialized_pk = arr_struct;
  deserialize_ring_elements_reduced_68(public_key, &deserialized_pk);
  return deserialized_pk;
}

/**
 Validate an ML-KEM public key.

 This implements the Modulus check in 7.2 2.
 Note that the size check in 7.2 1 is covered by the `PUBLIC_KEY_SIZE` in the
 `public_key` type.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- PUBLIC_KEY_SIZE= 1184
*/
bool libcrux_ml_kem_ind_cca_validate_public_key_b6(Eurydice_arr_5f *public_key)
{
  Eurydice_arr_bb
  deserialized_pk =
    deserialize_ring_elements_reduced_out_68(Eurydice_array_to_subslice_to_mut_211(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  Eurydice_arr_5f
  public_key_serialized =
    serialize_public_key_b6(&deserialized_pk,
      Eurydice_array_to_subslice_from_mut_5f4(public_key,
        libcrux_ml_kem_constants_ranked_bytes_per_ring_element((size_t)3U)));
  return Eurydice_array_eq((size_t)1184U, public_key, &public_key_serialized, uint8_t);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key_only
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
*/
bool libcrux_ml_kem_ind_cca_validate_private_key_only_52(Eurydice_arr_7d *private_key)
{
  Eurydice_arr_ec
  t =
    H_4a_78(Eurydice_array_to_subslice_mut_d418(private_key,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = (size_t)384U * (size_t)3U,
            .end = (size_t)768U * (size_t)3U + (size_t)32U
          }
        )));
  Eurydice_mut_borrow_slice_u8
  expected =
    Eurydice_array_to_subslice_mut_d418(private_key,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)768U * (size_t)3U + (size_t)32U,
          .end = (size_t)768U * (size_t)3U + (size_t)64U
        }
      ));
  return Eurydice_array_eq_slice_mut((size_t)32U, &t, &expected, uint8_t, bool);
}

/**
 Validate an ML-KEM private key.

 This implements the Hash check in 7.3 3.
 Note that the size checks in 7.2 1 and 2 are covered by the `SECRET_KEY_SIZE`
 and `CIPHERTEXT_SIZE` in the `private_key` and `ciphertext` types.
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.validate_private_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CIPHERTEXT_SIZE= 1088
*/
bool
libcrux_ml_kem_ind_cca_validate_private_key_ba(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *_ciphertext
)
{
  return libcrux_ml_kem_ind_cca_validate_private_key_only_52(private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- PRIVATE_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE libcrux_ml_kem_utils_extraction_helper_Keypair768
generate_keypair_30(Eurydice_mut_borrow_slice_u8 key_generation_seed)
{
  Eurydice_arr_bb private_key = default_70_68();
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51 public_key = default_8b_68();
  generate_keypair_unpacked_39(key_generation_seed, &private_key, &public_key);
  return serialize_unpacked_secret_key_30(&public_key, &private_key);
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.serialize_kem_secret_key
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- SERIALIZED_KEY_LEN= 2400
*/
static KRML_MUSTINLINE Eurydice_arr_7d
serialize_kem_secret_key_52(
  Eurydice_mut_borrow_slice_u8 private_key,
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value
)
{
  Eurydice_arr_7d out = { .data = { 0U } };
  libcrux_ml_kem_ind_cca_serialize_kem_secret_key_mut_52(private_key,
    public_key,
    implicit_rejection_value,
    &out);
  return out;
}

/**
 Packed API

 Generate a key pair.

 Depending on the `Vector` and `Hasher` used, this requires different hardware
 features
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.generate_keypair
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CPA_PRIVATE_KEY_SIZE= 1152
- PRIVATE_KEY_SIZE= 2400
- PUBLIC_KEY_SIZE= 1184
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
*/
libcrux_ml_kem_mlkem768_MlKem768KeyPair
libcrux_ml_kem_ind_cca_generate_keypair_b8(Eurydice_arr_c7 *randomness)
{
  Eurydice_mut_borrow_slice_u8
  ind_cpa_keypair_randomness =
    Eurydice_array_to_subslice_mut_d47(randomness,
      (
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE
        }
      ));
  Eurydice_mut_borrow_slice_u8
  implicit_rejection_value =
    Eurydice_array_to_subslice_from_mut_5f0(randomness,
      LIBCRUX_ML_KEM_CONSTANTS_CPA_PKE_KEY_GENERATION_SEED_SIZE);
  libcrux_ml_kem_utils_extraction_helper_Keypair768
  uu____0 = generate_keypair_30(ind_cpa_keypair_randomness);
  Eurydice_arr_0e ind_cpa_private_key = uu____0.fst;
  Eurydice_arr_5f public_key = uu____0.snd;
  Eurydice_arr_7d
  secret_key_serialized =
    serialize_kem_secret_key_52(Eurydice_array_to_slice_mut_f4(&ind_cpa_private_key),
      Eurydice_array_to_slice_mut_ff(&public_key),
      implicit_rejection_value);
  Eurydice_arr_7d private_key = libcrux_ml_kem_types_from_b2_79(secret_key_serialized);
  return
    libcrux_ml_kem_types_from_17_bc(private_key,
      libcrux_ml_kem_types_from_51_3d(public_key));
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.entropy_preprocess_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
*/
static KRML_MUSTINLINE Eurydice_arr_ec
entropy_preprocess_39_13(Eurydice_mut_borrow_slice_u8 randomness)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), randomness, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.build_unpacked_public_key
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- T_AS_NTT_ENCODED_SIZE= 1152
*/
static KRML_MUSTINLINE libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
build_unpacked_public_key_05(Eurydice_mut_borrow_slice_u8 public_key)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  unpacked_public_key = default_8b_68();
  build_unpacked_public_key_mut_05(public_key, &unpacked_public_key);
  return unpacked_public_key;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.encrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_LEN= 960
- C2_LEN= 128
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
- BLOCK_LEN= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
static KRML_MUSTINLINE Eurydice_arr_2b
encrypt_d5(
  Eurydice_mut_borrow_slice_u8 public_key,
  Eurydice_arr_ec *message,
  Eurydice_mut_borrow_slice_u8 randomness
)
{
  libcrux_ml_kem_ind_cpa_unpacked_IndCpaPublicKeyUnpacked_51
  unpacked_public_key = build_unpacked_public_key_05(public_key);
  return encrypt_unpacked_d5(&unpacked_public_key, message, randomness);
}

/**
This function found in impl {libcrux_ml_kem::variant::Variant for libcrux_ml_kem::variant::MlKem}
*/
/**
A monomorphic instance of libcrux_ml_kem.variant.kdf_39
with types libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]]
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
*/
static KRML_MUSTINLINE Eurydice_arr_ec kdf_39_52(Eurydice_mut_borrow_slice_u8 shared_secret)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_slice_mut_01(&out), shared_secret, uint8_t);
  return out;
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cca.encapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- PUBLIC_KEY_SIZE= 1184
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
*/
tuple_f4
libcrux_ml_kem_ind_cca_encapsulate_99(Eurydice_arr_5f *public_key, Eurydice_arr_ec *randomness)
{
  Eurydice_arr_ec
  randomness0 = entropy_preprocess_39_13(Eurydice_array_to_slice_mut_01(randomness));
  Eurydice_arr_c7
  to_hash =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&randomness0));
  Eurydice_mut_borrow_slice_u8
  uu____0 =
    Eurydice_array_to_subslice_from_mut_5f0(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_SIZE);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_ec
  lvalue =
    H_4a_78(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)));
  Eurydice_slice_copy(uu____0, Eurydice_array_to_slice_mut_01(&lvalue), uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_mut_17(&to_hash));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_2b
  ciphertext =
    encrypt_d5(Eurydice_array_to_slice_mut_ff(libcrux_ml_kem_types_as_slice_e6_3d(public_key)),
      &randomness0,
      pseudorandomness);
  Eurydice_arr_2b uu____2 = libcrux_ml_kem_types_from_19_52(ciphertext);
  return (KRML_CLITERAL(tuple_f4){ .fst = uu____2, .snd = kdf_39_52(shared_secret) });
}

/**
This function found in impl {core::ops::function::FnMut<(usize), libcrux_ml_kem::polynomial::PolynomialRingElement<Vector>[TraitClause@0, TraitClause@1]> for libcrux_ml_kem::ind_cpa::decrypt::closure<Vector, K, CIPHERTEXT_SIZE, VECTOR_U_ENCODED_SIZE, U_COMPRESSION_FACTOR, V_COMPRESSION_FACTOR>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt.call_mut_0b
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static Eurydice_arr_9e call_mut_0b_01(void **_)
{
  return ZERO_d6_ea();
}

/**
A monomorphic instance of libcrux_ml_kem.ind_cpa.decrypt
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector
with const generics
- K= 3
- CIPHERTEXT_SIZE= 1088
- VECTOR_U_ENCODED_SIZE= 960
- U_COMPRESSION_FACTOR= 10
- V_COMPRESSION_FACTOR= 4
*/
static KRML_MUSTINLINE Eurydice_arr_ec
decrypt_01(Eurydice_mut_borrow_slice_u8 secret_key, Eurydice_arr_2b *ciphertext)
{
  Eurydice_arr_bb arr_struct;
  KRML_MAYBE_FOR3(i,
    (size_t)0U,
    (size_t)3U,
    (size_t)1U,
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[i] = call_mut_0b_01(&lvalue););
  Eurydice_arr_bb secret_key_unpacked = arr_struct;
  deserialize_vector_68(secret_key, &secret_key_unpacked);
  return decrypt_unpacked_01(&secret_key_unpacked, ciphertext);
}

/**
 This code verifies on some machines, runs out of memory on others
*/
/**
A monomorphic instance of libcrux_ml_kem.ind_cca.decapsulate
with types libcrux_ml_kem_vector_portable_vector_type_PortableVector, libcrux_ml_kem_hash_functions_portable_PortableHash[[$3size_t]], libcrux_ml_kem_variant_MlKem
with const generics
- K= 3
- SECRET_KEY_SIZE= 2400
- CPA_SECRET_KEY_SIZE= 1152
- PUBLIC_KEY_SIZE= 1184
- CIPHERTEXT_SIZE= 1088
- T_AS_NTT_ENCODED_SIZE= 1152
- C1_SIZE= 960
- C2_SIZE= 128
- VECTOR_U_COMPRESSION_FACTOR= 10
- VECTOR_V_COMPRESSION_FACTOR= 4
- C1_BLOCK_SIZE= 320
- ETA1= 2
- ETA1_RANDOMNESS_SIZE= 128
- ETA2= 2
- ETA2_RANDOMNESS_SIZE= 128
- IMPLICIT_REJECTION_HASH_INPUT_SIZE= 1120
*/
Eurydice_arr_ec
libcrux_ml_kem_ind_cca_decapsulate_fd(
  Eurydice_arr_7d *private_key,
  Eurydice_arr_2b *ciphertext
)
{
  Eurydice_mut_borrow_slice_u8_x4
  uu____0 =
    libcrux_ml_kem_types_unpack_private_key_64(Eurydice_array_to_slice_mut_51(private_key));
  Eurydice_mut_borrow_slice_u8 ind_cpa_secret_key = uu____0.fst;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key = uu____0.snd;
  Eurydice_mut_borrow_slice_u8 ind_cpa_public_key_hash = uu____0.thd;
  Eurydice_mut_borrow_slice_u8 implicit_rejection_value = uu____0.f3;
  Eurydice_arr_ec decrypted = decrypt_01(ind_cpa_secret_key, ciphertext);
  Eurydice_arr_c7
  to_hash0 =
    libcrux_ml_kem_utils_into_padded_array_c9(Eurydice_array_to_slice_mut_01(&decrypted));
  Eurydice_slice_copy(Eurydice_array_to_subslice_from_mut_5f0(&to_hash0,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE),
    ind_cpa_public_key_hash,
    uint8_t);
  Eurydice_arr_c7 hashed = G_4a_78(Eurydice_array_to_slice_mut_17(&to_hash0));
  Eurydice_mut_borrow_slice_u8_x2
  uu____1 =
    Eurydice_slice_split_at(Eurydice_array_to_slice_mut_17(&hashed),
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE,
      uint8_t,
      Eurydice_mut_borrow_slice_u8_x2);
  Eurydice_mut_borrow_slice_u8 shared_secret0 = uu____1.fst;
  Eurydice_mut_borrow_slice_u8 pseudorandomness = uu____1.snd;
  Eurydice_arr_af to_hash = libcrux_ml_kem_utils_into_padded_array_66(implicit_rejection_value);
  Eurydice_mut_borrow_slice_u8
  uu____2 =
    Eurydice_array_to_subslice_from_mut_5f3(&to_hash,
      LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE);
  Eurydice_slice_copy(uu____2, libcrux_ml_kem_types_as_ref_c1_52(ciphertext), uint8_t);
  Eurydice_arr_ec
  implicit_rejection_shared_secret = PRF_4a_3b(Eurydice_array_to_slice_mut_81(&to_hash));
  Eurydice_arr_2b
  expected_ciphertext = encrypt_d5(ind_cpa_public_key, &decrypted, pseudorandomness);
  Eurydice_mut_borrow_slice_u8
  uu____3 = Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret);
  Eurydice_arr_ec implicit_rejection_shared_secret0 = kdf_39_52(uu____3);
  Eurydice_arr_ec shared_secret = kdf_39_52(shared_secret0);
  Eurydice_mut_borrow_slice_u8 uu____4 = libcrux_ml_kem_types_as_ref_c1_52(ciphertext);
  return
    libcrux_ml_kem_constant_time_ops_compare_ciphertexts_select_shared_secret_in_constant_time(uu____4,
      Eurydice_array_to_slice_mut_06(&expected_ciphertext),
      Eurydice_array_to_slice_mut_01(&shared_secret),
      Eurydice_array_to_slice_mut_01(&implicit_rejection_shared_secret0));
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_mlkem_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_mlkem_portable_H
#define libcrux_mlkem_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

Eurydice_arr_c7 libcrux_ml_kem_hash_functions_portable_G(Eurydice_mut_borrow_slice_u8 input);

Eurydice_arr_ec libcrux_ml_kem_hash_functions_portable_H(Eurydice_mut_borrow_slice_u8 input);

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_ELEMENTS_IN_VECTOR ((size_t)16U)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_MONTGOMERY_R_SQUARED_MOD_FIELD_MODULUS (1353)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_FIELD_MODULUS (3329)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_INVERSE_OF_MODULUS_MOD_MONTGOMERY_R (62209U)

typedef Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_PortableVector;

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_i16_array(Eurydice_mut_borrow_slice_i16 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_i16_array_b8(Eurydice_mut_borrow_slice_i16 array);

typedef struct uint8_t_x11_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
  uint8_t f4;
  uint8_t f5;
  uint8_t f6;
  uint8_t f7;
  uint8_t f8;
  uint8_t f9;
  uint8_t f10;
}
uint8_t_x11;

uint8_t_x11
libcrux_ml_kem_vector_portable_serialize_serialize_11_int(Eurydice_mut_borrow_slice_i16 v);

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_serialize_11(Eurydice_arr_d6 v);

Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_80 libcrux_ml_kem_vector_portable_serialize_11_b8(Eurydice_arr_d6 a);

typedef struct int16_t_x8_s
{
  int16_t fst;
  int16_t snd;
  int16_t thd;
  int16_t f3;
  int16_t f4;
  int16_t f5;
  int16_t f6;
  int16_t f7;
}
int16_t_x8;

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_11_int(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_11(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_11(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_11_b8(Eurydice_mut_borrow_slice_u8 a);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_to_i16_array(Eurydice_arr_d6 x);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_to_i16_array_b8(Eurydice_arr_d6 x);

#define LIBCRUX_ML_KEM_VECTOR_REJ_SAMPLE_TABLE_REJECTION_SAMPLE_SHUFFLE_TABLE ((KRML_CLITERAL(Eurydice_arr_87){ .data = { { .data = { 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U } }, { .data = { 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U } }, { .data = { 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U } }, { .data = { 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U } } } }))

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_zero(void);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_ZERO_b8(void);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_vector_type_from_bytes(Eurydice_mut_borrow_slice_u8 array);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_from_bytes_b8(Eurydice_mut_borrow_slice_u8 array);

void
libcrux_ml_kem_vector_portable_vector_type_to_bytes(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
void
libcrux_ml_kem_vector_portable_to_bytes_b8(
  Eurydice_arr_d6 x,
  Eurydice_mut_borrow_slice_u8 bytes
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_add(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_add_b8(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_sub(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_sub_b8(Eurydice_arr_d6 lhs, Eurydice_arr_d6 *rhs);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_multiply_by_constant(Eurydice_arr_d6 vec, int16_t c);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_multiply_by_constant_b8(Eurydice_arr_d6 vec, int16_t c);

/**
 Note: This function is not secret independent
 Only use with public values.
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_cond_subtract_3329(Eurydice_arr_d6 vec);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_cond_subtract_3329_b8(Eurydice_arr_d6 v);

#define LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_BARRETT_MULTIPLIER (20159)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT (26)

#define LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_R ((int32_t)((uint32_t)1 << (uint32_t)LIBCRUX_ML_KEM_VECTOR_TRAITS_BARRETT_SHIFT))

/**
 Signed Barrett Reduction

 Given an input `value`, `barrett_reduce` outputs a representative `result`
 such that:

 - result ≡ value (mod FIELD_MODULUS)
 - the absolute value of `result` is bound as follows:

 `|result| ≤ FIELD_MODULUS / 2 · (|value|/BARRETT_R + 1)

 Note: The input bound is 28296 to prevent overflow in the multiplication of quotient by FIELD_MODULUS

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce_element(int16_t value);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_arithmetic_barrett_reduce(Eurydice_arr_d6 vec);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_barrett_reduce_b8(Eurydice_arr_d6 vector);

#define LIBCRUX_ML_KEM_VECTOR_PORTABLE_ARITHMETIC_MONTGOMERY_SHIFT (16U)

/**
 Signed Montgomery Reduction

 Given an input `value`, `montgomery_reduce` outputs a representative `o`
 such that:

 - o ≡ value · MONTGOMERY_R^(-1) (mod FIELD_MODULUS)
 - the absolute value of `o` is bound as follows:

 `|result| ≤ ceil(|value| / MONTGOMERY_R) + 1665

 In particular, if `|value| ≤ FIELD_MODULUS-1 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS-1`.
 And, if `|value| ≤ pow2 16 * FIELD_MODULUS-1`, then `|o| <= FIELD_MODULUS + 1664

*/
int16_t libcrux_ml_kem_vector_portable_arithmetic_montgomery_reduce_element(int32_t value);

/**
 If `fe` is some field element 'x' of the Kyber field and `fer` is congruent to
 `y · MONTGOMERY_R`, this procedure outputs a value that is congruent to
 `x · y`, as follows:

    `fe · fer ≡ x · y · MONTGOMERY_R (mod FIELD_MODULUS)`

 `montgomery_reduce` takes the value `x · y · MONTGOMERY_R` and outputs a representative
 `x · y · MONTGOMERY_R * MONTGOMERY_R^{-1} ≡ x · y (mod FIELD_MODULUS)`.
*/
int16_t
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_fe_by_fer(
  int16_t fe,
  int16_t fer
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_montgomery_multiply_by_constant(
  Eurydice_arr_d6 vec,
  int16_t c
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_montgomery_multiply_by_constant_b8(
  Eurydice_arr_d6 vector,
  int16_t constant
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_bitwise_and_with_constant(
  Eurydice_arr_d6 vec,
  int16_t c
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_arithmetic_to_unsigned_representative(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_to_unsigned_representative_b8(Eurydice_arr_d6 a);

/**
 The `compress_*` functions implement the `Compress` function specified in the NIST FIPS
 203 standard (Page 18, Expression 4.5), which is defined as:

 ```plaintext
 Compress_d: ℤq -> ℤ_{2ᵈ}
 Compress_d(x) = ⌈(2ᵈ/q)·x⌋
 ```

 Since `⌈x⌋ = ⌊x + 1/2⌋` we have:

 ```plaintext
 Compress_d(x) = ⌊(2ᵈ/q)·x + 1/2⌋
               = ⌊(2^{d+1}·x + q) / 2q⌋
 ```

 For further information about the function implementations, consult the
 `implementation_notes.pdf` document in this directory.

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
uint8_t libcrux_ml_kem_vector_portable_compress_compress_message_coefficient(uint16_t fe);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_compress_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_1_b8(Eurydice_arr_d6 a);

uint32_t
libcrux_ml_kem_vector_portable_arithmetic_get_n_least_significant_bits(
  uint8_t n,
  uint32_t value
);

int16_t
libcrux_ml_kem_vector_portable_compress_compress_ciphertext_coefficient(
  uint8_t coefficient_bits,
  uint16_t fe
);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_compress_decompress_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_decompress_1_b8(Eurydice_arr_d6 a);

void
libcrux_ml_kem_vector_portable_ntt_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta);

void
libcrux_ml_kem_vector_portable_ntt_inv_ntt_step(
  Eurydice_arr_d6 *vec,
  int16_t zeta,
  size_t i,
  size_t j
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_1_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_1_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_2_step(
  Eurydice_arr_d6 vec,
  int16_t zeta0,
  int16_t zeta1
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_2_step_b8(
  Eurydice_arr_d6 a,
  int16_t zeta0,
  int16_t zeta1
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_inv_ntt_layer_3_step(Eurydice_arr_d6 vec, int16_t zeta);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_inv_ntt_layer_3_step_b8(Eurydice_arr_d6 a, int16_t zeta);

/**
 Compute the product of two Kyber binomials with respect to the
 modulus `X² - zeta`.

 This function almost implements <strong>Algorithm 11</strong> of the
 NIST FIPS 203 standard, which is reproduced below:

 ```plaintext
 Input:  a₀, a₁, b₀, b₁ ∈ ℤq.
 Input: γ ∈ ℤq.
 Output: c₀, c₁ ∈ ℤq.

 c₀ ← a₀·b₀ + a₁·b₁·γ
 c₁ ← a₀·b₁ + a₁·b₀
 return c₀, c₁
 ```
 We say "almost" because the coefficients output by this function are in
 the Montgomery domain (unlike in the specification).

 The NIST FIPS 203 standard can be found at
 <https://csrc.nist.gov/pubs/fips/203/ipd>.
*/
void
libcrux_ml_kem_vector_portable_ntt_ntt_multiply_binomials(
  Eurydice_arr_d6 *a,
  Eurydice_arr_d6 *b,
  int16_t zeta,
  size_t i,
  Eurydice_arr_d6 *out
);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_ntt_multiply(
  Eurydice_arr_d6 *lhs,
  Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_ntt_multiply_b8(
  Eurydice_arr_d6 *lhs,
  Eurydice_arr_d6 *rhs,
  int16_t zeta0,
  int16_t zeta1,
  int16_t zeta2,
  int16_t zeta3
);

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_serialize_1(Eurydice_arr_d6 v);

Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x2 libcrux_ml_kem_vector_portable_serialize_1_b8(Eurydice_arr_d6 a);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_1(Eurydice_mut_borrow_slice_u8 v);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_1(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_1_b8(Eurydice_mut_borrow_slice_u8 a);

typedef struct uint8_t_x4_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
}
uint8_t_x4;

uint8_t_x4
libcrux_ml_kem_vector_portable_serialize_serialize_4_int(Eurydice_mut_borrow_slice_i16 v);

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_serialize_4(Eurydice_arr_d6 v);

Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_array_u8x8 libcrux_ml_kem_vector_portable_serialize_4_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_4_int(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_4(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_4(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_4_b8(Eurydice_mut_borrow_slice_u8 a);

typedef struct uint8_t_x5_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
  uint8_t f3;
  uint8_t f4;
}
uint8_t_x5;

uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_5_int(Eurydice_mut_borrow_slice_i16 v);

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_serialize_5(Eurydice_arr_d6 v);

Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_6d libcrux_ml_kem_vector_portable_serialize_5_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_5_int(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_5(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_5(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_5_b8(Eurydice_mut_borrow_slice_u8 a);

uint8_t_x5
libcrux_ml_kem_vector_portable_serialize_serialize_10_int(Eurydice_mut_borrow_slice_i16 v);

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_serialize_10(Eurydice_arr_d6 v);

Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_fc libcrux_ml_kem_vector_portable_serialize_10_b8(Eurydice_arr_d6 a);

int16_t_x8
libcrux_ml_kem_vector_portable_serialize_deserialize_10_int(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_10(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_10(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_10_b8(Eurydice_mut_borrow_slice_u8 a);

typedef struct uint8_t_x3_s
{
  uint8_t fst;
  uint8_t snd;
  uint8_t thd;
}
uint8_t_x3;

uint8_t_x3
libcrux_ml_kem_vector_portable_serialize_serialize_12_int(Eurydice_mut_borrow_slice_i16 v);

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_serialize_12(Eurydice_arr_d6 v);

Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12(Eurydice_arr_d6 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_94 libcrux_ml_kem_vector_portable_serialize_12_b8(Eurydice_arr_d6 a);

typedef struct int16_t_x2_s
{
  int16_t fst;
  int16_t snd;
}
int16_t_x2;

int16_t_x2
libcrux_ml_kem_vector_portable_serialize_deserialize_12_int(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6
libcrux_ml_kem_vector_portable_serialize_deserialize_12(Eurydice_mut_borrow_slice_u8 bytes);

Eurydice_arr_d6 libcrux_ml_kem_vector_portable_deserialize_12(Eurydice_mut_borrow_slice_u8 a);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6
libcrux_ml_kem_vector_portable_deserialize_12_b8(Eurydice_mut_borrow_slice_u8 a);

size_t
libcrux_ml_kem_vector_portable_sampling_rej_sample(
  Eurydice_mut_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 result
);

/**
This function found in impl {libcrux_ml_kem::vector::traits::Operations for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
size_t
libcrux_ml_kem_vector_portable_rej_sample_b8(
  Eurydice_mut_borrow_slice_u8 a,
  Eurydice_mut_borrow_slice_i16 out
);

typedef int16_t libcrux_ml_kem_vector_portable_arithmetic_FieldElementTimesMontgomeryR;

typedef int16_t libcrux_ml_kem_vector_portable_arithmetic_MontgomeryFieldElement;

typedef int16_t libcrux_ml_kem_vector_portable_vector_type_FieldElement;

/**
This function found in impl {core::clone::Clone for libcrux_ml_kem::vector::portable::vector_type::PortableVector}
*/
Eurydice_arr_d6 libcrux_ml_kem_vector_portable_vector_type_clone_9c(Eurydice_arr_d6 *self);

#if defined(__cplusplus)
}
#endif

#define libcrux_mlkem_portable_H_DEFINED
#endif /* libcrux_mlkem_portable_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_sha3_avx2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_sha3_avx2.h"

#include "libcrux_sha3_portable.h"
#include "libcrux_core.h"
#include "internal/libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i zero_b0(void)
{
  return mm256_set1_epi64x(0LL);
}

static KRML_MUSTINLINE __m256i
_veor5q_u64(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  __m256i ab = mm256_xor_si256(a, b);
  __m256i cd = mm256_xor_si256(c, d);
  __m256i abcd = mm256_xor_si256(ab, cd);
  return mm256_xor_si256(abcd, e);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor5_b0(__m256i a, __m256i b, __m256i c, __m256i d, __m256i e)
{
  return _veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i rotate_left_76(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(1, x, __m256i), mm256_srli_epi64(63, x, __m256i));
}

static KRML_MUSTINLINE __m256i _vrax1q_u64(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, rotate_left_76(b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i rotate_left1_and_xor_b0(__m256i a, __m256i b)
{
  return _vrax1q_u64(a, b);
}

static KRML_MUSTINLINE __m256i _vbcaxq_u64(__m256i a, __m256i b, __m256i c)
{
  return mm256_xor_si256(a, mm256_andnot_si256(c, b));
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i and_not_xor_b0(__m256i a, __m256i b, __m256i c)
{
  return _vbcaxq_u64(a, b, c);
}

static KRML_MUSTINLINE __m256i _veorq_n_u64(__m256i a, uint64_t c)
{
  __m256i c0 = mm256_set1_epi64x((int64_t)c);
  return mm256_xor_si256(a, c0);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_constant_b0(__m256i a, uint64_t c)
{
  return _veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
static KRML_MUSTINLINE __m256i xor_b0(__m256i a, __m256i b)
{
  return mm256_xor_si256(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE Eurydice_arr_c40 new_80_5d(void)
{
  Eurydice_arr_c40 lit;
  __m256i repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = zero_b0();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (__m256i));
  return lit;
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void set_ij_5d(Eurydice_arr_c40 *arr, size_t i, size_t j, __m256i value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE __m256i *get_ij_5d(Eurydice_arr_c40 *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
load_block_b2(Eurydice_arr_c40 *state, Eurydice_arr_0b0 *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256(32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256(32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256(49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256(49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], v0));
    set_ij_5d(state, i1, j1, mm256_xor_si256(get_ij_5d(state, i1, j1)[0U], v1));
    set_ij_5d(state, i2, j2, mm256_xor_si256(get_ij_5d(state, i2, j2)[0U], v2));
    set_ij_5d(state, i3, j3, mm256_xor_si256(get_ij_5d(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)136U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)136U / (size_t)32U);
  Eurydice_arr_ec u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_mut_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)136U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)136U / (size_t)32U) % (size_t)5U;
  set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_ec u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_mut_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)136U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    set_ij_5d(state, i, j, mm256_xor_si256(get_ij_5d(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_22(Eurydice_arr_c40 *state, Eurydice_arr_0b0 *blocks, size_t start, size_t len)
{
  Eurydice_arr_dc
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_mut_c8(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)136U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_0b0
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_mut_58(buffers.data),
        Eurydice_array_to_slice_mut_58(&buffers.data[1U]),
        Eurydice_array_to_slice_mut_58(&buffers.data[2U]),
        Eurydice_array_to_slice_mut_58(&buffers.data[3U])
      }
    };
  load_block_b2(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 136
- DELIMITER= 31
*/
static void
load_last_8f_22(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start, size_t len)
{
  load_last_22(self, input, start, len);
}

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $5size_t
*/
typedef struct arr_50_s { __m256i data[5U]; } arr_50;

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static __m256i *index_c2_5d(Eurydice_arr_c40 *self, size_t_x2 index)
{
  return get_ij_5d(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE arr_50 theta_80_5d(Eurydice_arr_c40 *self)
{
  arr_50
  c =
    {
      .data = {
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        xor5_b0(index_c2_5d(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(arr_50){
        .data = {
          rotate_left1_and_xor_b0(c.data[((size_t)0U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)1U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)2U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)3U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          rotate_left1_and_xor_b0(c.data[((size_t)4U + (size_t)4U) % (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static void set_80_5d(Eurydice_arr_c40 *self, size_t i, size_t j, __m256i v)
{
  set_ij_5d(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i rotate_left_02(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(36, x, __m256i), mm256_srli_epi64(28, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_02(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_02(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 36
- RIGHT= 28
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_02(__m256i a, __m256i b)
{
  return _vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i rotate_left_ac(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(3, x, __m256i), mm256_srli_epi64(61, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ac(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ac(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 3
- RIGHT= 61
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ac(__m256i a, __m256i b)
{
  return _vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i rotate_left_020(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(41, x, __m256i), mm256_srli_epi64(23, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_020(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_020(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 41
- RIGHT= 23
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_020(__m256i a, __m256i b)
{
  return _vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i rotate_left_a9(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(18, x, __m256i), mm256_srli_epi64(46, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_a9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_a9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 18
- RIGHT= 46
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_a9(__m256i a, __m256i b)
{
  return _vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_0_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)0U,
    xor_b0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)0U,
    xor_and_rotate_b0_02(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)0U,
    xor_and_rotate_b0_ac(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)0U,
    xor_and_rotate_b0_020(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)0U,
    xor_and_rotate_b0_a9(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_76(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_76(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 1
- RIGHT= 63
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_76(__m256i a, __m256i b)
{
  return _vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i rotate_left_58(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(44, x, __m256i), mm256_srli_epi64(20, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_58(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_58(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 44
- RIGHT= 20
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_58(__m256i a, __m256i b)
{
  return _vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i rotate_left_e0(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(10, x, __m256i), mm256_srli_epi64(54, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_e0(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_e0(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 10
- RIGHT= 54
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_e0(__m256i a, __m256i b)
{
  return _vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i rotate_left_63(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(45, x, __m256i), mm256_srli_epi64(19, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_63(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_63(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 45
- RIGHT= 19
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_63(__m256i a, __m256i b)
{
  return _vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i rotate_left_6a(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(2, x, __m256i), mm256_srli_epi64(62, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6a(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6a(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 2
- RIGHT= 62
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6a(__m256i a, __m256i b)
{
  return _vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_1_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)1U,
    xor_and_rotate_b0_76(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)1U,
    xor_and_rotate_b0_58(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)1U,
    xor_and_rotate_b0_e0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)1U,
    xor_and_rotate_b0_63(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)1U,
    xor_and_rotate_b0_6a(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i rotate_left_ab(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(62, x, __m256i), mm256_srli_epi64(2, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ab(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ab(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 62
- RIGHT= 2
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ab(__m256i a, __m256i b)
{
  return _vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i rotate_left_5b(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(6, x, __m256i), mm256_srli_epi64(58, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_5b(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_5b(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 6
- RIGHT= 58
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_5b(__m256i a, __m256i b)
{
  return _vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i rotate_left_6f(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(43, x, __m256i), mm256_srli_epi64(21, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_6f(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_6f(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 43
- RIGHT= 21
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_6f(__m256i a, __m256i b)
{
  return _vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i rotate_left_62(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(15, x, __m256i), mm256_srli_epi64(49, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_62(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_62(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 15
- RIGHT= 49
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_62(__m256i a, __m256i b)
{
  return _vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i rotate_left_23(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(61, x, __m256i), mm256_srli_epi64(3, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_23(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_23(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 61
- RIGHT= 3
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_23(__m256i a, __m256i b)
{
  return _vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_2_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)2U,
    xor_and_rotate_b0_ab(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)2U,
    xor_and_rotate_b0_5b(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)2U,
    xor_and_rotate_b0_6f(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)2U,
    xor_and_rotate_b0_62(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)2U,
    xor_and_rotate_b0_23(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i rotate_left_37(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(28, x, __m256i), mm256_srli_epi64(36, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_37(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_37(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 28
- RIGHT= 36
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_37(__m256i a, __m256i b)
{
  return _vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i rotate_left_bb(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(55, x, __m256i), mm256_srli_epi64(9, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_bb(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_bb(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 55
- RIGHT= 9
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_bb(__m256i a, __m256i b)
{
  return _vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i rotate_left_b9(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(25, x, __m256i), mm256_srli_epi64(39, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_b9(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_b9(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 25
- RIGHT= 39
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_b9(__m256i a, __m256i b)
{
  return _vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i rotate_left_54(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(21, x, __m256i), mm256_srli_epi64(43, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_54(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_54(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 21
- RIGHT= 43
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_54(__m256i a, __m256i b)
{
  return _vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i rotate_left_4c(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(56, x, __m256i), mm256_srli_epi64(8, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_4c(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_4c(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 56
- RIGHT= 8
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_4c(__m256i a, __m256i b)
{
  return _vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_3_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)3U,
    xor_and_rotate_b0_37(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)3U,
    xor_and_rotate_b0_bb(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)3U,
    xor_and_rotate_b0_b9(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)3U,
    xor_and_rotate_b0_54(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)3U,
    xor_and_rotate_b0_4c(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i rotate_left_ce(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(27, x, __m256i), mm256_srli_epi64(37, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_ce(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_ce(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 27
- RIGHT= 37
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_ce(__m256i a, __m256i b)
{
  return _vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i rotate_left_77(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(20, x, __m256i), mm256_srli_epi64(44, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_77(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_77(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 20
- RIGHT= 44
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_77(__m256i a, __m256i b)
{
  return _vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i rotate_left_25(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(39, x, __m256i), mm256_srli_epi64(25, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_25(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_25(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 39
- RIGHT= 25
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_25(__m256i a, __m256i b)
{
  return _vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i rotate_left_af(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(8, x, __m256i), mm256_srli_epi64(56, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_af(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_af(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 8
- RIGHT= 56
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_af(__m256i a, __m256i b)
{
  return _vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i rotate_left_fd(__m256i x)
{
  return mm256_xor_si256(mm256_slli_epi64(14, x, __m256i), mm256_srli_epi64(50, x, __m256i));
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i _vxarq_u64_fd(__m256i a, __m256i b)
{
  __m256i ab = mm256_xor_si256(a, b);
  return rotate_left_fd(ab);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.xor_and_rotate_b0
with const generics
- LEFT= 14
- RIGHT= 50
*/
static KRML_MUSTINLINE __m256i xor_and_rotate_b0_fd(__m256i a, __m256i b)
{
  return _vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_4_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)4U,
    xor_and_rotate_b0_ce(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)1U,
    (size_t)4U,
    xor_and_rotate_b0_77(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)2U,
    (size_t)4U,
    xor_and_rotate_b0_25(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)3U,
    (size_t)4U,
    xor_and_rotate_b0_af(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  set_80_5d(self,
    (size_t)4U,
    (size_t)4U,
    xor_and_rotate_b0_fd(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void rho_80_5d(Eurydice_arr_c40 *self, arr_50 t)
{
  rho_0_80_5d(self, t);
  rho_1_80_5d(self, t);
  rho_2_80_5d(self, t);
  rho_3_80_5d(self, t);
  rho_4_80_5d(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_0_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)1U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)0U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_1_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)1U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_2_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)2U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_3_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)3U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_4_80_5d(Eurydice_arr_c40 *self, Eurydice_arr_c40 old)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  set_80_5d(self,
    (size_t)1U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  set_80_5d(self,
    (size_t)2U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  set_80_5d(self,
    (size_t)3U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  set_80_5d(self,
    (size_t)4U,
    (size_t)4U,
    index_c2_5d(&old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void pi_80_5d(Eurydice_arr_c40 *self)
{
  Eurydice_arr_c40 old = self[0U];
  pi_0_80_5d(self, old);
  pi_1_80_5d(self, old);
  pi_2_80_5d(self, old);
  pi_3_80_5d(self, old);
  pi_4_80_5d(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void chi_80_5d(Eurydice_arr_c40 *self)
{
  Eurydice_arr_c40 old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      set_80_5d(self,
        i1,
        j,
        and_not_xor_b0(index_c2_5d(self, (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          index_c2_5d(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          index_c2_5d(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void iota_80_5d(Eurydice_arr_c40 *self, size_t i)
{
  set_80_5d(self,
    (size_t)0U,
    (size_t)0U,
    xor_constant_b0(index_c2_5d(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
*/
static KRML_MUSTINLINE void keccakf1600_80_5d(Eurydice_arr_c40 *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    arr_50 t = theta_80_5d(self);
    rho_80_5d(self, t);
    pi_80_5d(self);
    chi_80_5d(self);
    iota_80_5d(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
absorb_final_80_af(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start, size_t len)
{
  load_last_8f_22(self, input, start, len);
  keccakf1600_80_5d(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
store_block_b2(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_ec u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____1, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____2, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l = mm256_permute2x128_si256(32, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v1h = mm256_permute2x128_si256(32, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i
    v2l = mm256_permute2x128_si256(49, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v3h = mm256_permute2x128_si256(49, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 136
*/
static void
squeeze4_17_b2(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_b2(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block_8f
with const generics
- RATE= 136
*/
static void load_block_8f_b2(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start)
{
  load_block_b2(self, input, start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 136
*/
static KRML_MUSTINLINE void
absorb_block_80_48(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start)
{
  load_block_8f_b2(self, input, start);
  keccakf1600_80_5d(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.keccak4
with const generics
- RATE= 136
- DELIM= 31
*/
static KRML_MUSTINLINE void
keccak4_22(
  Eurydice_arr_0b0 *data,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  Eurydice_arr_c40 s = new_80_5d();
  size_t data_len = data->data->meta;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = data_len / (size_t)136U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = data_len % (size_t)136U;
      absorb_final_80_af(&s, data, data_len - rem, rem);
      size_t outlen = out0.meta;
      size_t blocks = outlen / (size_t)136U;
      size_t last = outlen - outlen % (size_t)136U;
      if (blocks == (size_t)0U)
      {
        squeeze4_17_b2(&s, out0, out1, out2, out3, (size_t)0U, outlen);
      }
      else
      {
        squeeze4_17_b2(&s, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < blocks; i++)
        {
          size_t i0 = i;
          keccakf1600_80_5d(&s);
          squeeze4_17_b2(&s, out0, out1, out2, out3, i0 * (size_t)136U, (size_t)136U);
        }
        if (last < outlen)
        {
          keccakf1600_80_5d(&s);
          squeeze4_17_b2(&s, out0, out1, out2, out3, last, outlen - last);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    absorb_block_80_48(&s, data, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_mut_borrow_slice_u8 input0,
  Eurydice_mut_borrow_slice_u8 input1,
  Eurydice_mut_borrow_slice_u8 input2,
  Eurydice_mut_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_0b0 lvalue = { .data = { input0, input1, input2, input3 } };
  keccak4_22(&lvalue, out0, out1, out2, out3);
}

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_c40 libcrux_sha3_avx2_x4_incremental_init(void)
{
  return new_80_5d();
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
load_block_60(Eurydice_arr_c40 *state, Eurydice_arr_0b0 *blocks, size_t offset)
{
  for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)32U; i++)
  {
    size_t i4 = i;
    size_t start = offset + (size_t)32U * i4;
    __m256i
    v00 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[0U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v10 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[1U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v20 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[2U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i
    v30 =
      mm256_loadu_si256_u8(Eurydice_slice_subslice_mut_c8(blocks->data[3U],
          (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)32U })));
    __m256i v0l = mm256_unpacklo_epi64(v00, v10);
    __m256i v1h = mm256_unpackhi_epi64(v00, v10);
    __m256i v2l = mm256_unpacklo_epi64(v20, v30);
    __m256i v3h = mm256_unpackhi_epi64(v20, v30);
    __m256i v0 = mm256_permute2x128_si256(32, v0l, v2l, __m256i);
    __m256i v1 = mm256_permute2x128_si256(32, v1h, v3h, __m256i);
    __m256i v2 = mm256_permute2x128_si256(49, v0l, v2l, __m256i);
    __m256i v3 = mm256_permute2x128_si256(49, v1h, v3h, __m256i);
    size_t i0 = (size_t)4U * i4 / (size_t)5U;
    size_t j0 = (size_t)4U * i4 % (size_t)5U;
    size_t i1 = ((size_t)4U * i4 + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i4 + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i4 + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i4 + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i4 + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i4 + (size_t)3U) % (size_t)5U;
    set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], v0));
    set_ij_5d(state, i1, j1, mm256_xor_si256(get_ij_5d(state, i1, j1)[0U], v1));
    set_ij_5d(state, i2, j2, mm256_xor_si256(get_ij_5d(state, i2, j2)[0U], v2));
    set_ij_5d(state, i3, j3, mm256_xor_si256(get_ij_5d(state, i3, j3)[0U], v3));
  }
  size_t rem = (size_t)168U % (size_t)32U;
  size_t start = offset + (size_t)32U * ((size_t)168U / (size_t)32U);
  Eurydice_arr_ec u8s = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[0U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[1U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[2U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
    Eurydice_slice_subslice_mut_c8(blocks->data[3U],
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + (size_t)8U })),
    uint8_t);
  __m256i
  u =
    mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
        &u8s,
        uint8_t,
        Eurydice_mut_borrow_slice_u8));
  size_t i0 = (size_t)4U * ((size_t)168U / (size_t)32U) / (size_t)5U;
  size_t j0 = (size_t)4U * ((size_t)168U / (size_t)32U) % (size_t)5U;
  set_ij_5d(state, i0, j0, mm256_xor_si256(get_ij_5d(state, i0, j0)[0U], u));
  if (rem == (size_t)16U)
  {
    Eurydice_arr_ec u8s0 = { .data = { 0U } };
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[0U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[1U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[2U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d44(&u8s0,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
      Eurydice_slice_subslice_mut_c8(blocks->data[3U],
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)8U,
            .end = start + (size_t)16U
          }
        )),
      uint8_t);
    __m256i
    u0 =
      mm256_loadu_si256_u8(core_array___T__N___as_slice((size_t)32U,
          &u8s0,
          uint8_t,
          Eurydice_mut_borrow_slice_u8));
    size_t i = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) / (size_t)5U;
    size_t j = ((size_t)4U * ((size_t)168U / (size_t)32U) + (size_t)1U) % (size_t)5U;
    set_ij_5d(state, i, j, mm256_xor_si256(get_ij_5d(state, i, j)[0U], u0));
  }
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
static KRML_MUSTINLINE void
load_last_37(Eurydice_arr_c40 *state, Eurydice_arr_0b0 *blocks, size_t start, size_t len)
{
  Eurydice_arr_9c
  buffers =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  KRML_MAYBE_FOR4(i,
    (size_t)0U,
    (size_t)4U,
    (size_t)1U,
    size_t i0 = i;
    Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d41(&buffers.data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
      Eurydice_slice_subslice_mut_c8(blocks->data[i0],
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
      uint8_t);
    buffers.data[i0].data[len] = 31U;
    size_t uu____0 = i0;
    size_t uu____1 = (size_t)168U - (size_t)1U;
    buffers.data[uu____0].data[uu____1] = (uint32_t)buffers.data[uu____0].data[uu____1] | 128U;);
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_0b0
  lvalue =
    {
      .data = {
        Eurydice_array_to_slice_mut_2c(buffers.data),
        Eurydice_array_to_slice_mut_2c(&buffers.data[1U]),
        Eurydice_array_to_slice_mut_2c(&buffers.data[2U]),
        Eurydice_array_to_slice_mut_2c(&buffers.data[3U])
      }
    };
  load_block_60(state, &lvalue, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<4usize> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.load_last_8f
with const generics
- RATE= 168
- DELIMITER= 31
*/
static void
load_last_8f_37(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start, size_t len)
{
  load_last_37(self, input, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types core_core_arch_x86___m256i
with const generics
- N= 4
- RATE= 168
- DELIM= 31
*/
static KRML_MUSTINLINE void
absorb_final_80_af0(Eurydice_arr_c40 *self, Eurydice_arr_0b0 *input, size_t start, size_t len)
{
  load_last_8f_37(self, input, start, len);
  keccakf1600_80_5d(self);
}

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 data0,
  Eurydice_mut_borrow_slice_u8 data1,
  Eurydice_mut_borrow_slice_u8 data2,
  Eurydice_mut_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_0b0 lvalue = { .data = { data0, data1, data2, data3 } };
  absorb_final_80_af0(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.avx2.store_block
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
store_block_60(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  size_t chunks = len / (size_t)32U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = chunks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      size_t rem = len % (size_t)32U;
      if (rem > (size_t)0U)
      {
        size_t start0 = start + (size_t)32U * chunks;
        Eurydice_arr_ec u8s = { .data = { 0U } };
        size_t chunks8 = rem / (size_t)8U;
        for (size_t i0 = (size_t)0U; i0 < chunks8; i0++)
        {
          size_t k = i0;
          size_t i = ((size_t)4U * chunks + k) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + k) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____1 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____1, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)8U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)8U, .end = (size_t)16U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)16U, .end = (size_t)24U })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + (size_t)8U * k,
                  .end = start0 + (size_t)8U * (k + (size_t)1U)
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)24U, .end = (size_t)32U })),
            uint8_t);
        }
        size_t rem8 = rem % (size_t)8U;
        if (rem8 > (size_t)0U)
        {
          size_t i = ((size_t)4U * chunks + chunks8) / (size_t)5U;
          size_t j = ((size_t)4U * chunks + chunks8) % (size_t)5U;
          Eurydice_mut_borrow_slice_u8 uu____2 = Eurydice_array_to_slice_mut_01(&u8s);
          mm256_storeu_si256_u8(uu____2, get_ij_5d(s, i, j)[0U]);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out0,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = rem8 })),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out1,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)8U,
                  .end = (size_t)8U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out2,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)16U,
                  .end = (size_t)16U + rem8
                }
              )),
            uint8_t);
          Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out3,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = start0 + len - rem8,
                  .end = start0 + len
                }
              )),
            Eurydice_array_to_subslice_mut_d44(&u8s,
              (
                KRML_CLITERAL(core_ops_range_Range_87){
                  .start = (size_t)24U,
                  .end = (size_t)24U + rem8
                }
              )),
            uint8_t);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t i0 = (size_t)4U * i / (size_t)5U;
    size_t j0 = (size_t)4U * i % (size_t)5U;
    size_t i1 = ((size_t)4U * i + (size_t)1U) / (size_t)5U;
    size_t j1 = ((size_t)4U * i + (size_t)1U) % (size_t)5U;
    size_t i2 = ((size_t)4U * i + (size_t)2U) / (size_t)5U;
    size_t j2 = ((size_t)4U * i + (size_t)2U) % (size_t)5U;
    size_t i3 = ((size_t)4U * i + (size_t)3U) / (size_t)5U;
    size_t j3 = ((size_t)4U * i + (size_t)3U) % (size_t)5U;
    __m256i
    v0l = mm256_permute2x128_si256(32, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v1h = mm256_permute2x128_si256(32, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i
    v2l = mm256_permute2x128_si256(49, get_ij_5d(s, i0, j0)[0U], get_ij_5d(s, i2, j2)[0U], __m256i);
    __m256i
    v3h = mm256_permute2x128_si256(49, get_ij_5d(s, i1, j1)[0U], get_ij_5d(s, i3, j3)[0U], __m256i);
    __m256i v0 = mm256_unpacklo_epi64(v0l, v1h);
    __m256i v1 = mm256_unpackhi_epi64(v0l, v1h);
    __m256i v2 = mm256_unpacklo_epi64(v2l, v3h);
    __m256i v3 = mm256_unpackhi_epi64(v2l, v3h);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out0,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v0);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out1,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v1);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out2,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v2);
    mm256_storeu_si256_u8(Eurydice_slice_subslice_mut_c8(out3,
        (
          KRML_CLITERAL(core_ops_range_Range_87){
            .start = start + (size_t)32U * i,
            .end = start + (size_t)32U * (i + (size_t)1U)
          }
        )),
      v3);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze4<core::core_arch::x86::__m256i> for libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.avx2.squeeze4_17
with const generics
- RATE= 168
*/
static void
squeeze4_17_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start,
  size_t len
)
{
  store_block_60(self, out0, out1, out2, out3, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_three_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_three_blocks_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_three_blocks_81_60(s, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, start, (size_t)168U);
}

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_60(s, out0, out1, out2, out3, (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_five_blocks_81
with const generics
- RATE= 168
*/
static KRML_MUSTINLINE void
squeeze_first_five_blocks_81_60(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)0U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)2U * (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)3U * (size_t)168U, (size_t)168U);
  keccakf1600_80_5d(self);
  squeeze4_17_60(self, out0, out1, out2, out3, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_five_blocks_81_60(s, out0, out1, out2, out3);
}

/**
 Absorb
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 data0,
  Eurydice_mut_borrow_slice_u8 data1,
  Eurydice_mut_borrow_slice_u8 data2,
  Eurydice_mut_borrow_slice_u8 data3
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_0b0 lvalue = { .data = { data0, data1, data2, data3 } };
  absorb_final_80_af(s, &lvalue, (size_t)0U, data0.meta);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_first_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_first_block_81_b2(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze4_17_b2(self, out0, out1, out2, out3, (size_t)0U, (size_t)136U);
}

/**
 Squeeze block
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_first_block_81_b2(s, out0, out1, out2, out3);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<core::core_arch::x86::__m256i, 4usize>[core::marker::Sized<core::core_arch::x86::__m256i>, libcrux_sha3::simd::avx2::{libcrux_sha3::traits::KeccakItem<4usize> for core::core_arch::x86::__m256i}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.simd256.squeeze_next_block_81
with const generics
- RATE= 136
*/
static KRML_MUSTINLINE void
squeeze_next_block_81_b2(
  Eurydice_arr_c40 *self,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3,
  size_t start
)
{
  keccakf1600_80_5d(self);
  squeeze4_17_b2(self, out0, out1, out2, out3, start, (size_t)136U);
}

/**
 Squeeze next block
*/
KRML_MUSTINLINE void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
)
{
  squeeze_next_block_81_b2(s, out0, out1, out2, out3, (size_t)0U);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_sha3_avx2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_avx2_H
#define libcrux_sha3_avx2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "intrinsics/libcrux_intrinsics_avx2.h"

/**
A monomorphic instance of Eurydice.arr
with types core_core_arch_x86___m256i
with const generics
- $25size_t
*/
typedef struct Eurydice_arr_c40_s { __m256i data[25U]; } Eurydice_arr_c40;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types core_core_arch_x86___m256i
with const generics
- $4size_t
*/
typedef Eurydice_arr_c40 libcrux_sha3_generic_keccak_KeccakState_7d;

/**
 Perform 4 SHAKE256 operations in parallel
*/
void
libcrux_sha3_avx2_x4_shake256(
  Eurydice_mut_borrow_slice_u8 input0,
  Eurydice_mut_borrow_slice_u8 input1,
  Eurydice_mut_borrow_slice_u8 input2,
  Eurydice_mut_borrow_slice_u8 input3,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

typedef libcrux_sha3_generic_keccak_KeccakState_7d
libcrux_sha3_avx2_x4_incremental_KeccakState;

/**
 Initialise the [`KeccakState`].
*/
Eurydice_arr_c40 libcrux_sha3_avx2_x4_incremental_init(void);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 data0,
  Eurydice_mut_borrow_slice_u8 data1,
  Eurydice_mut_borrow_slice_u8 data2,
  Eurydice_mut_borrow_slice_u8 data3
);

/**
 Squeeze three blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze another block
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze five blocks
*/
void
libcrux_sha3_avx2_x4_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Absorb
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_absorb_final(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 data0,
  Eurydice_mut_borrow_slice_u8 data1,
  Eurydice_mut_borrow_slice_u8 data2,
  Eurydice_mut_borrow_slice_u8 data3
);

/**
 Squeeze block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_first_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

/**
 Squeeze next block
*/
void
libcrux_sha3_avx2_x4_incremental_shake256_squeeze_next_block(
  Eurydice_arr_c40 *s,
  Eurydice_mut_borrow_slice_u8 out0,
  Eurydice_mut_borrow_slice_u8 out1,
  Eurydice_mut_borrow_slice_u8 out2,
  Eurydice_mut_borrow_slice_u8 out3
);

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_avx2_H_DEFINED
#endif /* libcrux_sha3_avx2_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_sha3_internal.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_internal_H
#define libcrux_sha3_internal_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define libcrux_sha3_Algorithm_Sha224 1
#define libcrux_sha3_Algorithm_Sha256 2
#define libcrux_sha3_Algorithm_Sha384 3
#define libcrux_sha3_Algorithm_Sha512 4

typedef uint8_t libcrux_sha3_Algorithm;

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_internal_H_DEFINED
#endif /* libcrux_sha3_internal_H */


================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_sha3_portable.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "libcrux_sha3_portable.h"

#include "libcrux_core.h"
#include "internal/libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_zero_d2(void)
{
  return 0ULL;
}

KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__veor5q_u64(
  uint64_t a,
  uint64_t b,
  uint64_t c,
  uint64_t d,
  uint64_t e
)
{
  return (((a ^ b) ^ c) ^ d) ^ e;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor5_d2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e)
{
  return libcrux_sha3_simd_portable__veor5q_u64(a, b, c, d, e);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_76(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)1);
}

KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, uint64_t b)
{
  return a ^ libcrux_sha3_simd_portable_rotate_left_76(b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vrax1q_u64(a, b);
}

KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, uint64_t b, uint64_t c)
{
  return a ^ (b & ~c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, uint64_t b, uint64_t c)
{
  return libcrux_sha3_simd_portable__vbcaxq_u64(a, b, c);
}

KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, uint64_t c)
{
  return a ^ c;
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c)
{
  return libcrux_sha3_simd_portable__veorq_n_u64(a, c);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_xor_d2(uint64_t a, uint64_t b)
{
  return a ^ b;
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE Eurydice_arr_7c libcrux_sha3_generic_keccak_new_80_71(void)
{
  Eurydice_arr_7c lit;
  uint64_t repeat_expression[25U];
  for (size_t i = (size_t)0U; i < (size_t)25U; i++)
  {
    repeat_expression[i] = libcrux_sha3_simd_portable_zero_d2();
  }
  memcpy(lit.data, repeat_expression, (size_t)25U * sizeof (uint64_t));
  return lit;
}

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE uint64_t
*libcrux_sha3_traits_get_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j)
{
  return &arr->data[(size_t)5U * j + i];
}

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_traits_set_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j, uint64_t value)
{
  arr->data[(size_t)5U * j + i] = value;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_c6(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)72U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)72U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_mut_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 72
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_dc(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ab buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d4(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)72U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_c6(state,
    Eurydice_array_to_slice_mut_e2(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_dc(self, input->data[0U], start, len);
}

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types uint64_t
with const generics
- N= 1
*/
uint64_t *libcrux_sha3_generic_keccak_index_c2_71(Eurydice_arr_7c *self, size_t_x2 index)
{
  return libcrux_sha3_traits_get_ij_71(self, index.fst, index.snd);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE Eurydice_arr_84 libcrux_sha3_generic_keccak_theta_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_84
  c =
    {
      .data = {
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]),
        libcrux_sha3_simd_portable_xor5_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U])
      }
    };
  return
    (
      KRML_CLITERAL(Eurydice_arr_84){
        .data = {
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)0U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)0U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)1U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)1U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)2U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)2U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)3U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)3U + (size_t)1U) % (size_t)5U]),
          libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(c.data[((size_t)4U + (size_t)4U) %
              (size_t)5U],
            c.data[((size_t)4U + (size_t)1U) % (size_t)5U])
        }
      }
    );
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types uint64_t
with const generics
- N= 1
*/
void
libcrux_sha3_generic_keccak_set_80_71(Eurydice_arr_7c *self, size_t i, size_t j, uint64_t v)
{
  libcrux_sha3_traits_set_ij_71(self, i, j, v);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_02(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)36);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_02(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 36
- RIGHT= 28
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_02(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)3);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ac(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 3
- RIGHT= 61
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ac(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_020(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)41);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_020(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 41
- RIGHT= 23
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_020(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)18);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_a9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 18
- RIGHT= 46
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_a9(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_02(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_020(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U],
      t.data[0U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_76(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 1
- RIGHT= 63
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_76(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_58(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)44);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_58(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 44
- RIGHT= 20
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_58(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)10);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_e0(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 10
- RIGHT= 54
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_e0(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_63(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)45);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_63(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 45
- RIGHT= 19
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_63(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)2);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6a(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 2
- RIGHT= 62
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6a(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_76(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_58(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_63(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U],
      t.data[1U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)62);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ab(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 62
- RIGHT= 2
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ab(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)6);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_5b(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 6
- RIGHT= 58
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_5b(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)43);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_6f(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 43
- RIGHT= 21
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_6f(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_62(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)15);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_62(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 15
- RIGHT= 49
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_62(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_23(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)61);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_23(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 61
- RIGHT= 3
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_23(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_62(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_23(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U],
      t.data[2U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_37(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)28);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_37(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 28
- RIGHT= 36
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_37(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)55);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_bb(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 55
- RIGHT= 9
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_bb(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)25);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_b9(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 25
- RIGHT= 39
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_b9(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_54(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)21);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_54(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 21
- RIGHT= 43
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_54(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)56);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_4c(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 56
- RIGHT= 8
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_4c(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_37(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_54(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U],
      t.data[3U]));
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)27);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_ce(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 27
- RIGHT= 37
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_ce(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_77(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)20);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_77(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 20
- RIGHT= 44
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_77(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_25(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)39);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_25(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 39
- RIGHT= 25
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_25(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_af(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)8);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_af(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 8
- RIGHT= 56
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_af(a, b);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x)
{
  return core_num__u64__rotate_left(x, (uint32_t)14);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable_rotate_left_fd(a ^ b);
}

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 14
- RIGHT= 50
*/
KRML_MUSTINLINE uint64_t
libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b)
{
  return libcrux_sha3_simd_portable__vxarq_u64_fd(a, b);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_77(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_25(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_af(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U],
      t.data[4U]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_rho_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t)
{
  libcrux_sha3_generic_keccak_rho_0_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_1_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_2_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_3_80_71(self, t);
  libcrux_sha3_generic_keccak_rho_4_80_71(self, t);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)0U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)2U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)1U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, .snd = (size_t)3U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)2U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, .snd = (size_t)4U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)1U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)3U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, .snd = (size_t)0U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_pi_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)4U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)1U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)2U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)2U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)0U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)3U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)3U }))[0U]);
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)4U,
    (size_t)4U,
    libcrux_sha3_generic_keccak_index_c2_71(&old,
      (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, .snd = (size_t)1U }))[0U]);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_pi_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_7c old = self[0U];
  libcrux_sha3_generic_keccak_pi_0_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_1_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_2_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_3_80_71(self, old);
  libcrux_sha3_generic_keccak_pi_4_80_71(self, old);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_chi_80_71(Eurydice_arr_7c *self)
{
  Eurydice_arr_7c old = self[0U];
  KRML_MAYBE_FOR5(i0,
    (size_t)0U,
    (size_t)5U,
    (size_t)1U,
    size_t i1 = i0;
    KRML_MAYBE_FOR5(i,
      (size_t)0U,
      (size_t)5U,
      (size_t)1U,
      size_t j = i;
      libcrux_sha3_generic_keccak_set_80_71(self,
        i1,
        j,
        libcrux_sha3_simd_portable_and_not_xor_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)2U) % (size_t)5U }))[0U],
          libcrux_sha3_generic_keccak_index_c2_71(&old,
            (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = (j + (size_t)1U) % (size_t)5U }))[0U]));););
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_iota_80_71(Eurydice_arr_7c *self, size_t i)
{
  libcrux_sha3_generic_keccak_set_80_71(self,
    (size_t)0U,
    (size_t)0U,
    libcrux_sha3_simd_portable_xor_constant_d2(libcrux_sha3_generic_keccak_index_c2_71(self,
        (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, .snd = (size_t)0U }))[0U],
      LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS.data[i]));
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types uint64_t
with const generics
- N= 1
*/
KRML_MUSTINLINE void libcrux_sha3_generic_keccak_keccakf1600_80_71(Eurydice_arr_7c *self)
{
  for (size_t i = (size_t)0U; i < (size_t)24U; i++)
  {
    size_t i0 = i;
    Eurydice_arr_84 t = libcrux_sha3_generic_keccak_theta_80_71(self);
    libcrux_sha3_generic_keccak_rho_80_71(self, t);
    libcrux_sha3_generic_keccak_pi_80_71(self);
    libcrux_sha3_generic_keccak_chi_80_71(self);
    libcrux_sha3_generic_keccak_iota_80_71(self, i0);
  }
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_dc(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_c6(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0, Eurydice_array_to_subslice_to_mut_21(&bytes, remaining), uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_squeeze_9b_c6(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_c6(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_a1_c6(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_c6(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e9(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_c6(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 72
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_dc(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)72U;
  size_t input_rem = input_len % (size_t)72U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd(&s, &lvalue, input_len - input_rem, input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)72U;
      size_t output_rem = output_len % (size_t)72U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, (size_t)0U, (size_t)72U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, i0 * (size_t)72U, (size_t)72U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_c6(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e9(&s, &lvalue, i * (size_t)72U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 512 implementation.
*/
void
libcrux_sha3_portable_sha512(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_dc(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_b2(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)136U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_mut_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_22(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ff buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_b2(state,
    Eurydice_array_to_slice_mut_58(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_22(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_22(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd0(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_22(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_b2(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0, Eurydice_array_to_subslice_to_mut_21(&bytes, remaining), uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_squeeze_9b_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_b2(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_a1_b2(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_b2(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e90(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_b2(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_22(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd0(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e90(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 256 implementation.
*/
void
libcrux_sha3_portable_sha256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_22(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_220(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_ff buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d40(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)136U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_b2(state,
    Eurydice_array_to_slice_mut_58(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_220(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_220(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd1(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_220(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 31
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_220(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)136U;
  size_t input_rem = input_len % (size_t)136U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd1(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)136U;
      size_t output_rem = output_len % (size_t)136U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, (size_t)0U, (size_t)136U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, i0 * (size_t)136U, (size_t)136U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_b2(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e90(&s, &lvalue, i * (size_t)136U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHAKE256 implementation.
*/
void
libcrux_sha3_portable_shake256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_220(data, digest);
}

/**
 Create a new SHAKE-128 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake128_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_71();
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_60(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)168U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_mut_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_37(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_c5 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d41(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 31U;
  size_t uu____0 = (size_t)168U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_60(state,
    Eurydice_array_to_slice_mut_2c(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_37(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_37(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
- DELIM= 31
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd2(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_37(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
 Absorb
*/
void
libcrux_sha3_portable_incremental_shake128_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 data0
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_69 lvalue = { .data = { data0 } };
  libcrux_sha3_generic_keccak_absorb_final_80_bd2(s, &lvalue, (size_t)0U, data0.meta);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_60(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0, Eurydice_array_to_subslice_to_mut_21(&bytes, remaining), uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_squeeze_9b_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_60(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze three blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(s, out0);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, start, (size_t)168U);
}

/**
 Squeeze another block
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(s, out0, (size_t)0U);
}

/**
 Returns the output size of a digest.
*/
size_t libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode)
{
  switch (mode)
  {
    case libcrux_sha3_Algorithm_Sha224:
      {
        break;
      }
    case libcrux_sha3_Algorithm_Sha256:
      {
        return LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha384:
      {
        return LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE;
      }
    case libcrux_sha3_Algorithm_Sha512:
      {
        return LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE;
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_9e(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)144U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)144U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_mut_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 144
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_3a(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_f4 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d42(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)144U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_9e(state,
    Eurydice_array_to_slice_mut_38(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_3a(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_3a(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd3(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_3a(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_9e(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0, Eurydice_array_to_subslice_to_mut_21(&bytes, remaining), uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_squeeze_9b_9e(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_9e(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_a1_9e(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_9e(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e91(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_9e(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 144
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_3a(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)144U;
  size_t input_rem = input_len % (size_t)144U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd3(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)144U;
      size_t output_rem = output_len % (size_t)144U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, (size_t)0U, (size_t)144U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, i0 * (size_t)144U, (size_t)144U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_9e(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e91(&s, &lvalue, i * (size_t)144U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 224 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_sha224(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_3a(data, digest);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_block_53(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
)
{
  Eurydice_arr_7c state_flat = { .data = { 0U } };
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){
          .start = (size_t)0U,
          .end = (size_t)104U / (size_t)8U
        }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      for (size_t i = (size_t)0U; i < (size_t)104U / (size_t)8U; i++)
      {
        size_t i0 = i;
        libcrux_sha3_traits_set_ij_71(state,
          i0 / (size_t)5U,
          i0 % (size_t)5U,
          libcrux_sha3_traits_get_ij_71(state, i0 / (size_t)5U, i0 % (size_t)5U)[0U] ^
            state_flat.data[i0]);
      }
      return;
    }
    size_t i = uu____0.f0;
    size_t offset = start + (size_t)8U * i;
    Eurydice_array_u8x8 arr;
    memcpy(arr.data,
      Eurydice_slice_subslice_mut_c8(blocks,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = offset, .end = offset + (size_t)8U })).ptr,
      (size_t)8U * sizeof (uint8_t));
    Eurydice_array_u8x8
    uu____1 =
      core_result_unwrap_26_e0((
          KRML_CLITERAL(core_result_Result_8e){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
        ));
    state_flat.data[i] = core_num__u64__from_le_bytes(uu____1);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 104
- DELIMITER= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_load_last_dc0(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
)
{
  Eurydice_arr_c4 buffer = { .data = { 0U } };
  Eurydice_slice_copy(Eurydice_array_to_subslice_mut_d43(&buffer,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = len })),
    Eurydice_slice_subslice_mut_c8(blocks,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = start, .end = start + len })),
    uint8_t);
  buffer.data[len] = 6U;
  size_t uu____0 = (size_t)104U - (size_t)1U;
  buffer.data[uu____0] = (uint32_t)buffer.data[uu____0] | 128U;
  libcrux_sha3_simd_portable_load_block_53(state,
    Eurydice_array_to_slice_mut_72(&buffer),
    (size_t)0U);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc0(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_dc0(self, input->data[0U], start, len);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
- DELIM= 6
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_final_80_bd4(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_load_last_a1_dc0(self, input, start, len);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_simd_portable_store_block_53(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  size_t octets = len / (size_t)8U;
  for (size_t i = (size_t)0U; i < octets; i++)
  {
    size_t i0 = i;
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          i0 / (size_t)5U,
          i0 % (size_t)5U)[0U]);
    size_t out_pos = start + (size_t)8U * i0;
    Eurydice_slice_copy(Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + (size_t)8U })),
      Eurydice_array_to_slice_mut_6e(&bytes),
      uint8_t);
  }
  size_t remaining = len % (size_t)8U;
  if (remaining > (size_t)0U)
  {
    Eurydice_array_u8x8
    bytes =
      core_num__u64__to_le_bytes(libcrux_sha3_traits_get_ij_71(s,
          octets / (size_t)5U,
          octets % (size_t)5U)[0U]);
    size_t out_pos = start + len - remaining;
    Eurydice_mut_borrow_slice_u8
    uu____0 =
      Eurydice_slice_subslice_mut_c8(out,
        (KRML_CLITERAL(core_ops_range_Range_87){ .start = out_pos, .end = out_pos + remaining }));
    Eurydice_slice_copy(uu____0, Eurydice_array_to_subslice_to_mut_21(&bytes, remaining), uint8_t);
  }
}

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_squeeze_9b_53(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
)
{
  libcrux_sha3_simd_portable_store_block_53(self, out, start, len);
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_a1_53(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_53(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e92(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_53(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 104
- DELIM= 6
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_dc0(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)104U;
  size_t input_rem = input_len % (size_t)104U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd4(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)104U;
      size_t output_rem = output_len % (size_t)104U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, (size_t)0U, (size_t)104U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, i0 * (size_t)104U, (size_t)104U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_53(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e92(&s, &lvalue, i * (size_t)104U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHA3 384 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_sha384(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_dc0(data, digest);
}

/**
 SHA3 224

 Preconditions:
 - `digest.len() == 28`
*/
void
libcrux_sha3_sha224_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
)
{
  libcrux_sha3_portable_sha224(digest, payload);
}

/**
 SHA3 224
*/
Eurydice_arr_a2 libcrux_sha3_sha224(Eurydice_mut_borrow_slice_u8 data)
{
  Eurydice_arr_a2 out = { .data = { 0U } };
  libcrux_sha3_sha224_ema(Eurydice_array_to_slice_mut_5e(&out), data);
  return out;
}

/**
 SHA3 256
*/
void
libcrux_sha3_sha256_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
)
{
  libcrux_sha3_portable_sha256(digest, payload);
}

/**
 SHA3 256
*/
Eurydice_arr_ec libcrux_sha3_sha256(Eurydice_mut_borrow_slice_u8 data)
{
  Eurydice_arr_ec out = { .data = { 0U } };
  libcrux_sha3_sha256_ema(Eurydice_array_to_slice_mut_01(&out), data);
  return out;
}

/**
 SHA3 384
*/
void
libcrux_sha3_sha384_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
)
{
  libcrux_sha3_portable_sha384(digest, payload);
}

/**
 SHA3 384
*/
Eurydice_arr_65 libcrux_sha3_sha384(Eurydice_mut_borrow_slice_u8 data)
{
  Eurydice_arr_65 out = { .data = { 0U } };
  libcrux_sha3_sha384_ema(Eurydice_array_to_slice_mut_9f(&out), data);
  return out;
}

/**
 SHA3 512
*/
void
libcrux_sha3_sha512_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
)
{
  libcrux_sha3_portable_sha512(digest, payload);
}

/**
 SHA3 512
*/
Eurydice_arr_c7 libcrux_sha3_sha512(Eurydice_mut_borrow_slice_u8 data)
{
  Eurydice_arr_c7 out = { .data = { 0U } };
  libcrux_sha3_sha512_ema(Eurydice_array_to_slice_mut_17(&out), data);
  return out;
}

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_a1_60(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_60(self, input->data[0U], start);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_absorb_block_80_e93(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
)
{
  libcrux_sha3_simd_portable_load_block_a1_60(self, input, start);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
}

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 168
- DELIM= 31
*/
inline void
libcrux_sha3_generic_keccak_portable_keccak1_37(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
)
{
  Eurydice_arr_7c s = libcrux_sha3_generic_keccak_new_80_71();
  size_t input_len = input.meta;
  size_t input_blocks = input_len / (size_t)168U;
  size_t input_rem = input_len % (size_t)168U;
  core_ops_range_Range_87
  iter =
    core_iter_traits_collect__core__iter__traits__collect__IntoIterator_Clause1_Item__I__for_I__into_iter((
        KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = input_blocks }
      ),
      core_ops_range_Range_87,
      size_t,
      core_ops_range_Range_87);
  while (true)
  {
    core_option_Option_87
    uu____0 =
      core_iter_range__core__iter__traits__iterator__Iterator_A__for_core__ops__range__Range_A__TraitClause_0___next(&iter,
        size_t,
        core_option_Option_87);
    if (uu____0.tag == core_option_None)
    {
      /* original Rust expression is not an lvalue in C */
      Eurydice_arr_69 lvalue = { .data = { input } };
      libcrux_sha3_generic_keccak_absorb_final_80_bd2(&s,
        &lvalue,
        input_len - input_rem,
        input_rem);
      size_t output_len = output.meta;
      size_t output_blocks = output_len / (size_t)168U;
      size_t output_rem = output_len % (size_t)168U;
      if (output_blocks == (size_t)0U)
      {
        libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, (size_t)0U, output_len);
      }
      else
      {
        libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, (size_t)0U, (size_t)168U);
        for (size_t i = (size_t)1U; i < output_blocks; i++)
        {
          size_t i0 = i;
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, i0 * (size_t)168U, (size_t)168U);
        }
        if (output_rem != (size_t)0U)
        {
          libcrux_sha3_generic_keccak_keccakf1600_80_71(&s);
          libcrux_sha3_simd_portable_squeeze_9b_60(&s, output, output_len - output_rem, output_rem);
        }
      }
      return;
    }
    size_t i = uu____0.f0;
    /* original Rust expression is not an lvalue in C */
    Eurydice_arr_69 lvalue = { .data = { input } };
    libcrux_sha3_generic_keccak_absorb_block_80_e93(&s, &lvalue, i * (size_t)168U);
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}

/**
 A portable SHAKE128 implementation.
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_shake128(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
)
{
  libcrux_sha3_generic_keccak_portable_keccak1_37(data, digest);
}

/**
 SHAKE 128

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake128_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_mut_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake128(out, data);
}

/**
 SHAKE 256

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake256_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_mut_borrow_slice_u8 data)
{
  libcrux_sha3_portable_shake256(out, data);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4
with const generics
- RATE= 168
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)0U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)2U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)3U * (size_t)168U, (size_t)168U);
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_60(self, out, (size_t)4U * (size_t)168U, (size_t)168U);
}

/**
 Squeeze five blocks
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(s, out0);
}

/**
 Absorb some data for SHAKE-256 for the last time
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 data
)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_69 lvalue = { .data = { data } };
  libcrux_sha3_generic_keccak_absorb_final_80_bd1(s, &lvalue, (size_t)0U, data.meta);
}

/**
 Create a new SHAKE-256 state object.
*/
KRML_MUSTINLINE Eurydice_arr_7c libcrux_sha3_portable_incremental_shake256_init(void)
{
  return libcrux_sha3_generic_keccak_new_80_71();
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_simd_portable_squeeze_9b_b2(self, out, (size_t)0U, (size_t)136U);
}

/**
 Squeeze the first SHAKE-256 block
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_first_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(s, out);
}

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 136
*/
KRML_MUSTINLINE void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
)
{
  libcrux_sha3_generic_keccak_keccakf1600_80_71(self);
  libcrux_sha3_simd_portable_squeeze_9b_b2(self, out, start, (size_t)136U);
}

/**
 Squeeze the next SHAKE-256 block
*/
KRML_MUSTINLINE void
libcrux_sha3_portable_incremental_shake256_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
)
{
  libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(s, out, (size_t)0U);
}



================================================
FILE: out/test-libcrux-ml-kem-no-const/libcrux_sha3_portable.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef libcrux_sha3_portable_H
#define libcrux_sha3_portable_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "libcrux_core.h"

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_zero_d2(void);

uint64_t
libcrux_sha3_simd_portable__veor5q_u64(
  uint64_t a,
  uint64_t b,
  uint64_t c,
  uint64_t d,
  uint64_t e
);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t
libcrux_sha3_simd_portable_xor5_d2(uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_76(uint64_t x);

uint64_t libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b);

uint64_t libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, uint64_t b, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, uint64_t b, uint64_t c);

uint64_t libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
uint64_t libcrux_sha3_simd_portable_xor_d2(uint64_t a, uint64_t b);

#define LIBCRUX_SHA3_GENERIC_KECCAK_CONSTANTS_ROUNDCONSTANTS ((KRML_CLITERAL(Eurydice_arr_22){ .data = { 1ULL, 32898ULL, 9223372036854808714ULL, 9223372039002292224ULL, 32907ULL, 2147483649ULL, 9223372039002292353ULL, 9223372036854808585ULL, 138ULL, 136ULL, 2147516425ULL, 2147483658ULL, 2147516555ULL, 9223372036854775947ULL, 9223372036854808713ULL, 9223372036854808579ULL, 9223372036854808578ULL, 9223372036854775936ULL, 32778ULL, 9223372039002259466ULL, 9223372039002292353ULL, 9223372036854808704ULL, 2147483649ULL, 9223372039002292232ULL } }))

typedef struct size_t_x2_s
{
  size_t fst;
  size_t snd;
}
size_t_x2;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.KeccakState
with types uint64_t
with const generics
- $1size_t
*/
typedef Eurydice_arr_7c libcrux_sha3_generic_keccak_KeccakState_f3;

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.new_80
with types uint64_t
with const generics
- N= 1
*/
Eurydice_arr_7c libcrux_sha3_generic_keccak_new_80_71(void);

/**
A monomorphic instance of libcrux_sha3.traits.get_ij
with types uint64_t
with const generics
- N= 1
*/
uint64_t *libcrux_sha3_traits_get_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j);

/**
A monomorphic instance of libcrux_sha3.traits.set_ij
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_traits_set_ij_71(Eurydice_arr_7c *arr, size_t i, size_t j, uint64_t value);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_c6(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_dc(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 72
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {core::ops::index::Index<(usize, usize), T> for libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.index_c2
with types uint64_t
with const generics
- N= 1
*/
uint64_t *libcrux_sha3_generic_keccak_index_c2_71(Eurydice_arr_7c *self, size_t_x2 index);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.theta_80
with types uint64_t
with const generics
- N= 1
*/
Eurydice_arr_84 libcrux_sha3_generic_keccak_theta_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.set_80
with types uint64_t
with const generics
- N= 1
*/
void
libcrux_sha3_generic_keccak_set_80_71(Eurydice_arr_7c *self, size_t i, size_t j, uint64_t v);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_02(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 36
- RIGHT= 28
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 3
- RIGHT= 61
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_020(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 41
- RIGHT= 23
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 18
- RIGHT= 46
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_0_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 1
- RIGHT= 63
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_58(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 44
- RIGHT= 20
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 10
- RIGHT= 54
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_63(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 45
- RIGHT= 19
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 2
- RIGHT= 62
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_1_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 62
- RIGHT= 2
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 6
- RIGHT= 58
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 43
- RIGHT= 21
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_62(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 15
- RIGHT= 49
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_23(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 61
- RIGHT= 3
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_2_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_37(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 28
- RIGHT= 36
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 55
- RIGHT= 9
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 25
- RIGHT= 39
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_54(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 21
- RIGHT= 43
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 56
- RIGHT= 8
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_3_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 27
- RIGHT= 37
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_77(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 20
- RIGHT= 44
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_25(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 39
- RIGHT= 25
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_af(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 8
- RIGHT= 56
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b);

/**
A monomorphic instance of libcrux_sha3.simd.portable.rotate_left
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x);

/**
A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2
with const generics
- LEFT= 14
- RIGHT= 50
*/
uint64_t libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_4_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.rho_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_rho_80_71(Eurydice_arr_7c *self, Eurydice_arr_84 t);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_0_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_0_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_1_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_1_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_2_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_2_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_3_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_3_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_4_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_4_80_71(Eurydice_arr_7c *self, Eurydice_arr_7c old);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.pi_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_pi_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.chi_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_chi_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.iota_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_iota_80_71(Eurydice_arr_7c *self, size_t i);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80
with types uint64_t
with const generics
- N= 1
*/
void libcrux_sha3_generic_keccak_keccakf1600_80_71(Eurydice_arr_7c *self);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_store_block_c6(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_squeeze_9b_c6(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 72
*/
void
libcrux_sha3_simd_portable_load_block_a1_c6(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 72
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e9(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 72
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_dc(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 512 implementation.
*/
void
libcrux_sha3_portable_sha512(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_b2(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_22(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_22(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd0(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_store_block_b2(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_squeeze_9b_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 136
*/
void
libcrux_sha3_simd_portable_load_block_a1_b2(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e90(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_22(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 256 implementation.
*/
void
libcrux_sha3_portable_sha256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_220(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 136
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_220(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 136
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd1(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 136
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_220(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHAKE256 implementation.
*/
void
libcrux_sha3_portable_shake256(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

typedef libcrux_sha3_generic_keccak_KeccakState_f3 libcrux_sha3_portable_KeccakState;

/**
 Create a new SHAKE-128 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake128_init(void);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_60(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_37(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 168
- DELIMITER= 31
*/
void
libcrux_sha3_simd_portable_load_last_a1_37(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd2(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
 Absorb
*/
void
libcrux_sha3_portable_incremental_shake128_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 data0
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_store_block_60(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_squeeze_9b_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze three blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
);

/**
 Squeeze another block
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

#define libcrux_sha3_Algorithm_Sha224 1
#define libcrux_sha3_Algorithm_Sha256 2
#define libcrux_sha3_Algorithm_Sha384 3
#define libcrux_sha3_Algorithm_Sha512 4

typedef uint8_t libcrux_sha3_Algorithm;

#define LIBCRUX_SHA3_SHA3_224_DIGEST_SIZE ((size_t)28U)

#define LIBCRUX_SHA3_SHA3_256_DIGEST_SIZE ((size_t)32U)

#define LIBCRUX_SHA3_SHA3_384_DIGEST_SIZE ((size_t)48U)

#define LIBCRUX_SHA3_SHA3_512_DIGEST_SIZE ((size_t)64U)

/**
 Returns the output size of a digest.
*/
size_t libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_9e(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_3a(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 144
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_3a(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd3(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_store_block_9e(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_squeeze_9b_9e(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 144
*/
void
libcrux_sha3_simd_portable_load_block_a1_9e(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 144
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e91(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 144
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_3a(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 224 implementation.
*/
void
libcrux_sha3_portable_sha224(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_53(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_dc0(
  Eurydice_arr_7c *state,
  Eurydice_mut_borrow_slice_u8 blocks,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1
with const generics
- RATE= 104
- DELIMITER= 6
*/
void
libcrux_sha3_simd_portable_load_last_a1_dc0(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_absorb_final_80_bd4(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start,
  size_t len
);

/**
A monomorphic instance of libcrux_sha3.simd.portable.store_block
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_store_block_53(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Squeeze<u64> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.squeeze_9b
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_squeeze_9b_53(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start,
  size_t len
);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 104
*/
void
libcrux_sha3_simd_portable_load_block_a1_53(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 104
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e92(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 104
- DELIM= 6
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_dc0(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHA3 384 implementation.
*/
void
libcrux_sha3_portable_sha384(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

/**
 SHA3 224

 Preconditions:
 - `digest.len() == 28`
*/
void
libcrux_sha3_sha224_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
);

/**
 SHA3 224
*/
Eurydice_arr_a2 libcrux_sha3_sha224(Eurydice_mut_borrow_slice_u8 data);

/**
 SHA3 256
*/
void
libcrux_sha3_sha256_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
);

/**
 SHA3 256
*/
Eurydice_arr_ec libcrux_sha3_sha256(Eurydice_mut_borrow_slice_u8 data);

/**
 SHA3 384
*/
void
libcrux_sha3_sha384_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
);

/**
 SHA3 384
*/
Eurydice_arr_65 libcrux_sha3_sha384(Eurydice_mut_borrow_slice_u8 data);

/**
 SHA3 512
*/
void
libcrux_sha3_sha512_ema(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 payload
);

/**
 SHA3 512
*/
Eurydice_arr_c7 libcrux_sha3_sha512(Eurydice_mut_borrow_slice_u8 data);

/**
This function found in impl {libcrux_sha3::traits::Absorb<1usize> for libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1
with const generics
- RATE= 168
*/
void
libcrux_sha3_simd_portable_load_block_a1_60(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80
with types uint64_t
with const generics
- N= 1
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_absorb_block_80_e93(
  Eurydice_arr_7c *self,
  Eurydice_arr_69 *input,
  size_t start
);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1
with const generics
- RATE= 168
- DELIM= 31
*/
void
libcrux_sha3_generic_keccak_portable_keccak1_37(
  Eurydice_mut_borrow_slice_u8 input,
  Eurydice_mut_borrow_slice_u8 output
);

/**
 A portable SHAKE128 implementation.
*/
void
libcrux_sha3_portable_shake128(
  Eurydice_mut_borrow_slice_u8 digest,
  Eurydice_mut_borrow_slice_u8 data
);

/**
 SHAKE 128

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake128_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_mut_borrow_slice_u8 data);

/**
 SHAKE 256

 Writes `out.len()` bytes.
*/
void
libcrux_sha3_shake256_ema(Eurydice_mut_borrow_slice_u8 out, Eurydice_mut_borrow_slice_u8 data);

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $168size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_55_s
{
  Eurydice_arr_7c inner;
  Eurydice_arr_88 buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_55;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_55
libcrux_sha3_portable_incremental_Shake128Xof;

/**
A monomorphic instance of libcrux_sha3.generic_keccak.xof.KeccakXofState
with types uint64_t
with const generics
- $1size_t
- $136size_t
*/
typedef struct libcrux_sha3_generic_keccak_xof_KeccakXofState_8d_s
{
  Eurydice_arr_7c inner;
  Eurydice_arr_0b buf;
  size_t buf_len;
  bool sponge;
}
libcrux_sha3_generic_keccak_xof_KeccakXofState_8d;

typedef libcrux_sha3_generic_keccak_xof_KeccakXofState_8d
libcrux_sha3_portable_incremental_Shake256Xof;

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4
with const generics
- RATE= 168
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_60(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze five blocks
*/
void
libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out0
);

/**
 Absorb some data for SHAKE-256 for the last time
*/
void
libcrux_sha3_portable_incremental_shake256_absorb_final(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 data
);

/**
 Create a new SHAKE-256 state object.
*/
Eurydice_arr_7c libcrux_sha3_portable_incremental_shake256_init(void);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4
with const generics
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out
);

/**
 Squeeze the first SHAKE-256 block
*/
void
libcrux_sha3_portable_incremental_shake256_squeeze_first_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
);

/**
This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for u64}]}
*/
/**
A monomorphic instance of libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4
with const generics
- RATE= 136
*/
void
libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_b2(
  Eurydice_arr_7c *self,
  Eurydice_mut_borrow_slice_u8 out,
  size_t start
);

/**
 Squeeze the next SHAKE-256 block
*/
void
libcrux_sha3_portable_incremental_shake256_squeeze_next_block(
  Eurydice_arr_7c *s,
  Eurydice_mut_borrow_slice_u8 out
);

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_4a_s { Eurydice_arr_7c data[4U]; } Eurydice_arr_4a;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_1b_s { Eurydice_arr_7c data[3U]; } Eurydice_arr_1b;

/**
A monomorphic instance of Eurydice.arr
with types libcrux_sha3_portable_KeccakState
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_e3_s { Eurydice_arr_7c data[2U]; } Eurydice_arr_e3;

#if defined(__cplusplus)
}
#endif

#define libcrux_sha3_portable_H_DEFINED
#endif /* libcrux_sha3_portable_H */


================================================
FILE: out/test-lvalue/lvalue.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "lvalue.h"

void lvalue_main(void)
{

}

lvalue_Struct lvalue_use_struct(lvalue_ThreeWays s)
{
  bool uu____0 = false;
  uu____0 = true;
  lvalue_Struct uu____1;
  if (s.tag == lvalue_Middle)
  {
    int32_t i = s.val.case_Middle;
    uu____1 =
      (
        KRML_CLITERAL(lvalue_Struct){
          .tag = lvalue_B,
          .val = { .case_B = Eurydice_box_new(i, int32_t, int32_t *) }
        }
      );
  }
  else if (s.tag == lvalue_Left)
  {
    Eurydice_vec st = s.val.case_Left;
    uu____1 = (KRML_CLITERAL(lvalue_Struct){ .tag = lvalue_A, .val = { .case_A = st } });
  }
  else
  {
    uu____1 = (KRML_CLITERAL(lvalue_Struct){ .tag = lvalue_C });
  }
  if (!(s.tag == lvalue_Left))
  {
    return uu____1;
  }
  return uu____1;
}

/**
This function found in impl {core::marker::Destruct for lvalue::ThreeWays}
*/
void lvalue_ThreeWays_drop_in_place_d9(lvalue_ThreeWays *_)
{
  lvalue_ThreeWays scrut = _[0U];
  if (!(scrut.tag == lvalue_Middle))
  {
    if (scrut.tag == lvalue_Left)
    {

    }
  }
}



================================================
FILE: out/test-lvalue/lvalue.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef lvalue_H
#define lvalue_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define lvalue_A 0
#define lvalue_B 1
#define lvalue_C 2

typedef uint8_t lvalue_Struct_tags;

typedef struct lvalue_Struct_s
{
  lvalue_Struct_tags tag;
  union {
    Eurydice_vec case_A;
    int32_t *case_B;
  }
  val;
}
lvalue_Struct;

#define lvalue_Middle 0
#define lvalue_Left 1
#define lvalue_Right 2

typedef uint8_t lvalue_ThreeWays_tags;

typedef struct lvalue_ThreeWays_s
{
  lvalue_ThreeWays_tags tag;
  union {
    int32_t case_Middle;
    Eurydice_vec case_Left;
    float64_t *case_Right;
  }
  val;
}
lvalue_ThreeWays;

void lvalue_main(void);

lvalue_Struct lvalue_use_struct(lvalue_ThreeWays s);

/**
This function found in impl {core::marker::Destruct for lvalue::ThreeWays}
*/
void lvalue_ThreeWays_drop_in_place_d9(lvalue_ThreeWays *_);

#if defined(__cplusplus)
}
#endif

#define lvalue_H_DEFINED
#endif /* lvalue_H */


================================================
FILE: out/test-mismatch/mismatch.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "mismatch.h"

void mismatch_main(void)
{

}



================================================
FILE: out/test-mismatch/mismatch.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef mismatch_H
#define mismatch_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

void mismatch_main(void);

#if defined(__cplusplus)
}
#endif

#define mismatch_H_DEFINED
#endif /* mismatch_H */


================================================
FILE: out/test-more_dst/more_dst.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "more_dst.h"

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void more_dst_main(void)
{
  more_dst_TS1 x1 = { .foo = 0U, .data = { .data = { 0U } } };
  Eurydice_dst_ref_shared_62 y1 = { .ptr = (const more_dst_T1 *)&x1, .meta = (size_t)4U };
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue0 = 0U;
  const_uint32_t__x2 uu____0 = { .fst = &((const uint32_t *)y1.ptr->data)[1U], .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  more_dst_TS2 x2 = { .foo = 0U, .data = x1 };
  Eurydice_dst_ref_shared_21 y2 = { .ptr = (const more_dst_T2 *)&x2, .meta = (size_t)4U };
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue1 = 0U;
  const_uint32_t__x2
  uu____1 = { .fst = &((const uint32_t *)y2.ptr->data.data)[2U], .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  more_dst_TS3 x3 = { .foo = 0U, .data = x2 };
  Eurydice_dst_ref_shared_a8 y3 = { .ptr = (const more_dst_T3 *)&x3, .meta = (size_t)4U };
  /* original Rust expression is not an lvalue in C */
  uint32_t lvalue = 0U;
  const_uint32_t__x2
  uu____2 = { .fst = &((const uint32_t *)y3.ptr->data.data.data)[3U], .snd = &lvalue };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
}



================================================
FILE: out/test-more_dst/more_dst.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef more_dst_H
#define more_dst_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

typedef struct more_dst_T1_s
{
  uint32_t foo;
  uint32_t data[];
}
more_dst_T1;

typedef struct more_dst_T2_s
{
  uint32_t foo;
  more_dst_T1 data;
}
more_dst_T2;

typedef struct more_dst_T3_s
{
  uint32_t foo;
  more_dst_T2 data;
}
more_dst_T3;

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_e5_s { uint32_t data[4U]; } Eurydice_arr_e5;

typedef struct more_dst_TS1_s
{
  uint32_t foo;
  Eurydice_arr_e5 data;
}
more_dst_TS1;

typedef struct more_dst_TS2_s
{
  uint32_t foo;
  more_dst_TS1 data;
}
more_dst_TS2;

typedef struct more_dst_TS3_s
{
  uint32_t foo;
  more_dst_TS2 data;
}
more_dst_TS3;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types more_dst_T1, size_t

*/
typedef struct Eurydice_dst_ref_shared_62_s
{
  const more_dst_T1 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_62;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types uint32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0c_s
{
  const uint32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0c;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types more_dst_T2, size_t

*/
typedef struct Eurydice_dst_ref_shared_21_s
{
  const more_dst_T2 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_21;

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types more_dst_T3, size_t

*/
typedef struct Eurydice_dst_ref_shared_a8_s
{
  const more_dst_T3 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_a8;

void more_dst_main(void);

#if defined(__cplusplus)
}
#endif

#define more_dst_H_DEFINED
#endif /* more_dst_H */


================================================
FILE: out/test-more_primitive_types/more_primitive_types.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "more_primitive_types.h"

int32_t more_primitive_types_int128_operations(more_primitive_types_MorePrimitiveTypes *p)
{
  Eurydice_Int128_int128_t uu____0 = p->int128;
  Eurydice_Int128_int128_t
  uu____1 =
    Eurydice_Int128_i128_mul(Eurydice_Int128_i128_from_bits(0x0ULL, 0x1ffffffffffffffULL),
      Eurydice_Int128_i128_from_bits(0x0ULL, 0x1ULL));
  Eurydice_Int128_int128_t
  uu____2 =
    Eurydice_Int128_i128_shl(Eurydice_Int128_i128_sub(Eurydice_Int128_i128_from_bits(0x0ULL,
          0xffffffff1ULL),
        uu____1),
      10U);
  p->int128 = Eurydice_Int128_i128_band(uu____0, uu____2);
  Eurydice_Int128_uint128_t uu____3 = p->uint128;
  Eurydice_Int128_uint128_t
  uu____4 =
    Eurydice_Int128_u128_sub(Eurydice_Int128_u128_from_bits(0x0ULL, 0xffffffff1ULL),
      Eurydice_Int128_u128_from_bits(0x0ULL, 0x1fULL));
  p->uint128 = Eurydice_Int128_u128_band(uu____3, uu____4);
  Eurydice_Int128_uint128_t uu____5 = p->uint128;
  Eurydice_Int128_uint128_t
  uu____6 =
    Eurydice_Int128_u128_shr(Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL),
      (uint32_t)uu____5);
  Eurydice_Int128_uint128_t x = Eurydice_Int128_u128_shl(uu____6, (uint32_t)p->int128);
  return (int32_t)x;
}

int32_t more_primitive_types_match_u128(const more_primitive_types_MorePrimitiveTypes *p)
{
  if
  (
    !(Eurydice_Int128_u128_eq(p->uint128, Eurydice_Int128_u128_from_bits(0x0ULL, 0xffffULL)) ||
      Eurydice_Int128_u128_eq(p->uint128,
        Eurydice_Int128_u128_from_bits(0x0ULL, 0xffffffffULL)))
  )
  {
    if
    (
      Eurydice_Int128_u128_eq(p->uint128,
        Eurydice_Int128_u128_from_bits(0xffffffffffffULL, 0xffffffffffffffffULL))
    )
    {
      return 4;
    }
    else if
    (
      Eurydice_Int128_u128_eq(p->uint128,
        Eurydice_Int128_u128_from_bits(0xffffffffffffffffULL, 0xffffffffffffffffULL))
    )
    {
      return 5;
    }
    else
    {
      return 1;
    }
  }
  return 3;
}

int32_t more_primitive_types_match_i128(const more_primitive_types_MorePrimitiveTypes *p)
{
  if
  (
    !(Eurydice_Int128_i128_eq(p->int128,
      Eurydice_Int128_i128_from_bits(0xffffffffffffffffULL, 0xffffffffffff0001ULL))
    ||
      Eurydice_Int128_i128_eq(p->int128,
        Eurydice_Int128_i128_from_bits(0xffffffffffffffffULL, 0xffffffff00000001ULL)))
  )
  {
    if
    (
      Eurydice_Int128_i128_eq(p->int128,
        Eurydice_Int128_i128_from_bits(0xffffffffffffffffULL, 0x1ULL))
    )
    {
      return 4;
    }
    else if
    (
      Eurydice_Int128_i128_eq(p->int128,
        Eurydice_Int128_i128_from_bits(0xfffff00000000000ULL, 0x1ULL))
    )
    {
      return 5;
    }
    else
    {
      return 1;
    }
  }
  return 3;
}

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $6size_t
*/
typedef struct arr_d7_s { uint8_t data[6U]; } arr_d7;

void more_primitive_types_use_more_primitive_types(void)
{
  /* original Rust expression is not an lvalue in C */
  arr_d7 lvalue = { .data = { 97U, 104U, 101U, 108U, 108U, 111U } };
  const arr_d7 *s = &lvalue;
  more_primitive_types_MorePrimitiveTypes
  p =
    {
      .int128 = Eurydice_Int128_i128_from_bits(0xfffff00000000000ULL, 0x1ULL),
      .uint128 = Eurydice_Int128_u128_from_bits(0xffffffffffffULL, 0xffffffffffffffffULL),
      .c = 97U
    };
  more_primitive_types_match_u128(&p);
  more_primitive_types_match_i128(&p);
  EURYDICE_ASSERT(p.c == s->data[0U], "panic!");
}

void more_primitive_types_main(void)
{
  more_primitive_types_use_more_primitive_types();
}

int32_t more_primitive_types_more_operations(more_primitive_types_MorePrimitiveTypes *p)
{
  int32_t result = 0;
  Eurydice_Int128_int128_t uu____0 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_add(uu____0, Eurydice_Int128_i128_from_bits(0x0ULL, 0x1ULL));
  Eurydice_Int128_uint128_t uu____1 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_add(uu____1, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL));
  Eurydice_Int128_int128_t uu____2 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_sub(uu____2, Eurydice_Int128_i128_from_bits(0x0ULL, 0x1ULL));
  Eurydice_Int128_uint128_t uu____3 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_sub(uu____3, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL));
  Eurydice_Int128_int128_t uu____4 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_mul(uu____4, Eurydice_Int128_i128_from_bits(0x0ULL, 0x2ULL));
  Eurydice_Int128_uint128_t uu____5 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_mul(uu____5, Eurydice_Int128_u128_from_bits(0x0ULL, 0x2ULL));
  Eurydice_Int128_int128_t uu____6 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_div(uu____6, Eurydice_Int128_i128_from_bits(0x0ULL, 0x2ULL));
  Eurydice_Int128_uint128_t uu____7 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_div(uu____7, Eurydice_Int128_u128_from_bits(0x0ULL, 0x2ULL));
  Eurydice_Int128_int128_t uu____8 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_mod(uu____8, Eurydice_Int128_i128_from_bits(0x0ULL, 0x3ULL));
  Eurydice_Int128_uint128_t uu____9 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_mod(uu____9, Eurydice_Int128_u128_from_bits(0x0ULL, 0x3ULL));
  result += (int32_t)Eurydice_Int128_i128_shl(p->int128, 1U);
  result += (int32_t)Eurydice_Int128_u128_shl(p->uint128, 1U);
  result += (int32_t)Eurydice_Int128_i128_shr(p->int128, 1U);
  result += (int32_t)Eurydice_Int128_u128_shr(p->uint128, 1U);
  Eurydice_Int128_int128_t uu____10 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_band(uu____10, Eurydice_Int128_i128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_uint128_t uu____11 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_band(uu____11, Eurydice_Int128_u128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_int128_t uu____12 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_bor(uu____12, Eurydice_Int128_i128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_uint128_t uu____13 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_bor(uu____13, Eurydice_Int128_u128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_int128_t uu____14 = p->int128;
  result +=
    (int32_t)Eurydice_Int128_i128_bxor(uu____14, Eurydice_Int128_i128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_uint128_t uu____15 = p->uint128;
  result +=
    (int32_t)Eurydice_Int128_u128_bxor(uu____15, Eurydice_Int128_u128_from_bits(0x0ULL, 0xffULL));
  Eurydice_Int128_int128_t uu____16 = p->int128;
  if (Eurydice_Int128_i128_eq(uu____16, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____17 = p->uint128;
  if (Eurydice_Int128_u128_eq(uu____17, Eurydice_Int128_u128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_int128_t uu____18 = p->int128;
  if (Eurydice_Int128_i128_neq(uu____18, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____19 = p->uint128;
  if (Eurydice_Int128_u128_neq(uu____19, Eurydice_Int128_u128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_int128_t uu____20 = p->int128;
  if (Eurydice_Int128_i128_lt(uu____20, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____21 = p->uint128;
  if (Eurydice_Int128_u128_lt(uu____21, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL)))
  {
    result++;
  }
  Eurydice_Int128_int128_t uu____22 = p->int128;
  if (Eurydice_Int128_i128_lte(uu____22, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____23 = p->uint128;
  if (Eurydice_Int128_u128_lte(uu____23, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL)))
  {
    result++;
  }
  Eurydice_Int128_int128_t uu____24 = p->int128;
  if (Eurydice_Int128_i128_gt(uu____24, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____25 = p->uint128;
  if (Eurydice_Int128_u128_gt(uu____25, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL)))
  {
    result++;
  }
  Eurydice_Int128_int128_t uu____26 = p->int128;
  if (Eurydice_Int128_i128_gte(uu____26, Eurydice_Int128_i128_from_bits(0x0ULL, 0x0ULL)))
  {
    result++;
  }
  Eurydice_Int128_uint128_t uu____27 = p->uint128;
  if (Eurydice_Int128_u128_gte(uu____27, Eurydice_Int128_u128_from_bits(0x0ULL, 0x1ULL)))
  {
    result++;
  }
  result += (int32_t)Eurydice_Int128_i128_neg(p->int128);
  result += (int32_t)Eurydice_Int128_i128_bnot(p->int128);
  return result + (int32_t)Eurydice_Int128_u128_bnot(p->uint128);
}



================================================
FILE: out/test-more_primitive_types/more_primitive_types.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef more_primitive_types_H
#define more_primitive_types_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "eurydice/int128.h"

typedef struct more_primitive_types_MorePrimitiveTypes_s
{
  Eurydice_Int128_int128_t int128;
  Eurydice_Int128_uint128_t uint128;
  uint32_t c;
}
more_primitive_types_MorePrimitiveTypes;

int32_t more_primitive_types_int128_operations(more_primitive_types_MorePrimitiveTypes *p);

int32_t more_primitive_types_match_u128(const more_primitive_types_MorePrimitiveTypes *p);

int32_t more_primitive_types_match_i128(const more_primitive_types_MorePrimitiveTypes *p);

void more_primitive_types_use_more_primitive_types(void);

void more_primitive_types_main(void);

int32_t more_primitive_types_more_operations(more_primitive_types_MorePrimitiveTypes *p);

#if defined(__cplusplus)
}
#endif

#define more_primitive_types_H_DEFINED
#endif /* more_primitive_types_H */


================================================
FILE: out/test-more_str/more_str.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "more_str.h"

void more_str_use_str(Eurydice_dst_ref_shared_0d s)
{
  EURYDICE_ASSERT(core_str__str__len(s) > (size_t)2U, "panic!");
}

void more_str_main(void)
{
  Eurydice_dst_ref_shared_0d eng = { .ptr = "Hello, world!", .meta = (size_t)13U };
  Eurydice_dst_ref_shared_0d
  chn = { .ptr = "\\u{4f60}\\u{597d}\\u{ff0c}\\u{4e16}\\u{754c}\\u{ff01}", .meta = (size_t)18U };
  Eurydice_dst_ref_shared_0d
  jpn =
    {
      .ptr = "\\u{3053}\\u{3093}\\u{306b}\\u{3061}\\u{306f}\\u{4e16}\\u{754c}\\u{ff01}",
      .meta = (size_t)24U
    };
  Eurydice_dst_ref_shared_0d
  mix =
    {
      .ptr = "Hello, \\u{4f60}\\u{597d}\\u{ff0c}\\u{3053}\\u{3093}\\u{306b}\\u{3061}\\u{306f}\\u{4e16}\\u{754c}\\u{ff01}123Hi",
      .meta = (size_t)45U
    };
  more_str_use_str(eng);
  more_str_use_str(chn);
  more_str_use_str(jpn);
  more_str_use_str(mix);
}



================================================
FILE: out/test-more_str/more_str.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef more_str_H
#define more_str_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_c_char_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0d_s
{
  const Eurydice_c_char_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0d;

extern size_t core_str__str__len(Eurydice_dst_ref_shared_0d x0);

void more_str_use_str(Eurydice_dst_ref_shared_0d s);

void more_str_main(void);

#if defined(__cplusplus)
}
#endif

#define more_str_H_DEFINED
#endif /* more_str_H */


================================================
FILE: out/test-names/names.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "names.h"

void names_f(uint32_t struct0)
{

}

void names_main(void)
{

}



================================================
FILE: out/test-names/names.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef names_H
#define names_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define names_Foo 0
#define names_Bar 1

typedef uint8_t names_Baz_tags;

typedef struct names_Baz_s
{
  names_Baz_tags tag;
  union {
    struct
    {
      uint32_t f0;
      uint32_t f1;
    }
    case_Foo;
    uint32_t case_Bar;
  }
  val;
}
names_Baz;

typedef struct names_Foo0_s
{
  uint32_t x;
  uint32_t y;
}
names_Foo0;

typedef struct names_Type_s
{
  int32_t switch0;
  int32_t class0;
}
names_Type;

void names_f(uint32_t struct0);

void names_main(void);

#if defined(__cplusplus)
}
#endif

#define names_H_DEFINED
#endif /* names_H */


================================================
FILE: out/test-nested_arrays/nested_arrays.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "nested_arrays.h"

typedef struct const_uint32_t__x2_s
{
  const uint32_t *fst;
  const uint32_t *snd;
}
const_uint32_t__x2;

void nested_arrays_main(void)
{
  Eurydice_arr_9a keys;
  Eurydice_arr_40 repeat_expression0[3U];
  for (size_t i0 = (size_t)0U; i0 < (size_t)3U; i0++)
  {
    Eurydice_arr_40 lit;
    nested_arrays_Key repeat_expression[3U];
    for (size_t i = (size_t)0U; i < (size_t)3U; i++)
    {
      repeat_expression[i] = NESTED_ARRAYS_ZERO;
    }
    memcpy(lit.data, repeat_expression, (size_t)3U * sizeof (nested_arrays_Key));
    repeat_expression0[i0] = lit;
  }
  memcpy(keys.data, repeat_expression0, (size_t)3U * sizeof (Eurydice_arr_40));
  for (size_t i0 = (size_t)0U; i0 < (size_t)3U; i0++)
  {
    size_t i1 = i0;
    for (size_t i2 = (size_t)0U; i2 < (size_t)3U; i2++)
    {
      size_t j = i2;
      for (size_t i = (size_t)0U; i < (size_t)8U; i++)
      {
        size_t k = i;
        uint32_t actual = keys.data[i1].data[j].data[k];
        uint32_t expected = (uint32_t)k;
        const_uint32_t__x2 uu____0 = { .fst = &actual, .snd = &expected };
        EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
      }
    }
  }
}

Eurydice_arr_a1 nested_arrays_test(void)
{
  Eurydice_arr_5c out0 = { .data = { 0U } };
  Eurydice_arr_5c out1 = { .data = { 0U } };
  Eurydice_arr_5c out2 = { .data = { 0U } };
  Eurydice_arr_5c out3 = { .data = { 0U } };
  return (KRML_CLITERAL(Eurydice_arr_a1){ .data = { out0, out1, out2, out3 } });
}



================================================
FILE: out/test-nested_arrays/nested_arrays.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef nested_arrays_H
#define nested_arrays_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern bool
core_cmp_impls__core__cmp__PartialEq_usize__for_usize__eq(const size_t *x0, const size_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_usize__for_usize__partial_cmp(
  const size_t *x0,
  const size_t *x1
);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__backward_checked(size_t x0, size_t x1);

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__forward_checked(size_t x0, size_t x1);

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_usize__steps_between(
  const size_t *x0,
  const size_t *x1
);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

typedef struct nested_arrays_Key_s { uint32_t data[8U]; } nested_arrays_Key;

#define NESTED_ARRAYS_ZERO ((KRML_CLITERAL(nested_arrays_Key){ .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U } }))

/**
A monomorphic instance of Eurydice.arr
with types nested_arrays_Key
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_40_s { nested_arrays_Key data[3U]; } Eurydice_arr_40;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_40
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_9a_s { Eurydice_arr_40 data[3U]; } Eurydice_arr_9a;

void nested_arrays_main(void);

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $200size_t
*/
typedef struct Eurydice_arr_5c_s { uint8_t data[200U]; } Eurydice_arr_5c;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_5c
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_a1_s { Eurydice_arr_5c data[4U]; } Eurydice_arr_a1;

Eurydice_arr_a1 nested_arrays_test(void);

#if defined(__cplusplus)
}
#endif

#define nested_arrays_H_DEFINED
#endif /* nested_arrays_H */


================================================
FILE: out/test-nested_arrays2/nested_arrays2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "nested_arrays2.h"

void nested_arrays2_main(void)
{

}



================================================
FILE: out/test-nested_arrays2/nested_arrays2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef nested_arrays2_H
#define nested_arrays2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_82_s { uint8_t data[1U]; } Eurydice_arr_82;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_82
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_99_s { Eurydice_arr_82 data[1U]; } Eurydice_arr_99;

#define NESTED_ARRAYS2_TABLE ((KRML_CLITERAL(Eurydice_arr_99){ .data = { { .data = { 1U } } } }))

void nested_arrays2_main(void);

#if defined(__cplusplus)
}
#endif

#define nested_arrays2_H_DEFINED
#endif /* nested_arrays2_H */


================================================
FILE: out/test-option/option.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "option.h"

void option_main(void)
{

}

/**
 Converts from `&Option<T>` to `Option<&T>`.

 # Examples

 Calculates the length of an <code>Option<[String]></code> as an <code>Option<[usize]></code>
 without moving the [`String`]. The [`map`] method takes the `self` argument by value,
 consuming the original, so this technique uses `as_ref` to first take an `Option` to a
 reference to the value inside the original.

 [`map`]: Option::map
 [String]: ../../std/string/struct.String.html "String"
 [`String`]: ../../std/string/struct.String.html "String"

 ```
 let text: Option<String> = Some("Hello, world!".to_string());
 // First, cast `Option<String>` to `Option<&String>` with `as_ref`,
 // then consume *that* with `map`, leaving `text` on the stack.
 let text_length: Option<usize> = text.as_ref().map(|s| s.len());
 println!("still can print text: {text:?}");
 ```
*/
/**
This function found in impl {core::option::Option<T>[TraitClause@0]}
*/
/**
A monomorphic instance of core.option.as_ref_cd
with types Eurydice_arr uint8_t[[$16size_t]]

*/
inline core_option_Option_4d core_option_as_ref_cd_4f(const core_option_Option_9e *self)
{
  if (!(self->tag == core_option_None))
  {
    const Eurydice_arr_b2 *x = &self->f0;
    return (KRML_CLITERAL(core_option_Option_4d){ .tag = core_option_Some, .f0 = x });
  }
  return (KRML_CLITERAL(core_option_Option_4d){ .tag = core_option_None });
}

/**
This function found in impl {option::S}
*/
core_option_Option_4d option_option_ref_b6(const core_option_Option_9e *self)
{
  return core_option_as_ref_cd_4f(self);
}



================================================
FILE: out/test-option/option.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef option_H
#define option_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_b2_s { uint8_t data[16U]; } Eurydice_arr_b2;

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_9e_tags;

/**
A monomorphic instance of core.option.Option
with types Eurydice_arr_b2

*/
typedef struct core_option_Option_9e_s
{
  core_option_Option_9e_tags tag;
  Eurydice_arr_b2 f0;
}
core_option_Option_9e;

typedef core_option_Option_9e option_S;

typedef Eurydice_arr_b2 option_Val;

void option_main(void);

/**
A monomorphic instance of core.option.Option
with types const Eurydice_arr_b2*

*/
typedef struct core_option_Option_4d_s
{
  core_option_Option_9e_tags tag;
  const Eurydice_arr_b2 *f0;
}
core_option_Option_4d;

/**
 Converts from `&Option<T>` to `Option<&T>`.

 # Examples

 Calculates the length of an <code>Option<[String]></code> as an <code>Option<[usize]></code>
 without moving the [`String`]. The [`map`] method takes the `self` argument by value,
 consuming the original, so this technique uses `as_ref` to first take an `Option` to a
 reference to the value inside the original.

 [`map`]: Option::map
 [String]: ../../std/string/struct.String.html "String"
 [`String`]: ../../std/string/struct.String.html "String"

 ```
 let text: Option<String> = Some("Hello, world!".to_string());
 // First, cast `Option<String>` to `Option<&String>` with `as_ref`,
 // then consume *that* with `map`, leaving `text` on the stack.
 let text_length: Option<usize> = text.as_ref().map(|s| s.len());
 println!("still can print text: {text:?}");
 ```
*/
/**
This function found in impl {core::option::Option<T>[TraitClause@0]}
*/
/**
A monomorphic instance of core.option.as_ref_cd
with types Eurydice_arr uint8_t[[$16size_t]]

*/
core_option_Option_4d core_option_as_ref_cd_4f(const core_option_Option_9e *self);

/**
This function found in impl {option::S}
*/
core_option_Option_4d option_option_ref_b6(const core_option_Option_9e *self);

#if defined(__cplusplus)
}
#endif

#define option_H_DEFINED
#endif /* option_H */


================================================
FILE: out/test-parentparent/parentparent.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "parentparent.h"

void parentparent_main(void)
{

}



================================================
FILE: out/test-parentparent/parentparent.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef parentparent_H
#define parentparent_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

void parentparent_main(void);

#if defined(__cplusplus)
}
#endif

#define parentparent_H_DEFINED
#endif /* parentparent_H */


================================================
FILE: out/test-partial_eq/partial_eq.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "partial_eq.h"

/**
This function found in impl {core::cmp::PartialEq<partial_eq::Enum> for partial_eq::Enum}
*/
inline bool partial_eq_eq_31(const partial_eq_Enum *self, const partial_eq_Enum *other)
{
  return true;
}

typedef struct const_partial_eq_Enum__x2_s
{
  const partial_eq_Enum *fst;
  const partial_eq_Enum *snd;
}
const_partial_eq_Enum__x2;

typedef struct const_const_partial_eq_Enum___x2_s
{
  const partial_eq_Enum *const *fst;
  const partial_eq_Enum *const *snd;
}
const_const_partial_eq_Enum___x2;

void partial_eq_main(void)
{
  partial_eq_Enum expected = partial_eq_Enum_A;
  const_partial_eq_Enum__x2 uu____0 = { .fst = &expected, .snd = &expected };
  EURYDICE_ASSERT(partial_eq_eq_31(uu____0.fst, uu____0.snd), "panic!");
  /* original Rust expression is not an lvalue in C */
  const partial_eq_Enum *lvalue0 = &expected;
  /* original Rust expression is not an lvalue in C */
  const partial_eq_Enum *lvalue = &expected;
  const_const_partial_eq_Enum___x2 uu____1 = { .fst = &lvalue0, .snd = &lvalue };
  EURYDICE_ASSERT(partial_eq_eq_31(uu____1.fst[0U], uu____1.snd[0U]), "panic!");
}

/**
This function found in impl {core::fmt::Debug for partial_eq::Enum}
*/
inline core_result_Result_10
partial_eq_fmt_29(const partial_eq_Enum *self, core_fmt_Formatter *f)
{
  return
    core_fmt__core__fmt__Formatter__a___write_str(f,
      (KRML_CLITERAL(Eurydice_dst_ref_shared_0d){ .ptr = "A", .meta = (size_t)1U }));
}



================================================
FILE: out/test-partial_eq/partial_eq.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef partial_eq_H
#define partial_eq_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_c_char_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0d_s
{
  const Eurydice_c_char_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0d;

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_10;

extern core_result_Result_10
core_fmt__core__fmt__Formatter__a___write_str(
  core_fmt_Formatter *x0,
  Eurydice_dst_ref_shared_0d x1
);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

#define partial_eq_Enum_A 0

typedef uint8_t partial_eq_Enum;

/**
This function found in impl {core::cmp::PartialEq<partial_eq::Enum> for partial_eq::Enum}
*/
bool partial_eq_eq_31(const partial_eq_Enum *self, const partial_eq_Enum *other);

void partial_eq_main(void);

/**
This function found in impl {core::fmt::Debug for partial_eq::Enum}
*/
core_result_Result_10 partial_eq_fmt_29(const partial_eq_Enum *self, core_fmt_Formatter *f);

#if defined(__cplusplus)
}
#endif

#define partial_eq_H_DEFINED
#endif /* partial_eq_H */


================================================
FILE: out/test-raw_pointers/raw_pointers.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "raw_pointers.h"

typedef struct const_uint8_t__x2_s
{
  const uint8_t *fst;
  const uint8_t *snd;
}
const_uint8_t__x2;

void raw_pointers_main(void)
{
  uint8_t x = 0U;
  const uint8_t *px = (const uint8_t *)&x;
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue = 0U;
  const_uint8_t__x2 uu____0 = { .fst = &lvalue, .snd = px };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}



================================================
FILE: out/test-raw_pointers/raw_pointers.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef raw_pointers_H
#define raw_pointers_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void raw_pointers_main(void);

#if defined(__cplusplus)
}
#endif

#define raw_pointers_H_DEFINED
#endif /* raw_pointers_H */


================================================
FILE: out/test-reborrow/reborrow.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "reborrow.h"

typedef struct const_uint8_t__x2_s
{
  const uint8_t *fst;
  const uint8_t *snd;
}
const_uint8_t__x2;

void reborrow_main(void)
{
  uint8_t x = 0U;
  const uint8_t *px = (const uint8_t *)&x;
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue0 = 0U;
  const_uint8_t__x2 uu____0 = { .fst = &lvalue0, .snd = px };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  const uint8_t *py = px;
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue1 = 0U;
  const_uint8_t__x2 uu____1 = { .fst = &lvalue1, .snd = py };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  uint8_t val = 0U;
  uint8_t *b = Eurydice_box_new(val, uint8_t, uint8_t *);
  const uint8_t *pb = b;
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue2 = 0U;
  const_uint8_t__x2 uu____2 = { .fst = &lvalue2, .snd = pb };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  const uint8_t *pb2 = pb;
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue = 0U;
  const_uint8_t__x2 uu____3 = { .fst = &lvalue, .snd = pb2 };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
}



================================================
FILE: out/test-reborrow/reborrow.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef reborrow_H
#define reborrow_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void reborrow_main(void);

#if defined(__cplusplus)
}
#endif

#define reborrow_H_DEFINED
#endif /* reborrow_H */


================================================
FILE: out/test-recursion/recursion.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "recursion.h"

bool recursion_is_odd(int32_t y)
{
  if (!(y < 0))
  {
    switch (y)
    {
      case 0:
        {
          break;
        }
      case 1:
        {
          return true;
        }
      default:
        {
          int32_t y0 = y;
          return recursion_is_odd(y0 - 2);
        }
    }
    return false;
  }
  return recursion_is_odd(-y);
}

void recursion_main(void)
{
  EURYDICE_ASSERT(!!recursion_is_odd(5), "assert failure");
}



================================================
FILE: out/test-recursion/recursion.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef recursion_H
#define recursion_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

bool recursion_is_odd(int32_t y);

void recursion_main(void);

#if defined(__cplusplus)
}
#endif

#define recursion_H_DEFINED
#endif /* recursion_H */


================================================
FILE: out/test-repeat/repeat.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "repeat.h"

void repeat_main(void)
{
  if
  (
    !(REPEAT_C1.data[0U] + REPEAT_C2.data->data[0U] +
      (uint32_t)REPEAT_REJECTION_SAMPLE_SHUFFLE_TABLE.data[255U].data[0U]
    != 0U)
  )
  {
    return;
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}



================================================
FILE: out/test-repeat/repeat.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef repeat_H
#define repeat_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of Eurydice.arr
with types uint32_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_d5_s { uint32_t data[1U]; } Eurydice_arr_d5;

#define REPEAT_C1 ((KRML_CLITERAL(Eurydice_arr_d5){ .data = { 0U } }))

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_d5
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_aa_s { Eurydice_arr_d5 data[1U]; } Eurydice_arr_aa;

#define REPEAT_C2 ((KRML_CLITERAL(Eurydice_arr_aa){ .data = { { .data = { 0U } } } }))

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $16size_t
*/
typedef struct Eurydice_arr_b2_s { uint8_t data[16U]; } Eurydice_arr_b2;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_b2
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_87_s { Eurydice_arr_b2 data[256U]; } Eurydice_arr_87;

#define REPEAT_REJECTION_SAMPLE_SHUFFLE_TABLE ((KRML_CLITERAL(Eurydice_arr_87){ .data = { { .data = { 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 255U, 255U, 255U, 255U } }, { .data = { 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 255U, 255U } }, { .data = { 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 14U, 15U, 255U, 255U } }, { .data = { 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U, 255U, 255U } }, { .data = { 0U, 1U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U, 255U, 255U } }, { .data = { 0U, 1U, 2U, 3U, 4U, 5U, 6U, 7U, 8U, 9U, 10U, 11U, 12U, 13U, 14U, 15U } } } }))

void repeat_main(void);

#if defined(__cplusplus)
}
#endif

#define repeat_H_DEFINED
#endif /* repeat_H */


================================================
FILE: out/test-result/result.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "result.h"

result_S result_ident(result_S x)
{
  return x;
}

result_S result_mk1(uint32_t x, uint32_t y)
{
  return
    (KRML_CLITERAL(result_S){ .tag = result_S1, .val = { .case_S1 = { .x1 = x, .y1 = y } } });
}

void result_main(void)
{
  result_S uu____0 = result_mk1(0U, 0U);
  if (uu____0.tag == result_S1)
  {
    switch (uu____0.val.case_S1.x1)
    {
      case 0U:
        {
          switch (uu____0.val.case_S1.y1)
          {
            case 0U:
              {
                result_S
                uu____1 =
                  result_ident((
                      KRML_CLITERAL(result_S){
                        .tag = result_S2,
                        .val = { .case_S2 = { .x2 = 0U, .y2 = 0U } }
                      }
                    ));
                if (uu____1.tag == result_S2)
                {
                  switch (uu____1.val.case_S2.x2)
                  {
                    case 0U:
                      {
                        switch (uu____1.val.case_S2.y2)
                        {
                          case 0U:
                            {
                              return;
                            }
                          default:
                            {

                            }
                        }
                        break;
                      }
                    default:
                      {

                      }
                  }
                }
                KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
                KRML_HOST_EXIT(255U);
                break;
              }
            default:
              {

              }
          }
          break;
        }
      default:
        {

        }
    }
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}



================================================
FILE: out/test-result/result.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef result_H
#define result_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define result_S1 0
#define result_S2 1

typedef uint8_t result_S_tags;

typedef struct result_S_s
{
  result_S_tags tag;
  union {
    struct
    {
      uint32_t x1;
      uint32_t y1;
    }
    case_S1;
    struct
    {
      uint32_t x2;
      uint32_t y2;
    }
    case_S2;
  }
  val;
}
result_S;

result_S result_ident(result_S x);

result_S result_mk1(uint32_t x, uint32_t y);

void result_main(void);

#if defined(__cplusplus)
}
#endif

#define result_H_DEFINED
#endif /* result_H */


================================================
FILE: out/test-signed_wrapping/signed_wrapping.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "signed_wrapping.h"

typedef struct const_int8_t__x2_s
{
  const int8_t *fst;
  const int8_t *snd;
}
const_int8_t__x2;

typedef struct const_int16_t__x2_s
{
  const int16_t *fst;
  const int16_t *snd;
}
const_int16_t__x2;

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

typedef struct const_int64_t__x2_s
{
  const int64_t *fst;
  const int64_t *snd;
}
const_int64_t__x2;

void signed_wrapping_main(void)
{
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue0 = core_num__i8__wrapping_add(100, 27);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue1 = 127;
  const_int8_t__x2 uu____0 = { .fst = &lvalue0, .snd = &lvalue1 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue2 = core_num__i8__wrapping_add(100, 100);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue3 = -56;
  const_int8_t__x2 uu____1 = { .fst = &lvalue2, .snd = &lvalue3 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue4 = core_num__i8__wrapping_add(-128, -1);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue5 = 127;
  const_int8_t__x2 uu____2 = { .fst = &lvalue4, .snd = &lvalue5 };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue6 = core_num__i8__wrapping_sub(10, 20);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue7 = -10;
  const_int8_t__x2 uu____3 = { .fst = &lvalue6, .snd = &lvalue7 };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue8 = core_num__i8__wrapping_sub(-128, 1);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue9 = 127;
  const_int8_t__x2 uu____4 = { .fst = &lvalue8, .snd = &lvalue9 };
  EURYDICE_ASSERT(uu____4.fst[0U] == uu____4.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue10 = core_num__i8__wrapping_sub(127, -1);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue11 = -128;
  const_int8_t__x2 uu____5 = { .fst = &lvalue10, .snd = &lvalue11 };
  EURYDICE_ASSERT(uu____5.fst[0U] == uu____5.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue12 = core_num__i8__wrapping_mul(10, 5);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue13 = 50;
  const_int8_t__x2 uu____6 = { .fst = &lvalue12, .snd = &lvalue13 };
  EURYDICE_ASSERT(uu____6.fst[0U] == uu____6.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue14 = core_num__i8__wrapping_mul(100, 2);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue15 = -56;
  const_int8_t__x2 uu____7 = { .fst = &lvalue14, .snd = &lvalue15 };
  EURYDICE_ASSERT(uu____7.fst[0U] == uu____7.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue16 = core_num__i8__wrapping_mul(-128, -1);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue17 = -128;
  const_int8_t__x2 uu____8 = { .fst = &lvalue16, .snd = &lvalue17 };
  EURYDICE_ASSERT(uu____8.fst[0U] == uu____8.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue18 = core_num__i8__wrapping_neg(5);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue19 = -5;
  const_int8_t__x2 uu____9 = { .fst = &lvalue18, .snd = &lvalue19 };
  EURYDICE_ASSERT(uu____9.fst[0U] == uu____9.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue20 = core_num__i8__wrapping_neg(-128);
  /* original Rust expression is not an lvalue in C */
  int8_t lvalue21 = -128;
  const_int8_t__x2 uu____10 = { .fst = &lvalue20, .snd = &lvalue21 };
  EURYDICE_ASSERT(uu____10.fst[0U] == uu____10.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue22 = core_num__i16__wrapping_add(30000, 2768);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue23 = -32768;
  const_int16_t__x2 uu____11 = { .fst = &lvalue22, .snd = &lvalue23 };
  EURYDICE_ASSERT(uu____11.fst[0U] == uu____11.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue24 = core_num__i16__wrapping_add(-32768, -1);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue25 = 32767;
  const_int16_t__x2 uu____12 = { .fst = &lvalue24, .snd = &lvalue25 };
  EURYDICE_ASSERT(uu____12.fst[0U] == uu____12.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue26 = core_num__i16__wrapping_sub(-32768, 1);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue27 = 32767;
  const_int16_t__x2 uu____13 = { .fst = &lvalue26, .snd = &lvalue27 };
  EURYDICE_ASSERT(uu____13.fst[0U] == uu____13.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue28 = core_num__i16__wrapping_sub(32767, -1);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue29 = -32768;
  const_int16_t__x2 uu____14 = { .fst = &lvalue28, .snd = &lvalue29 };
  EURYDICE_ASSERT(uu____14.fst[0U] == uu____14.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue30 = core_num__i16__wrapping_mul(200, 200);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue31 = -25536;
  const_int16_t__x2 uu____15 = { .fst = &lvalue30, .snd = &lvalue31 };
  EURYDICE_ASSERT(uu____15.fst[0U] == uu____15.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue32 = core_num__i16__wrapping_mul(-32768, -1);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue33 = -32768;
  const_int16_t__x2 uu____16 = { .fst = &lvalue32, .snd = &lvalue33 };
  EURYDICE_ASSERT(uu____16.fst[0U] == uu____16.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue34 = core_num__i16__wrapping_neg(5);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue35 = -5;
  const_int16_t__x2 uu____17 = { .fst = &lvalue34, .snd = &lvalue35 };
  EURYDICE_ASSERT(uu____17.fst[0U] == uu____17.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue36 = core_num__i16__wrapping_neg(-32768);
  /* original Rust expression is not an lvalue in C */
  int16_t lvalue37 = -32768;
  const_int16_t__x2 uu____18 = { .fst = &lvalue36, .snd = &lvalue37 };
  EURYDICE_ASSERT(uu____18.fst[0U] == uu____18.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue38 = core_num__i32__wrapping_add(2000000000, 2000000000);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue39 = -294967296;
  const_int32_t__x2 uu____19 = { .fst = &lvalue38, .snd = &lvalue39 };
  EURYDICE_ASSERT(uu____19.fst[0U] == uu____19.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue40 = core_num__i32__wrapping_add(INT32_MIN, -1);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue41 = 2147483647;
  const_int32_t__x2 uu____20 = { .fst = &lvalue40, .snd = &lvalue41 };
  EURYDICE_ASSERT(uu____20.fst[0U] == uu____20.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue42 = core_num__i32__wrapping_sub(INT32_MIN, 1);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue43 = 2147483647;
  const_int32_t__x2 uu____21 = { .fst = &lvalue42, .snd = &lvalue43 };
  EURYDICE_ASSERT(uu____21.fst[0U] == uu____21.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue44 = core_num__i32__wrapping_sub(2147483647, -1);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue45 = INT32_MIN;
  const_int32_t__x2 uu____22 = { .fst = &lvalue44, .snd = &lvalue45 };
  EURYDICE_ASSERT(uu____22.fst[0U] == uu____22.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue46 = core_num__i32__wrapping_mul(100000, 100000);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue47 = 1410065408;
  const_int32_t__x2 uu____23 = { .fst = &lvalue46, .snd = &lvalue47 };
  EURYDICE_ASSERT(uu____23.fst[0U] == uu____23.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue48 = core_num__i32__wrapping_mul(INT32_MIN, -1);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue49 = INT32_MIN;
  const_int32_t__x2 uu____24 = { .fst = &lvalue48, .snd = &lvalue49 };
  EURYDICE_ASSERT(uu____24.fst[0U] == uu____24.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue50 = core_num__i32__wrapping_neg(5);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue51 = -5;
  const_int32_t__x2 uu____25 = { .fst = &lvalue50, .snd = &lvalue51 };
  EURYDICE_ASSERT(uu____25.fst[0U] == uu____25.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue52 = core_num__i32__wrapping_neg(INT32_MIN);
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue53 = INT32_MIN;
  const_int32_t__x2 uu____26 = { .fst = &lvalue52, .snd = &lvalue53 };
  EURYDICE_ASSERT(uu____26.fst[0U] == uu____26.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue54 = core_num__i64__wrapping_add(5000000000000000000LL, 5000000000000000000LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue55 = -8446744073709551616LL;
  const_int64_t__x2 uu____27 = { .fst = &lvalue54, .snd = &lvalue55 };
  EURYDICE_ASSERT(uu____27.fst[0U] == uu____27.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue56 = core_num__i64__wrapping_add(INT64_MIN, -1LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue57 = 9223372036854775807LL;
  const_int64_t__x2 uu____28 = { .fst = &lvalue56, .snd = &lvalue57 };
  EURYDICE_ASSERT(uu____28.fst[0U] == uu____28.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue58 = core_num__i64__wrapping_sub(INT64_MIN, 1LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue59 = 9223372036854775807LL;
  const_int64_t__x2 uu____29 = { .fst = &lvalue58, .snd = &lvalue59 };
  EURYDICE_ASSERT(uu____29.fst[0U] == uu____29.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue60 = core_num__i64__wrapping_sub(9223372036854775807LL, -1LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue61 = INT64_MIN;
  const_int64_t__x2 uu____30 = { .fst = &lvalue60, .snd = &lvalue61 };
  EURYDICE_ASSERT(uu____30.fst[0U] == uu____30.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue62 = core_num__i64__wrapping_mul(3000000000LL, 3000000000LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue63 = 9000000000000000000LL;
  const_int64_t__x2 uu____31 = { .fst = &lvalue62, .snd = &lvalue63 };
  EURYDICE_ASSERT(uu____31.fst[0U] == uu____31.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue64 = core_num__i64__wrapping_mul(INT64_MIN, -1LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue65 = INT64_MIN;
  const_int64_t__x2 uu____32 = { .fst = &lvalue64, .snd = &lvalue65 };
  EURYDICE_ASSERT(uu____32.fst[0U] == uu____32.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue66 = core_num__i64__wrapping_neg(5LL);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue67 = -5LL;
  const_int64_t__x2 uu____33 = { .fst = &lvalue66, .snd = &lvalue67 };
  EURYDICE_ASSERT(uu____33.fst[0U] == uu____33.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue68 = core_num__i64__wrapping_neg(INT64_MIN);
  /* original Rust expression is not an lvalue in C */
  int64_t lvalue = INT64_MIN;
  const_int64_t__x2 uu____34 = { .fst = &lvalue68, .snd = &lvalue };
  EURYDICE_ASSERT(uu____34.fst[0U] == uu____34.snd[0U], "panic!");
}



================================================
FILE: out/test-signed_wrapping/signed_wrapping.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef signed_wrapping_H
#define signed_wrapping_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

static inline int16_t core_num__i16__wrapping_add(int16_t x0, int16_t x1);

static inline int16_t core_num__i16__wrapping_mul(int16_t x0, int16_t x1);

static inline int16_t core_num__i16__wrapping_neg(int16_t x0);

static inline int16_t core_num__i16__wrapping_sub(int16_t x0, int16_t x1);

static inline int32_t core_num__i32__wrapping_add(int32_t x0, int32_t x1);

static inline int32_t core_num__i32__wrapping_mul(int32_t x0, int32_t x1);

static inline int32_t core_num__i32__wrapping_neg(int32_t x0);

static inline int32_t core_num__i32__wrapping_sub(int32_t x0, int32_t x1);

static inline int64_t core_num__i64__wrapping_add(int64_t x0, int64_t x1);

static inline int64_t core_num__i64__wrapping_mul(int64_t x0, int64_t x1);

static inline int64_t core_num__i64__wrapping_neg(int64_t x0);

static inline int64_t core_num__i64__wrapping_sub(int64_t x0, int64_t x1);

static inline int8_t core_num__i8__wrapping_add(int8_t x0, int8_t x1);

static inline int8_t core_num__i8__wrapping_mul(int8_t x0, int8_t x1);

static inline int8_t core_num__i8__wrapping_neg(int8_t x0);

static inline int8_t core_num__i8__wrapping_sub(int8_t x0, int8_t x1);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void signed_wrapping_main(void);

#if defined(__cplusplus)
}
#endif

#define signed_wrapping_H_DEFINED
#endif /* signed_wrapping_H */


================================================
FILE: out/test-slice_array/slice_array.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "slice_array.h"

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types Eurydice_arr uint8_t[[$4size_t]]
with const generics
- N= 4
*/
static Eurydice_dst_ref_mut_b5 array_to_slice_mut_4e(Eurydice_arr_ba *a)
{
  Eurydice_dst_ref_mut_b5 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

typedef struct const_uint8_t__x2_s
{
  const uint8_t *fst;
  const uint8_t *snd;
}
const_uint8_t__x2;

void slice_array_f1(void)
{
  Eurydice_arr_ba
  x =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_dst_ref_mut_b5
  y0 =
    Eurydice_slice_split_at_mut(array_to_slice_mut_4e(&x),
      (size_t)2U,
      Eurydice_array_u8x4,
      Eurydice_dst_ref_mut_b5_x2).fst;
  y0.ptr->data[0U] = 1U;
  uint8_t actual = x.data->data[0U];
  uint8_t expected = 1U;
  const_uint8_t__x2 uu____0 = { .fst = &actual, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void slice_array_f2(void)
{
  Eurydice_arr_ba
  x =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_dst_ref_mut_b5
  y0 =
    Eurydice_slice_split_at_mut(array_to_slice_mut_4e(&x),
      (size_t)2U,
      Eurydice_array_u8x4,
      Eurydice_dst_ref_mut_b5_x2).fst;
  Eurydice_array_u8x4 z = y0.ptr[0U];
  z.data[0U] = 1U;
  uint8_t actual = x.data->data[0U];
  uint8_t expected = 0U;
  const_uint8_t__x2 uu____0 = { .fst = &actual, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  /* original Rust expression is not an lvalue in C */
  uint8_t lvalue = 1U;
  const_uint8_t__x2 uu____1 = { .fst = z.data, .snd = &lvalue };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4
*/
static Eurydice_borrow_slice_u8 array_to_slice_shared_98(const Eurydice_array_u8x4 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types Eurydice_arr uint8_t[[$4size_t]], core_array_TryFromSliceError

*/
static Eurydice_array_u8x4 unwrap_26_cc(core_result_Result_c7 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
This function found in impl {core::result::Result<T, E>[TraitClause@0, TraitClause@1]}
*/
/**
A monomorphic instance of core.result.unwrap_26
with types const Eurydice_arr uint8_t[[$4size_t]]*, core_array_TryFromSliceError

*/
static const Eurydice_array_u8x4 *unwrap_26_7f(core_result_Result_90 self)
{
  if (self.tag == core_result_Ok)
  {
    return self.val.case_Ok;
  }
  else
  {
    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "unwrap not Ok");
    KRML_HOST_EXIT(255U);
  }
}

/**
A monomorphic instance of Eurydice.array_to_slice_mut
with types uint8_t
with const generics
- N= 4
*/
static Eurydice_mut_borrow_slice_u8 array_to_slice_mut_98(Eurydice_array_u8x4 *a)
{
  Eurydice_mut_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

void slice_array_f3(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue0 = { .data = { 0U } };
  Eurydice_borrow_slice_u8 x1 = array_to_slice_shared_98(&lvalue0);
  Eurydice_array_u8x4 arr0;
  memcpy(arr0.data, x1.ptr, (size_t)4U * sizeof (uint8_t));
  Eurydice_array_u8x4
  y1 =
    unwrap_26_cc((
        KRML_CLITERAL(core_result_Result_c7){ .tag = core_result_Ok, .val = { .case_Ok = arr0 } }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue1 = { .data = { 0U } };
  Eurydice_borrow_slice_u8 x2 = array_to_slice_shared_98(&lvalue1);
  Eurydice_borrow_slice_u8 uu____0 = x2;
  Eurydice_array_u8x4 arr1;
  memcpy(arr1.data, uu____0.ptr, (size_t)4U * sizeof (uint8_t));
  const
  Eurydice_array_u8x4
  *y2 =
    unwrap_26_7f(Eurydice_slice_to_ref_array2((size_t)4U,
        uu____0,
        &arr1,
        Eurydice_borrow_slice_u8,
        const Eurydice_array_u8x4 *,
        core_array_TryFromSliceError,
        core_result_Result_90));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue = { .data = { 0U } };
  Eurydice_mut_borrow_slice_u8 x3 = array_to_slice_mut_98(&lvalue);
  Eurydice_array_u8x4 arr;
  memcpy(arr.data, x3.ptr, (size_t)4U * sizeof (uint8_t));
  Eurydice_array_u8x4
  y3 =
    unwrap_26_cc((
        KRML_CLITERAL(core_result_Result_c7){ .tag = core_result_Ok, .val = { .case_Ok = arr } }
      ));
  const_uint8_t__x2 uu____1 = { .fst = y1.data, .snd = y2->data };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  const_uint8_t__x2 uu____2 = { .fst = y1.data, .snd = y3.data };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
}

/**
A monomorphic instance of slice_array.f4
with const generics
- K= 4
*/
void slice_array_f4_23(void)
{
  Eurydice_arr_ba
  x =
    { .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } } };
  Eurydice_dst_ref_mut_b5
  y0 =
    Eurydice_slice_split_at_mut(array_to_slice_mut_4e(&x),
      (size_t)2U,
      Eurydice_array_u8x4,
      Eurydice_dst_ref_mut_b5_x2).fst;
  y0.ptr->data[0U] = 1U;
  uint8_t actual = x.data->data[0U];
  uint8_t expected = 1U;
  const_uint8_t__x2 uu____0 = { .fst = &actual, .snd = &expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of slice_array.f5
with const generics
- K= 4
*/
void slice_array_f5_23(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue0 = { .data = { 0U } };
  Eurydice_borrow_slice_u8 x1 = array_to_slice_shared_98(&lvalue0);
  Eurydice_array_u8x4 arr0;
  memcpy(arr0.data, x1.ptr, (size_t)4U * sizeof (uint8_t));
  Eurydice_array_u8x4
  y1 =
    unwrap_26_cc((
        KRML_CLITERAL(core_result_Result_c7){ .tag = core_result_Ok, .val = { .case_Ok = arr0 } }
      ));
  /* original Rust expression is not an lvalue in C */
  Eurydice_array_u8x4 lvalue = { .data = { 0U } };
  Eurydice_borrow_slice_u8
  x2 = core_array___T__N___as_slice((size_t)4U, &lvalue, uint8_t, Eurydice_borrow_slice_u8);
  Eurydice_borrow_slice_u8 uu____0 = x2;
  Eurydice_array_u8x4 arr;
  memcpy(arr.data, uu____0.ptr, (size_t)4U * sizeof (uint8_t));
  const
  Eurydice_array_u8x4
  *y2 =
    unwrap_26_7f(Eurydice_slice_to_ref_array2((size_t)4U,
        uu____0,
        &arr,
        Eurydice_borrow_slice_u8,
        const Eurydice_array_u8x4 *,
        core_array_TryFromSliceError,
        core_result_Result_90));
  const_uint8_t__x2 uu____1 = { .fst = y1.data, .snd = y2->data };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}

void slice_array_main(void)
{
  slice_array_f1();
  slice_array_f2();
  slice_array_f3();
  slice_array_f4_23();
  slice_array_f5_23();
}



================================================
FILE: out/test-slice_array/slice_array.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef slice_array_H
#define slice_array_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#define core_result_Ok 0
#define core_result_Err 1

typedef uint8_t core_result_Result_10;

extern core_result_Result_10
core_array__core__fmt__Debug_for_core__array__TryFromSliceError__fmt(
  const core_array_TryFromSliceError *x0,
  core_fmt_Formatter *x1
);

extern uint8_t core_clone_impls__core__clone__Clone_for_u8__clone(const uint8_t *x0);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_array_u8x4, size_t

*/
typedef struct Eurydice_dst_ref_mut_b5_s
{
  Eurydice_array_u8x4 *ptr;
  size_t meta;
}
Eurydice_dst_ref_mut_b5;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_array_u8x4
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_ba_s { Eurydice_array_u8x4 data[4U]; } Eurydice_arr_ba;

typedef struct Eurydice_dst_ref_mut_b5_x2_s
{
  Eurydice_dst_ref_mut_b5 fst;
  Eurydice_dst_ref_mut_b5 snd;
}
Eurydice_dst_ref_mut_b5_x2;

void slice_array_f1(void);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_array_u8x4, size_t

*/
typedef struct Eurydice_dst_ref_shared_b5_s
{
  const Eurydice_array_u8x4 *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_b5;

void slice_array_f2(void);

/**
A monomorphic instance of core.result.Result
with types Eurydice_array_u8x4, core_array_TryFromSliceError

*/
typedef struct core_result_Result_c7_s
{
  core_result_Result_10 tag;
  union {
    Eurydice_array_u8x4 case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_c7;

/**
A monomorphic instance of core.result.Result
with types const Eurydice_array_u8x4*, core_array_TryFromSliceError

*/
typedef struct core_result_Result_90_s
{
  core_result_Result_10 tag;
  union {
    const Eurydice_array_u8x4 *case_Ok;
    core_array_TryFromSliceError case_Err;
  }
  val;
}
core_result_Result_90;

void slice_array_f3(void);

/**
A monomorphic instance of slice_array.f4
with const generics
- K= 4
*/
void slice_array_f4_23(void);

/**
A monomorphic instance of slice_array.f5
with const generics
- K= 4
*/
void slice_array_f5_23(void);

void slice_array_main(void);

#if defined(__cplusplus)
}
#endif

#define slice_array_H_DEFINED
#endif /* slice_array_H */


================================================
FILE: out/test-step_by/step_by.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "step_by.h"

typedef struct const_int32_t__x2_s
{
  const int32_t *fst;
  const int32_t *snd;
}
const_int32_t__x2;

void step_by_bar(void)
{
  int32_t i0 = 0;
  for (int32_t i = 0; i < 24; i += (int32_t)(size_t)6U)
  {
    int32_t j = i;
    i0 += j;
  }
  /* original Rust expression is not an lvalue in C */
  int32_t lvalue = 36;
  const_int32_t__x2 uu____0 = { .fst = &i0, .snd = &lvalue };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

void step_by_main1(void)
{
  step_by_bar();
  int32_t i0 = 0;
  for (int32_t i = 0; i < 24; i += (int32_t)(size_t)6U)
  {
    int32_t j = i;
    i0 += j;
  }
  for (int32_t i = 0; i < 24; i += (int32_t)(size_t)6U)
  {
    int32_t j = i;
    i0 += j;
  }
}

void step_by_main2(void)
{
  step_by_main1();
  for (int32_t i = 0; i < 24; i += (int32_t)(size_t)6U)
  {

  }
  for (int32_t i = 0; i < 24; i += (int32_t)(size_t)6U)
  {

  }
}

void step_by_main(void)
{
  step_by_main2();
  for (int32_t i = 0; i < 24; i++)
  {

  }
  for (int32_t i = 0; i < 24; i++)
  {

  }
}



================================================
FILE: out/test-step_by/step_by.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef step_by_H
#define step_by_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern int32_t core_clone_impls__core__clone__Clone_for_i32__clone(const int32_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern bool
core_cmp_impls__core__cmp__PartialEq_i32__for_i32__eq(const int32_t *x0, const int32_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_i32__for_i32__partial_cmp(
  const int32_t *x0,
  const int32_t *x1
);

/**
A monomorphic instance of core.option.Option
with types int32_t

*/
typedef struct core_option_Option_9e_s
{
  core_option_Option_77_tags tag;
  int32_t f0;
}
core_option_Option_9e;

extern core_option_Option_9e
core_iter_range__core__iter__range__Step_for_i32__backward_checked(int32_t x0, size_t x1);

extern core_option_Option_9e
core_iter_range__core__iter__range__Step_for_i32__forward_checked(int32_t x0, size_t x1);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_i32__steps_between(
  const int32_t *x0,
  const int32_t *x1
);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

void step_by_bar(void);

void step_by_main1(void);

void step_by_main2(void);

void step_by_main(void);

#if defined(__cplusplus)
}
#endif

#define step_by_H_DEFINED
#endif /* step_by_H */


================================================
FILE: out/test-substr/substr.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "substr.h"

/**
A monomorphic instance of Eurydice.dst_ref_mut
with types Eurydice_c_char_t, size_t

*/
typedef struct dst_ref_mut_0d_s
{
  Eurydice_c_char_t *ptr;
  size_t meta;
}
dst_ref_mut_0d;

#define None 0
#define Some 1

typedef uint8_t Option_9f_tags;

/**
A monomorphic instance of core.option.Option
with types Eurydice_dst_ref_shared_0d

*/
typedef struct Option_9f_s
{
  Option_9f_tags tag;
  Eurydice_dst_ref_shared_0d f0;
}
Option_9f;

extern Option_9f
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get(
  size_t x0,
  Eurydice_dst_ref_shared_0d x1
);

/**
A monomorphic instance of core.option.Option
with types Eurydice_dst_ref_mut_0d

*/
typedef struct Option_c0_s
{
  Option_9f_tags tag;
  dst_ref_mut_0d f0;
}
Option_c0;

extern Option_c0
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_mut(
  size_t x0,
  dst_ref_mut_0d x1
);

extern Eurydice_dst_ref_shared_0d
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_unchecked(
  size_t x0,
  Eurydice_dst_ref_shared_0d x1
);

extern dst_ref_mut_0d
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_unchecked_mut(
  size_t x0,
  dst_ref_mut_0d x1
);

extern Eurydice_dst_ref_shared_0d
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____index(
  size_t x0,
  Eurydice_dst_ref_shared_0d x1
);

extern dst_ref_mut_0d
core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____index_mut(
  size_t x0,
  dst_ref_mut_0d x1
);

void substr_main(void)
{
  Eurydice_dst_ref_shared_0d str = { .ptr = "abc", .meta = (size_t)3U };
  Eurydice_dst_ref_shared_0d
  take =
    core_str_traits__core__ops__index__Index_I__Clause1_Output__for_str__index(core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get,
      core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_mut,
      core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_unchecked,
      core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____get_unchecked_mut,
      core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____index,
      core_str_traits__core__slice__index__SliceIndex_str__str__for_core__ops__range__RangeFrom_usize__core__marker__Sized_usize____index_mut,
      str,
      (size_t)1U,
      size_t,
      Eurydice_c_char_t [],
      Eurydice_dst_ref_shared_0d);
  EURYDICE_ASSERT(core_str__str__len(take) == (size_t)2U, "panic!");
}



================================================
FILE: out/test-substr/substr.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef substr_H
#define substr_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

#include "substr_stubs.h"

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types Eurydice_c_char_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_0d_s
{
  const Eurydice_c_char_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_0d;

extern size_t core_str__str__len(Eurydice_dst_ref_shared_0d x0);

void substr_main(void);

#if defined(__cplusplus)
}
#endif

#define substr_H_DEFINED
#endif /* substr_H */


================================================
FILE: out/test-symcrust/internal/Eurydice.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef internal_Eurydice_H
#define internal_Eurydice_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern uint32_t Eurydice_min_u32(uint32_t x, uint32_t y);

#if defined(__cplusplus)
}
#endif

#define internal_Eurydice_H_DEFINED
#endif /* internal_Eurydice_H */


================================================
FILE: out/test-symcrust/symcrust.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "symcrust.h"

#include "internal/Eurydice.h"

/**
A monomorphic instance of Eurydice.slice_subslice_mut
with types uint8_t, core_ops_range_Range size_t, Eurydice_derefed_slice uint8_t

*/
static Eurydice_mut_borrow_slice_u8
slice_subslice_mut_c8(Eurydice_mut_borrow_slice_u8 s, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_mut_borrow_slice_u8){ .ptr = s.ptr + r.start, .meta = r.end - r.start }
    );
}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types uint8_t
with const generics
- N= 4
*/
static Eurydice_borrow_slice_u8 array_to_slice_shared_98(const Eurydice_array_u8x4 *a)
{
  Eurydice_borrow_slice_u8 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)4U;
  return lit;
}

void
symcrust_SymCrustMlKemPolyElementCompressAndEncode(
  const Eurydice_arr_82 *coeffs,
  uint32_t nBitsPerCoefficient,
  Eurydice_mut_borrow_slice_u8 dst
)
{
  uint64_t SYMCRYPT_MLKEM_COMPRESS_MULCONSTANT = 10321339ULL;
  uint32_t SYMCRYPT_MLKEM_COMPRESS_SHIFTCONSTANT = 35U;
  size_t cbDstWritten = (size_t)0U;
  uint32_t accumulator = 0U;
  uint32_t nBitsInAccumulator = 0U;
  EURYDICE_ASSERT(nBitsPerCoefficient > 0U, "panic!");
  EURYDICE_ASSERT(nBitsPerCoefficient <= 12U, "panic!");
  EURYDICE_ASSERT((uint64_t)dst.meta == 256ULL * (uint64_t)nBitsPerCoefficient / 8ULL, "panic!");
  for (size_t i = (size_t)0U; i < (size_t)256U; i++)
  {
    size_t i0 = i;
    uint32_t nBitsInCoefficient = nBitsPerCoefficient;
    uint32_t coefficient = (uint32_t)coeffs->data[i0];
    if (nBitsPerCoefficient < 12U)
    {
      uint64_t multiplication = (uint64_t)coefficient * SYMCRYPT_MLKEM_COMPRESS_MULCONSTANT;
      coefficient =
        (uint32_t)(multiplication >>
          (uint32_t)(SYMCRYPT_MLKEM_COMPRESS_SHIFTCONSTANT - (nBitsPerCoefficient + 1U)));
      coefficient++;
      coefficient >>= 1U;
      coefficient &= ((1U << (uint32_t)nBitsPerCoefficient) - 1U);
    }
    while (nBitsInCoefficient > 0U)
    {
      uint32_t nBitsToEncode = Eurydice_min_u32(nBitsInCoefficient, 32U - nBitsInAccumulator);
      uint32_t bitsToEncode = coefficient & ((1U << (uint32_t)nBitsToEncode) - 1U);
      coefficient >>= (uint32_t)nBitsToEncode;
      nBitsInCoefficient -= nBitsToEncode;
      accumulator |= bitsToEncode << (uint32_t)nBitsInAccumulator;
      nBitsInAccumulator += nBitsToEncode;
      if (nBitsInAccumulator == 32U)
      {
        Eurydice_mut_borrow_slice_u8
        uu____0 =
          slice_subslice_mut_c8(dst,
            (
              KRML_CLITERAL(core_ops_range_Range_87){
                .start = cbDstWritten,
                .end = cbDstWritten + (size_t)4U
              }
            ));
        /* original Rust expression is not an lvalue in C */
        Eurydice_array_u8x4 lvalue = core_num__u32__to_le_bytes(accumulator);
        Eurydice_slice_copy(uu____0, array_to_slice_shared_98(&lvalue), uint8_t);
        cbDstWritten += (size_t)4U;
        accumulator = 0U;
        nBitsInAccumulator = 0U;
      }
    }
  }
}

void symcrust_main(void)
{

}



================================================
FILE: out/test-symcrust/symcrust.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef symcrust_H
#define symcrust_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern uint8_t core_clone_impls__core__clone__Clone_for_u8__clone(const uint8_t *x0);

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern uint32_t core_cmp_impls__core__cmp__Ord_for_u32__min(uint32_t x0, uint32_t x1);

extern bool
core_cmp_impls__core__cmp__PartialEq_usize__for_usize__eq(const size_t *x0, const size_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_usize__for_usize__partial_cmp(
  const size_t *x0,
  const size_t *x1
);

static inline uint32_t core_convert_num__core__convert__From_u16__for_u32__from(uint16_t x0);

static inline uint64_t core_convert_num__core__convert__From_u32__for_u64__from(uint32_t x0);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__backward_checked(size_t x0, size_t x1);

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__forward_checked(size_t x0, size_t x1);

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_usize__steps_between(
  const size_t *x0,
  const size_t *x1
);

static inline Eurydice_array_u8x4 core_num__u32__to_le_bytes(uint32_t x0);

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

/**
A monomorphic instance of Eurydice.arr
with types uint16_t
with const generics
- $256size_t
*/
typedef struct Eurydice_arr_82_s { uint16_t data[256U]; } Eurydice_arr_82;

void
symcrust_SymCrustMlKemPolyElementCompressAndEncode(
  const Eurydice_arr_82 *coeffs,
  uint32_t nBitsPerCoefficient,
  Eurydice_mut_borrow_slice_u8 dst
);

void symcrust_main(void);

#if defined(__cplusplus)
}
#endif

#define symcrust_H_DEFINED
#endif /* symcrust_H */


================================================
FILE: out/test-trait_generics/trait_generics.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "trait_generics.h"

/**
This function found in impl {trait_generics::MyFnOnce for trait_generics::Foo<K>}
*/
/**
A monomorphic instance of trait_generics.call_once_a3
with const generics
- K= 10
*/
uint32_t trait_generics_call_once_a3_55(void)
{
  return 0U;
}

/**
A monomorphic instance of trait_generics.from_fn
with types trait_generics_Foo[[$10size_t]]
with const generics

*/
void trait_generics_from_fn_74(void)
{
  trait_generics_call_once_a3_55();
}

void trait_generics_main(void)
{
  trait_generics_from_fn_74();
}



================================================
FILE: out/test-trait_generics/trait_generics.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef trait_generics_H
#define trait_generics_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
This function found in impl {trait_generics::MyFnOnce for trait_generics::Foo<K>}
*/
/**
A monomorphic instance of trait_generics.call_once_a3
with const generics
- K= 10
*/
uint32_t trait_generics_call_once_a3_55(void);

/**
A monomorphic instance of trait_generics.from_fn
with types trait_generics_Foo[[$10size_t]]
with const generics

*/
void trait_generics_from_fn_74(void);

void trait_generics_main(void);

#if defined(__cplusplus)
}
#endif

#define trait_generics_H_DEFINED
#endif /* trait_generics_H */


================================================
FILE: out/test-traits/traits.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "traits.h"

/**
This function found in impl {traits::ToInt for traits::Foo}
*/
uint32_t traits_to_int_ac(const traits_Foo *self)
{
  switch (self[0U])
  {
    case traits_Foo_Foo1:
      {
        break;
      }
    case traits_Foo_Foo2:
      {
        return 2U;
      }
    default:
      {
        KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, __LINE__);
        KRML_HOST_EXIT(253U);
      }
  }
  return 1U;
}

/**
This function found in impl {traits::ToInt for &0 ([traits::Foo])}
*/
uint32_t traits_to_int_0f(const Eurydice_dst_ref_shared_42 *self)
{
  uint32_t uu____0 = traits_to_int_ac(&self->ptr[0U]);
  return uu____0 * traits_to_int_ac(&self->ptr[1U]);
}

/**
A monomorphic instance of Eurydice.array_to_subslice_shared
with types traits_Foo, core_ops_range_Range size_t, Eurydice_derefed_slice traits_Foo
with const generics
- N= 2
*/
static Eurydice_dst_ref_shared_42
array_to_subslice_shared_7d(const Eurydice_arr_0e *a, core_ops_range_Range_87 r)
{
  return
    (
      KRML_CLITERAL(Eurydice_dst_ref_shared_42){ .ptr = a->data + r.start, .meta = r.end - r.start }
    );
}

void traits_main(void)
{
  Eurydice_arr_0e foos = { .data = { traits_Foo_Foo1, traits_Foo_Foo2 } };
  /* original Rust expression is not an lvalue in C */
  Eurydice_dst_ref_shared_42
  lvalue =
    array_to_subslice_shared_7d(&foos,
      (KRML_CLITERAL(core_ops_range_Range_87){ .start = (size_t)0U, .end = (size_t)2U }));
  if (!(traits_to_int_0f(&lvalue) != 2U))
  {
    return;
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}



================================================
FILE: out/test-traits/traits.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef traits_H
#define traits_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

#define traits_Foo_Foo1 0
#define traits_Foo_Foo2 1

typedef uint8_t traits_Foo;

/**
This function found in impl {traits::ToInt for traits::Foo}
*/
uint32_t traits_to_int_ac(const traits_Foo *self);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types traits_Foo, size_t

*/
typedef struct Eurydice_dst_ref_shared_42_s
{
  const traits_Foo *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_42;

/**
This function found in impl {traits::ToInt for &0 ([traits::Foo])}
*/
uint32_t traits_to_int_0f(const Eurydice_dst_ref_shared_42 *self);

/**
A monomorphic instance of Eurydice.arr
with types traits_Foo
with const generics
- $2size_t
*/
typedef struct Eurydice_arr_0e_s { traits_Foo data[2U]; } Eurydice_arr_0e;

void traits_main(void);

#if defined(__cplusplus)
}
#endif

#define traits_H_DEFINED
#endif /* traits_H */


================================================
FILE: out/test-traits2/traits2.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "traits2.h"

void traits2_main(void)
{

}



================================================
FILE: out/test-traits2/traits2.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef traits2_H
#define traits2_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

#define core_cmp_Ordering_Less -1
#define core_cmp_Ordering_Equal 0
#define core_cmp_Ordering_Greater 1

typedef int8_t core_cmp_Ordering;

extern bool
core_cmp_impls__core__cmp__PartialEq_usize__for_usize__eq(const size_t *x0, const size_t *x1);

#define core_option_None 0
#define core_option_Some 1

typedef uint8_t core_option_Option_77_tags;

/**
A monomorphic instance of core.option.Option
with types core_cmp_Ordering

*/
typedef struct core_option_Option_77_s
{
  core_option_Option_77_tags tag;
  core_cmp_Ordering f0;
}
core_option_Option_77;

extern core_option_Option_77
core_cmp_impls__core__cmp__PartialOrd_usize__for_usize__partial_cmp(
  const size_t *x0,
  const size_t *x1
);

/**
A monomorphic instance of core.option.Option
with types size_t

*/
typedef struct core_option_Option_87_s
{
  core_option_Option_77_tags tag;
  size_t f0;
}
core_option_Option_87;

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__backward_checked(size_t x0, size_t x1);

extern core_option_Option_87
core_iter_range__core__iter__range__Step_for_usize__forward_checked(size_t x0, size_t x1);

/**
A monomorphic instance of n-tuple
with types size_t, core_option_Option_87

*/
typedef struct tuple_21_s
{
  size_t fst;
  core_option_Option_87 snd;
}
tuple_21;

extern tuple_21
core_iter_range__core__iter__range__Step_for_usize__steps_between(
  const size_t *x0,
  const size_t *x1
);

/**
A monomorphic instance of core.ops.range.Range
with types size_t

*/
typedef struct core_ops_range_Range_87_s
{
  size_t start;
  size_t end;
}
core_ops_range_Range_87;

void traits2_main(void);

#if defined(__cplusplus)
}
#endif

#define traits2_H_DEFINED
#endif /* traits2_H */


================================================
FILE: out/test-traits3/traits3.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "traits3.h"

/**
This function found in impl {traits3::internal::KeccakItem<2usize> for (u64, u64)}
*/
uint64_t_x2 traits3_zero_c8(void)
{
  return (KRML_CLITERAL(uint64_t_x2){ .fst = 0ULL, .snd = 0ULL });
}

/**
A monomorphic instance of traits3.keccak
with types (uint64_t * uint64_t)
with const generics
- N= 2
*/
void traits3_keccak_ea(void)
{

}

void traits3_keccakx2(void)
{

}

void traits3_main(void)
{

}



================================================
FILE: out/test-traits3/traits3.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef traits3_H
#define traits3_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

typedef struct uint64_t_x2_s
{
  uint64_t fst;
  uint64_t snd;
}
uint64_t_x2;

/**
This function found in impl {traits3::internal::KeccakItem<2usize> for (u64, u64)}
*/
uint64_t_x2 traits3_zero_c8(void);

/**
A monomorphic instance of traits3.keccak
with types (uint64_t * uint64_t)
with const generics
- N= 2
*/
void traits3_keccak_ea(void);

void traits3_keccakx2(void);

void traits3_main(void);

typedef uint64_t_x2 traits3_uint64x2_t;

#if defined(__cplusplus)
}
#endif

#define traits3_H_DEFINED
#endif /* traits3_H */


================================================
FILE: out/test-we_need_charon_monomorphization/we_need_charon_monomorphization.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "we_need_charon_monomorphization.h"

/**
A monomorphic instance of we_need_charon_monomorphization.use_ref
with types Eurydice_derefed_slice int32_t

*/
void we_need_charon_monomorphization_use_ref_ee(const int32_t (*_t)[])
{

}

void we_need_charon_monomorphization_supply_ref(Eurydice_dst_ref_shared_83 s)
{

}

/**
A monomorphic instance of Eurydice.array_to_slice_shared
with types int32_t
with const generics
- N= 3
*/
static Eurydice_dst_ref_shared_83 array_to_slice_shared_ab(const Eurydice_arr_bf *a)
{
  Eurydice_dst_ref_shared_83 lit;
  lit.ptr = a->data;
  lit.meta = (size_t)3U;
  return lit;
}

void we_need_charon_monomorphization_main(void)
{
  /* original Rust expression is not an lvalue in C */
  Eurydice_arr_bf lvalue = { .data = { 1, 2, 3 } };
  we_need_charon_monomorphization_supply_ref(array_to_slice_shared_ab(&lvalue));
}



================================================
FILE: out/test-we_need_charon_monomorphization/we_need_charon_monomorphization.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef we_need_charon_monomorphization_H
#define we_need_charon_monomorphization_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

/**
A monomorphic instance of we_need_charon_monomorphization.use_ref
with types Eurydice_derefed_slice int32_t

*/
void we_need_charon_monomorphization_use_ref_ee(const int32_t (*_t)[]);

/**
A monomorphic instance of Eurydice.dst_ref_shared
with types int32_t, size_t

*/
typedef struct Eurydice_dst_ref_shared_83_s
{
  const int32_t *ptr;
  size_t meta;
}
Eurydice_dst_ref_shared_83;

void we_need_charon_monomorphization_supply_ref(Eurydice_dst_ref_shared_83 s);

/**
A monomorphic instance of Eurydice.arr
with types int32_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_bf_s { int32_t data[3U]; } Eurydice_arr_bf;

void we_need_charon_monomorphization_main(void);

#if defined(__cplusplus)
}
#endif

#define we_need_charon_monomorphization_H_DEFINED
#endif /* we_need_charon_monomorphization_H */


================================================
FILE: out/test-where_clauses_closures/where_clauses_closures.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "where_clauses_closures.h"

/**
This function found in impl {where_clauses_closures::Ops<1usize> for usize}
*/
size_t where_clauses_closures_zero_38(void)
{
  return (size_t)0U;
}

/**
This function found in impl {where_clauses_closures::Ops<1usize> for usize}
*/
size_t where_clauses_closures_of_usize_38(size_t x)
{
  return x;
}

/**
This function found in impl {core::ops::function::FnMut<(usize), T> for where_clauses_closures::test::closure<T, K>[TraitClause@0, TraitClause@1, TraitClause@2]}
*/
/**
A monomorphic instance of where_clauses_closures.test.call_mut_1a
with types size_t
with const generics
- K= 1
*/
size_t where_clauses_closures_test_call_mut_1a_df(void **_, size_t tupled_args)
{
  size_t i = tupled_args;
  return where_clauses_closures_of_usize_38(i);
}

/**
This function found in impl {core::ops::function::FnOnce<(usize), T> for where_clauses_closures::test::closure<T, K>[TraitClause@0, TraitClause@1, TraitClause@2]}
*/
/**
A monomorphic instance of where_clauses_closures.test.call_once_79
with types size_t
with const generics
- K= 1
*/
size_t where_clauses_closures_test_call_once_79_df(size_t _)
{
  /* original Rust expression is not an lvalue in C */
  void *lvalue = (void *)0U;
  return where_clauses_closures_test_call_mut_1a_df(&lvalue, _);
}

/**
A monomorphic instance of where_clauses_closures.test
with types size_t
with const generics
- K= 1
*/
size_t_x2 where_clauses_closures_test_df(void)
{
  Eurydice_arr_58 arr_struct;
  {
    /* original Rust expression is not an lvalue in C */
    void *lvalue = (void *)0U;
    arr_struct.data[0U] = where_clauses_closures_test_call_mut_1a_df(&lvalue, (size_t)0U);
  }
  Eurydice_arr_58 x = arr_struct;
  size_t y = where_clauses_closures_zero_38();
  return (KRML_CLITERAL(size_t_x2){ .fst = x.data[0U], .snd = y });
}

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

void where_clauses_closures_main(void)
{
  size_t_x2 uu____0 = where_clauses_closures_test_df();
  size_t x = uu____0.fst;
  size_t y = uu____0.snd;
  const_size_t__x2 uu____1 = { .fst = &x, .snd = &y };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}



================================================
FILE: out/test-where_clauses_closures/where_clauses_closures.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef where_clauses_closures_H
#define where_clauses_closures_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
This function found in impl {where_clauses_closures::Ops<1usize> for usize}
*/
size_t where_clauses_closures_zero_38(void);

/**
This function found in impl {where_clauses_closures::Ops<1usize> for usize}
*/
size_t where_clauses_closures_of_usize_38(size_t x);

/**
This function found in impl {core::ops::function::FnMut<(usize), T> for where_clauses_closures::test::closure<T, K>[TraitClause@0, TraitClause@1, TraitClause@2]}
*/
/**
A monomorphic instance of where_clauses_closures.test.call_mut_1a
with types size_t
with const generics
- K= 1
*/
size_t where_clauses_closures_test_call_mut_1a_df(void **_, size_t tupled_args);

/**
This function found in impl {core::ops::function::FnOnce<(usize), T> for where_clauses_closures::test::closure<T, K>[TraitClause@0, TraitClause@1, TraitClause@2]}
*/
/**
A monomorphic instance of where_clauses_closures.test.call_once_79
with types size_t
with const generics
- K= 1
*/
size_t where_clauses_closures_test_call_once_79_df(size_t _);

typedef struct size_t_x2_s
{
  size_t fst;
  size_t snd;
}
size_t_x2;

/**
A monomorphic instance of Eurydice.arr
with types size_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_58_s { size_t data[1U]; } Eurydice_arr_58;

/**
A monomorphic instance of where_clauses_closures.test
with types size_t
with const generics
- K= 1
*/
size_t_x2 where_clauses_closures_test_df(void);

void where_clauses_closures_main(void);

#if defined(__cplusplus)
}
#endif

#define where_clauses_closures_H_DEFINED
#endif /* where_clauses_closures_H */


================================================
FILE: out/test-where_clauses_fncg/where_clauses_fncg.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "where_clauses_fncg.h"

/**
This function found in impl {where_clauses_fncg::Foo<K> for u64}
*/
/**
A monomorphic instance of where_clauses_fncg.bar_16
with const generics
- K= 8
- L= 4
*/
uint64_t where_clauses_fncg_bar_16_f4(Eurydice_arr_07 x, Eurydice_arr_34 _)
{
  return (uint64_t)x.data->data[0U];
}

/**
A monomorphic instance of where_clauses_fncg.f
with types uint64_t
with const generics
- K= 6
- L= 8
- M= 10
*/
uint64_t where_clauses_fncg_f_d3(void)
{
  return
    where_clauses_fncg_bar_16_f4((
        KRML_CLITERAL(Eurydice_arr_07){
          .data = {
            { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
            { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
          }
        }
      ),
      (
        KRML_CLITERAL(Eurydice_arr_34){
          .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } }
        }
      ));
}

/**
This function found in impl {where_clauses_fncg::Foo<K> for u64}
*/
/**
A monomorphic instance of where_clauses_fncg.bar_16
with const generics
- K= 12
- L= 4
*/
uint64_t where_clauses_fncg_bar_16_9e(Eurydice_arr_40 x, Eurydice_arr_11 _)
{
  return (uint64_t)x.data->data[0U];
}

/**
This function found in impl {where_clauses_fncg::UseFoo for ()}
*/
/**
A monomorphic instance of where_clauses_fncg.method_foo_db
with types uint64_t
with const generics
- K= 12
*/
uint64_t where_clauses_fncg_method_foo_db_27(void)
{
  return
    where_clauses_fncg_bar_16_9e((
        KRML_CLITERAL(Eurydice_arr_40){
          .data = {
            { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
            { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } },
            { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }
          }
        }
      ),
      (
        KRML_CLITERAL(Eurydice_arr_11){
          .data = { { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } }, { .data = { 0U } } }
        }
      ));
}

/**
A monomorphic instance of where_clauses_fncg.g
with types ()
with const generics

*/
uint64_t where_clauses_fncg_g_ec(void)
{
  return where_clauses_fncg_method_foo_db_27();
}

typedef struct const_uint64_t__x2_s
{
  const uint64_t *fst;
  const uint64_t *snd;
}
const_uint64_t__x2;

void where_clauses_fncg_main(void)
{
  uint64_t r = where_clauses_fncg_f_d3();
  /* original Rust expression is not an lvalue in C */
  uint64_t lvalue0 = 0ULL;
  const_uint64_t__x2 uu____0 = { .fst = &r, .snd = &lvalue0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  uint64_t r0 = where_clauses_fncg_g_ec();
  /* original Rust expression is not an lvalue in C */
  uint64_t lvalue = 0ULL;
  const_uint64_t__x2 uu____1 = { .fst = &r0, .snd = &lvalue };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
}



================================================
FILE: out/test-where_clauses_fncg/where_clauses_fncg.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef where_clauses_fncg_H
#define where_clauses_fncg_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

static inline uint64_t core_convert_num__core__convert__From_u8__for_u64__from(uint8_t x0);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_array_u8x4
with const generics
- $8size_t
*/
typedef struct Eurydice_arr_07_s { Eurydice_array_u8x4 data[8U]; } Eurydice_arr_07;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_array_u8x8
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_34_s { Eurydice_array_u8x8 data[4U]; } Eurydice_arr_34;

/**
This function found in impl {where_clauses_fncg::Foo<K> for u64}
*/
/**
A monomorphic instance of where_clauses_fncg.bar_16
with const generics
- K= 8
- L= 4
*/
uint64_t where_clauses_fncg_bar_16_f4(Eurydice_arr_07 x, Eurydice_arr_34 _);

/**
A monomorphic instance of where_clauses_fncg.f
with types uint64_t
with const generics
- K= 6
- L= 8
- M= 10
*/
uint64_t where_clauses_fncg_f_d3(void);

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_array_u8x4
with const generics
- $12size_t
*/
typedef struct Eurydice_arr_40_s { Eurydice_array_u8x4 data[12U]; } Eurydice_arr_40;

/**
A monomorphic instance of Eurydice.arr
with types uint8_t
with const generics
- $12size_t
*/
typedef struct Eurydice_arr_a3_s { uint8_t data[12U]; } Eurydice_arr_a3;

/**
A monomorphic instance of Eurydice.arr
with types Eurydice_arr_a3
with const generics
- $4size_t
*/
typedef struct Eurydice_arr_11_s { Eurydice_arr_a3 data[4U]; } Eurydice_arr_11;

/**
This function found in impl {where_clauses_fncg::Foo<K> for u64}
*/
/**
A monomorphic instance of where_clauses_fncg.bar_16
with const generics
- K= 12
- L= 4
*/
uint64_t where_clauses_fncg_bar_16_9e(Eurydice_arr_40 x, Eurydice_arr_11 _);

/**
This function found in impl {where_clauses_fncg::UseFoo for ()}
*/
/**
A monomorphic instance of where_clauses_fncg.method_foo_db
with types uint64_t
with const generics
- K= 12
*/
uint64_t where_clauses_fncg_method_foo_db_27(void);

/**
A monomorphic instance of where_clauses_fncg.g
with types ()
with const generics

*/
uint64_t where_clauses_fncg_g_ec(void);

void where_clauses_fncg_main(void);

#if defined(__cplusplus)
}
#endif

#define where_clauses_fncg_H_DEFINED
#endif /* where_clauses_fncg_H */


================================================
FILE: out/test-where_clauses_simple/where_clauses_simple.c
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "where_clauses_simple.h"

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.of_u16_81
with const generics
- K= 3
*/
size_t where_clauses_simple_of_u16_81_78(uint16_t x)
{
  return (size_t)x;
}

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.add_81
with const generics
- K= 3
*/
size_t where_clauses_simple_add_81_78(Eurydice_arr_dc x, size_t y)
{
  return (size_t)x.data[0U] + y + (size_t)3U;
}

/**
A monomorphic instance of where_clauses_simple.fn_k
with types size_t
with const generics
- K= 3
*/
size_t where_clauses_simple_fn_k_f3(void)
{
  size_t x = where_clauses_simple_of_u16_81_78(0U);
  return where_clauses_simple_add_81_78((KRML_CLITERAL(Eurydice_arr_dc){ .data = { 0U } }), x);
}

typedef struct const_size_t__x2_s
{
  const size_t *fst;
  const size_t *snd;
}
const_size_t__x2;

void where_clauses_simple_k_calls_k(void)
{
  size_t r = where_clauses_simple_fn_k_f3();
  size_t r_expected = (size_t)3U;
  const_size_t__x2 uu____0 = { .fst = &r, .snd = &r_expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
This function found in impl {where_clauses_simple::Ops<1usize> for u64}
*/
uint64_t where_clauses_simple_add_19(Eurydice_arr_96 x, uint64_t y)
{
  return (uint64_t)x.data[0U] + y;
}

/**
This function found in impl {where_clauses_simple::Ops<1usize> for u64}
*/
uint64_t where_clauses_simple_of_u16_19(uint16_t x)
{
  return (uint64_t)x;
}

/**
A monomorphic instance of where_clauses_simple.fn_k
with types uint64_t
with const generics
- K= 1
*/
uint64_t where_clauses_simple_fn_k_1c(void)
{
  uint64_t x = where_clauses_simple_of_u16_19(0U);
  return where_clauses_simple_add_19((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), x);
}

typedef struct const_uint64_t__x2_s
{
  const uint64_t *fst;
  const uint64_t *snd;
}
const_uint64_t__x2;

void where_clauses_simple_k_calls_one(void)
{
  uint64_t r = where_clauses_simple_fn_k_1c();
  uint64_t r_expected = 0ULL;
  const_uint64_t__x2 uu____0 = { .fst = &r, .snd = &r_expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.of_u16_81
with const generics
- K= 1
*/
size_t where_clauses_simple_of_u16_81_6c(uint16_t x)
{
  return (size_t)x;
}

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.add_81
with const generics
- K= 1
*/
size_t where_clauses_simple_add_81_6c(Eurydice_arr_96 x, size_t y)
{
  return (size_t)x.data[0U] + y + (size_t)1U;
}

/**
A monomorphic instance of where_clauses_simple.fn_1
with types size_t
with const generics

*/
size_t where_clauses_simple_fn_1_2f(void)
{
  size_t x = where_clauses_simple_of_u16_81_6c(0U);
  return where_clauses_simple_add_81_6c((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), x);
}

void where_clauses_simple_one_calls_k(void)
{
  size_t r = where_clauses_simple_fn_1_2f();
  size_t r_expected = (size_t)1U;
  const_size_t__x2 uu____0 = { .fst = &r, .snd = &r_expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of where_clauses_simple.fn_1
with types uint64_t
with const generics

*/
uint64_t where_clauses_simple_fn_1_e5(void)
{
  uint64_t x = where_clauses_simple_of_u16_19(0U);
  return where_clauses_simple_add_19((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), x);
}

void where_clauses_simple_one_calls_one(void)
{
  uint64_t r = where_clauses_simple_fn_1_e5();
  uint64_t r_expected = 0ULL;
  const_uint64_t__x2 uu____0 = { .fst = &r, .snd = &r_expected };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
}

/**
A monomorphic instance of where_clauses_simple.double
with types uint64_t, size_t
with const generics

*/
tuple_3d where_clauses_simple_double_4e(uint64_t x, size_t y)
{
  uint64_t
  uu____0 = where_clauses_simple_add_19((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), x);
  return
    (
      KRML_CLITERAL(tuple_3d){
        .fst = uu____0,
        .snd = where_clauses_simple_add_81_6c((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), y)
      }
    );
}

/**
A monomorphic instance of where_clauses_simple.double_k
with types size_t, uint64_t
with const generics
- K= 3
*/
tuple_7d where_clauses_simple_double_k_c8(size_t x, uint64_t y)
{
  size_t
  uu____0 = where_clauses_simple_add_81_78((KRML_CLITERAL(Eurydice_arr_dc){ .data = { 0U } }), x);
  return
    (
      KRML_CLITERAL(tuple_7d){
        .fst = uu____0,
        .snd = where_clauses_simple_add_19((KRML_CLITERAL(Eurydice_arr_96){ .data = { 0U } }), y)
      }
    );
}

void where_clauses_simple_main(void)
{
  where_clauses_simple_k_calls_k();
  where_clauses_simple_k_calls_one();
  where_clauses_simple_one_calls_k();
  where_clauses_simple_one_calls_one();
  tuple_3d x = where_clauses_simple_double_4e(1ULL, (size_t)1U);
  tuple_7d y = where_clauses_simple_double_k_c8((size_t)1U, 1ULL);
  uint64_t x_0 = 1ULL;
  size_t x_1 = (size_t)2U;
  const_uint64_t__x2 uu____0 = { .fst = &x.fst, .snd = &x_0 };
  EURYDICE_ASSERT(uu____0.fst[0U] == uu____0.snd[0U], "panic!");
  const_size_t__x2 uu____1 = { .fst = &x.snd, .snd = &x_1 };
  EURYDICE_ASSERT(uu____1.fst[0U] == uu____1.snd[0U], "panic!");
  size_t y_0 = (size_t)4U;
  uint64_t y_1 = 1ULL;
  const_size_t__x2 uu____2 = { .fst = &y.fst, .snd = &y_0 };
  EURYDICE_ASSERT(uu____2.fst[0U] == uu____2.snd[0U], "panic!");
  const_uint64_t__x2 uu____3 = { .fst = &y.snd, .snd = &y_1 };
  EURYDICE_ASSERT(uu____3.fst[0U] == uu____3.snd[0U], "panic!");
}



================================================
FILE: out/test-where_clauses_simple/where_clauses_simple.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef where_clauses_simple_H
#define where_clauses_simple_H

#include "eurydice_glue.h"


#if defined(__cplusplus)
extern "C" {
#endif

extern uint64_t core_clone_impls__core__clone__Clone_for_u64__clone(const uint64_t *x0);

extern size_t core_clone_impls__core__clone__Clone_for_usize__clone(const size_t *x0);

static inline uint64_t core_convert_num__core__convert__From_u16__for_u64__from(uint16_t x0);

static inline size_t core_convert_num__core__convert__From_u16__for_usize__from(uint16_t x0);

#define core_panicking_AssertKind_Eq 0
#define core_panicking_AssertKind_Ne 1
#define core_panicking_AssertKind_Match 2

typedef uint8_t core_panicking_AssertKind;

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.of_u16_81
with const generics
- K= 3
*/
size_t where_clauses_simple_of_u16_81_78(uint16_t x);

/**
A monomorphic instance of Eurydice.arr
with types uint16_t
with const generics
- $3size_t
*/
typedef struct Eurydice_arr_dc_s { uint16_t data[3U]; } Eurydice_arr_dc;

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.add_81
with const generics
- K= 3
*/
size_t where_clauses_simple_add_81_78(Eurydice_arr_dc x, size_t y);

/**
A monomorphic instance of where_clauses_simple.fn_k
with types size_t
with const generics
- K= 3
*/
size_t where_clauses_simple_fn_k_f3(void);

void where_clauses_simple_k_calls_k(void);

/**
A monomorphic instance of Eurydice.arr
with types uint16_t
with const generics
- $1size_t
*/
typedef struct Eurydice_arr_96_s { uint16_t data[1U]; } Eurydice_arr_96;

/**
This function found in impl {where_clauses_simple::Ops<1usize> for u64}
*/
uint64_t where_clauses_simple_add_19(Eurydice_arr_96 x, uint64_t y);

/**
This function found in impl {where_clauses_simple::Ops<1usize> for u64}
*/
uint64_t where_clauses_simple_of_u16_19(uint16_t x);

/**
A monomorphic instance of where_clauses_simple.fn_k
with types uint64_t
with const generics
- K= 1
*/
uint64_t where_clauses_simple_fn_k_1c(void);

void where_clauses_simple_k_calls_one(void);

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.of_u16_81
with const generics
- K= 1
*/
size_t where_clauses_simple_of_u16_81_6c(uint16_t x);

/**
This function found in impl {where_clauses_simple::Ops<K> for usize}
*/
/**
A monomorphic instance of where_clauses_simple.add_81
with const generics
- K= 1
*/
size_t where_clauses_simple_add_81_6c(Eurydice_arr_96 x, size_t y);

/**
A monomorphic instance of where_clauses_simple.fn_1
with types size_t
with const generics

*/
size_t where_clauses_simple_fn_1_2f(void);

void where_clauses_simple_one_calls_k(void);

/**
A monomorphic instance of where_clauses_simple.fn_1
with types uint64_t
with const generics

*/
uint64_t where_clauses_simple_fn_1_e5(void);

void where_clauses_simple_one_calls_one(void);

/**
A monomorphic instance of n-tuple
with types uint64_t, size_t

*/
typedef struct tuple_3d_s
{
  uint64_t fst;
  size_t snd;
}
tuple_3d;

/**
A monomorphic instance of where_clauses_simple.double
with types uint64_t, size_t
with const generics

*/
tuple_3d where_clauses_simple_double_4e(uint64_t x, size_t y);

/**
A monomorphic instance of n-tuple
with types size_t, uint64_t

*/
typedef struct tuple_7d_s
{
  size_t fst;
  uint64_t snd;
}
tuple_7d;

/**
A monomorphic instance of where_clauses_simple.double_k
with types size_t, uint64_t
with const generics
- K= 3
*/
tuple_7d where_clauses_simple_double_k_c8(size_t x, uint64_t y);

void where_clauses_simple_main(void);

#if defined(__cplusplus)
}
#endif

#define where_clauses_simple_H_DEFINED
#endif /* where_clauses_simple_H */


================================================
FILE: out/testxx-result/result.cc
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#include "result.h"

result_S result_ident(result_S x)
{
  return x;
}

result_S result_mk1(uint32_t x, uint32_t y)
{
  return result_S_s(result_S1, &result_S_s::U::case_S1, { x, y });
}

void result_main(void)
{
  result_S uu____0 = result_mk1(0U, 0U);
  if (uu____0.tag == result_S1)
  {
    switch (uu____0.val.case_S1.x1)
    {
      case 0U:
        {
          switch (uu____0.val.case_S1.y1)
          {
            case 0U:
              {
                result_S
                uu____1 = result_ident(result_S_s(result_S2, &result_S_s::U::case_S2, { 0U, 0U }));
                if (uu____1.tag == result_S2)
                {
                  switch (uu____1.val.case_S2.x2)
                  {
                    case 0U:
                      {
                        switch (uu____1.val.case_S2.y2)
                        {
                          case 0U:
                            {
                              return;
                            }
                          default:
                            {

                            }
                        }
                        break;
                      }
                    default:
                      {

                      }
                  }
                }
                KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
                KRML_HOST_EXIT(255U);
                break;
              }
            default:
              {

              }
          }
          break;
        }
      default:
        {

        }
    }
  }
  KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, "panic!");
  KRML_HOST_EXIT(255U);
}



================================================
FILE: out/testxx-result/result.h
================================================
/* 
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>

  F* version: <unknown>

 */

#ifndef result_H
#define result_H

#include "eurydice_glue.h"



#define result_S1 0
#define result_S2 1

typedef uint8_t result_S_tags;

typedef struct result_S_s
{
  result_S_tags tag;
  union U {
    struct
    {
      uint32_t x1;
      uint32_t y1;
    }
    case_S1;
    struct
    {
      uint32_t x2;
      uint32_t y2;
    }
    case_S2;
  }
  val;
  KRML_UNION_CONSTRUCTOR(result_S_s)
}
result_S;

result_S result_ident(result_S x);

result_S result_mk1(uint32_t x, uint32_t y);

void result_main(void);


#define result_H_DEFINED
#endif /* result_H */


================================================
FILE: scripts/check-dependency.sh
================================================
#!/usr/bin/env bash
# Eurydice has 3 dependencies that must be handled by hand: karamel, charon, and libcrux.
# For each, we require that `./$PROJECT` contain a clone of the corresponding repository.
# For users/devs of Eurydice only, the repos can be cloned directly there and
# this script will ensure the right commit is checked out. For devs that also
# touch those linked projects, each `./$PROJECT` can be instead a symlink to a
# local clone, in which case having the wrong commit checked out will only be a
# flagged as a warning.
#
# This script must be called like:
#   ./scripts/check-dependency.sh <PROJECT>
# or
#   ./scripts/check-dependency.sh <PROJECT> --force

if [[ "$IN_CI" == "1" ]]; then
    # Don't check commit hashes etc in CI.
    exit 0
fi

PROJECT="$1"
FORCE=
if [[ "$2" == "--force" ]]; then
    FORCE=1
fi

if !which jq 2> /dev/null 1>&2; then
    echo 'Error: `jq` not found. Please install the `jq` command-line utility.'
    exit 1
fi

rebuild() {
    if which nix 2> /dev/null 1>&2; then
      local has_nix=true
    else
      local has_nix=false
    fi
    case "$1" in
        karamel)
            if ! $has_nix; then
              opam install --deps-only .
            fi
            make lib/Version.ml lib/AutoConfig.ml
        ;;
        charon)
            if $has_nix; then
                # No need to install dependencies via opam if we're within nix
                nix develop --command bash -c "make test"
            elif which rustup 2> /dev/null 1>&2; then
                opam install --deps-only .
                make test
            else
                echo 'Error: Neither `rustup` nor `nix` appears to be installed. Install one or the other in order to build `charon`.'
                exit 1
            fi
            # If we rebuilt charon, most likely the llbc files in eurydice are stale.
            (cd .. && make clean-llbc)
        ;;
        libcrux)
            # Nothing to do
        ;;
    esac
}

PINNED_COMMIT="$(jq -r ".nodes.$PROJECT.locked.rev" flake.lock)"
REPO_URL="$(jq -r '.nodes.'$PROJECT'.original | "https://github.com/\(.owner)/\(.repo)"' flake.lock)"
if [ -e "./$PROJECT" ]; then
    # If ./$PROJECT is a symlink, we assume it's a working copy so we won't enforce commit hashes.
    IS_SYMLINK=
    if [ -L "./$PROJECT" ]; then
        # echo 'Warning: `./'"$PROJECT"'` is a symlink; we assume it is a working copy and will not enforce commit hashes.'
        IS_SYMLINK=1
    fi

    cd "$PROJECT"

    ACTUAL_COMMIT="$(git rev-parse HEAD)"
    if [[ "$ACTUAL_COMMIT" != "$PINNED_COMMIT" ]]; then
        if [[ "$FORCE" == "1" ]]; then
            git fetch origin && git checkout "$PINNED_COMMIT" && rebuild
            exit 0
        elif [[ "$IS_SYMLINK" == "1" ]]; then
            echo 'Warning: `'"$PROJECT"'` commit ('"$ACTUAL_COMMIT"') is not the pinned commit ('"$PINNED_COMMIT"').'
            exit 0
        else
            echo 'Error: `'$PROJECT'` commit is not the pinned commit. Update the '$PROJECT' repository to the commit specified in `flake.lock`:'
            echo '  $ cd '$PROJECT' && git fetch origin && git checkout '"$PINNED_COMMIT"' && make'
            echo 'To do this automatically, run `make setup-'$PROJECT'`.'
            exit 1
        fi
    fi

    if [[ "$FORCE" == "1" ]]; then
        rebuild
        exit 0
    fi
else
    if [[ "$FORCE" == "1" ]]; then
        git clone "$REPO_URL"
        cd "$PROJECT" && git checkout "$PINNED_COMMIT" && rebuild $PROJECT
        exit 0
    else
        echo 'Error: `'$PROJECT'` not found. Please clone the '$PROJECT' repository into `./'$PROJECT'`,'\
            'or make a symlink to an existing clone of '$PROJECT':'
        echo '  $ git clone '$REPO_URL''
        echo '  $ cd '$PROJECT' && git checkout '"$PINNED_COMMIT"' && make'
        echo 'To do this automatically, run `make setup-'$PROJECT'`.'
        exit 1
    fi
fi


================================================
FILE: scripts/ci-check-charon-pin-is-forward.sh
================================================
#!/usr/bin/env bash
# Checks that the charon pin moves forward from the previous pin, to ensure we don't regress the Charon version.

NEW_CHARON_PIN="$(cat flake.lock | jq -r .nodes.charon.locked.rev)"
OLD_CHARON_PIN="$(git show origin/main:flake.lock | jq -r .nodes.charon.locked.rev)"
echo "This PR updates the charon pin from $OLD_CHARON_PIN to $NEW_CHARON_PIN"

git clone https://github.com/AeneasVerif/charon
cd charon

# Fetch commits in PRs
git config remote.origin.fetch "+refs/pull/*/head:refs/remotes/origin/pr/*"
git fetch --all

if ! git merge-base --is-ancestor "$OLD_CHARON_PIN" "$NEW_CHARON_PIN"; then
    echo "Error: the new charon pin does not have the old one as its ancestor. The pin must only move forward."
    exit 1
fi


================================================
FILE: scripts/ci-check-charon-pin-is-merged.sh
================================================
#!/usr/bin/env bash
# Checks that the charon pin is merged into Charon.

NEW_CHARON_PIN="$(cat flake.lock | jq -r .nodes.charon.locked.rev)"
OLD_CHARON_PIN="$(git show origin/main:flake.lock | jq -r .nodes.charon.locked.rev)"
echo "This PR updates the charon pin from $OLD_CHARON_PIN to $NEW_CHARON_PIN"

git clone https://github.com/AeneasVerif/charon
cd charon
CHARON_MAIN="$(git rev-parse HEAD)"

if ! git merge-base --is-ancestor "$NEW_CHARON_PIN" "$CHARON_MAIN"; then
    echo "Error: commit $NEW_CHARON_PIN is not merged into Charon."
    exit 1
fi


================================================
FILE: scripts/format.sh
================================================
#!/usr/bin/env bash
set -euo pipefail

usage() {
  echo "Usage: $0 {check|apply}" >&2
  exit 1
}

if [ $# -ne 1 ]; then
  usage
fi

format_file="${FORMAT_FILE:-include/eurydice_glue.h}"

case "$1" in
  check)
    status=0
    if ! dune build @fmt; then
      status=1
    fi

    tmp_file="$(mktemp)"
    trap 'rm -f "$tmp_file"' EXIT

    clang-format "$format_file" > "$tmp_file"
    if ! diff "$format_file" "$tmp_file"; then
      status=1
    fi

    if [ "$status" -ne 0 ]; then
      echo -e "\033[0;31m⚠️⚠️⚠️ SUGGESTED: make format-apply\033[0;m"
    fi
    exit "$status"
    ;;
  apply)
    dune fmt >/dev/null || true
    clang-format -i "$format_file"
    ;;
  *)
    usage
    ;;
esac


================================================
FILE: scripts/update-charon-pin.sh
================================================
#!/usr/bin/env bash
CHARON_DIR=./lib/charon
CHARON_BRANCH="$(git -C "$CHARON_DIR" rev-parse --abbrev-ref HEAD)"
CHARON_COMMIT="$(git -C "$CHARON_DIR" rev-parse HEAD)"
echo 'Taking the commit from your local charon directory. The charon branch is `'"$CHARON_BRANCH"'`'
nix flake update charon --extra-experimental-features nix-command --extra-experimental-features flakes --override-input charon "github:aeneasverif/charon/$CHARON_COMMIT"


================================================
FILE: test/array.rs
================================================
struct Foo {
    x: [u32; 2],
    y: [u32; 2],
}

fn mut_array(mut x: [u32; 2]) {
    x[0] = 1u32;
}

fn mut_foo(mut f: Foo) {
    f.x[0] = 1u32;
    let mut copy: [u32; 2] = f.y;
    copy[0] = 0u32;
    assert!(copy[0]!=1u32);
}

fn mk_foo() -> Foo {
    let x = [0u32, 0u32];
    let y = [1u32, 1u32];
    Foo { x, y }
}

fn mk_foo2() -> Foo {
    mk_foo()
}

fn mk_incr2<const K: usize>() -> [u32; K] {
    let j = 1;
    core::array::from_fn(|i| i as u32 + j)
}

fn mk_incr<const K: usize>() -> [u32; K] {
    core::array::from_fn(|i| i as u32)
}

fn nested_from_fn<const K: usize>() -> [[usize; K]; K] {
    core::array::from_fn(|j| core::array::from_fn(|i| i+j))
}

fn plus_one<const K: usize>(x: [u32; K]) -> [u16; K] {
    x.map(|x| (x + 1) as u16)
}

fn const_eq<const K:usize>(x: [u32; K], y: [u32; K]) -> bool {
   x == y
}

pub fn fun(x: &[[u8; 32]]) -> u8 {
    x[0][0..1][0]
}
 
fn init() -> [u8; 32] {
    [0u8; 32]
}

fn references() -> () {
    let x = &init();
}

fn main() {
    // XXX1
    let Foo { x, y } = mk_foo2();
    let unsigned = 0u32;
    mut_array(x);
    // XXX2
    mut_foo(Foo { x, y });
    assert_eq!(x[0], unsigned);

    let a: [u32; 10] = mk_incr();
    // XXX3
    assert_eq!(a[9], 9);

    let a: [u32; 10] = mk_incr2();
    let expected = 10;
    assert_eq!(a[9], expected);

    // XXX4
    let a = plus_one([0u32]);
    assert_eq!(a[0], 1u16);

    // XXX5
    let a = nested_from_fn::<4>();
    assert_eq!(a[3][3], 6);

    // XXX6
    let x = [2u32; 2];
    let y = [2u32; 2];
    let b = const_eq(x,y);
    assert_eq!(b, true);
}



================================================
FILE: test/array2d.rs
================================================
fn f(mut x: [[u32; 2]; 4]) -> bool {
    x[0] = [ 1, 2 ];
    let y: [[u32; 2]; 4] = [
        [1, 2],
        [3, 4],
        [1, 2],
        [3, 4],
    ];
    x == y
}

fn main() {
    let mut y = [[1,2]; 4];
    y[1] = [3, 4];
    y[3] = [3, 4];
    let actual = f(y);
    let expected = true;
    assert_eq!(actual, expected);
}


================================================
FILE: test/castunsize.rs
================================================
struct S<U: ?Sized> {
    foo: u32,
    my_data: U,
}

type T = S<[u32]>;

fn main1() {
    let x = S { foo: 0, my_data: [0 ; 4] };
    let x: &T = &x;
    assert_eq!(x.my_data[3],0);
}

fn main2<const K:usize>() {
    let x = S { foo: 0, my_data: [0 ; K] };
    let x: &T = &x;
    assert_eq!(x.my_data[3],0);
}

fn main3() {
    let x: Box<[u32]> = Box::new([0; 4]);
    assert_eq!(x[3], 0);
}

fn main4<const K:usize>() {
    let x: Box<[u32]> = Box::new([0; K]);
    assert_eq!(x[3], 0);
}

fn main() {
    main1();
    main2::<5>();
    main3();
    main4::<5>();
}


================================================
FILE: test/chunks.rs
================================================
fn main() {
    let a = [ 0, 1, 2, 3, 4, 5, 6 ];
    let mut i = 0;
    // This one not supported -- all the other ones are.
    for v in a {
        i += v;
    }
    for v in a.iter() {
        i += v;
    }
    for _ in a.chunks(2) {
        i += 1;
    }
    for _ in a.chunks_exact(2) {
        i += 1;
    }
    let expected = 28;
    assert_eq!(i, expected);
}


================================================
FILE: test/closure.rs
================================================
fn f() -> [[usize; 1]; 1] {
    let s = [0; 1];
    let a: [[usize; 1]; 1] = core::array::from_fn(|i| {
        core::array::from_fn(|j| (s[0]+i+j))
    });
    a
}

fn main() {
    let actual = f()[0][0];
    let expected = 0;
    assert_eq!(actual, expected);
}


================================================
FILE: test/closure_fn_cast.rs
================================================
fn main(){
    let f: fn(i32) -> i32 = |x| x + 42;
    f(1);
}


================================================
FILE: test/collision.rs
================================================
enum Either {
  Left(i32),
  Right(bool),
}
enum Direction {
  Left(u64),
  Middle,
  Right(u64),
}
fn collision(a : Either, b : Direction) -> i32 {
  let x = match a {
    Either::Left(_) => 1,
    Either::Right(_) => 2,
  };
  let y = match b {
    Direction::Left(_) => 3,
    Direction::Middle => 0,
    Direction::Right(_) => 4,
  };
  x + y
}
fn main() {
  assert!(collision(Either::Left(10), Direction::Right(20)) > 0);
}


================================================
FILE: test/const_generics.rs
================================================
/* TEST 1, with data types -- doesn't work yet */
struct Pair<T, U, const N: usize, const M: usize> {
    left: [ T; N ],
    right: [ U; M ]
}

fn mk_pairs<T: Copy, U: Copy, const N: usize, const M: usize> (x: T, y: U) -> Pair<T, T, N, N> {
    let a1 = [ x; N ];
    let a2 = [ y; M ];
    let p1 = Pair { left: a1, right: a2 };
    let p2 = Pair { left: a2, right: a1 };
    Pair { left: p1.left, right: p2.right }
}

fn main1() {
    let Pair { left, right } = mk_pairs::<u32,u64,2,4>(0u32, 0u64);
    let expected = 0u32;
    assert_eq!(left[0], expected);
    assert_eq!(left[1], expected);
    assert_eq!(right[0], expected);
    assert_eq!(right[1], expected);
}

/* TEST 2, too many trait bounds -- doesn't work yet */
/*
fn alloc2<const N: usize, const M: usize, T: Copy + Eq>(x: T) {
    let a1 = [x; N];
    let a2 = [x; M];
    if a1[0] != a2[0] {
        alloc2::<M, N, T>(x);
    }
}

fn main() {
    alloc2::<1,1, u32>(0);
}
*/

/* TEST 3 */
fn h<const FOO: usize>(x: u32) -> usize {
    FOO
}

fn i<const FOO: usize>(x: u32) -> u32 {
    x
}

fn f<const FOO: usize, const BAR: u32>(x: u32, y: usize) -> bool {
    let arr1 = [ x; FOO ];
    let arr2 = [ y; FOO ];
    arr1[0] == BAR && arr2[0] == FOO
}

fn g<const BAR: usize, const FOO: u32>(x: u32, y: usize) -> bool {
    f::<BAR, FOO>(x, y) && x == FOO && y == BAR
}

fn main3() {
    let x = f::<1, 2>(0, 0) && g::<3, 4>(0, 0);
    let expected = false;
    assert_eq!(x, expected);
}

/* TEST 4 (Franziskus) */
fn serialize<const OUT_LEN: usize>(re: &[u32]) -> [u8; OUT_LEN] {
  let mut out = [0u8; OUT_LEN];
  out[..4].copy_from_slice(&re[0].to_be_bytes());
  out[4..].copy_from_slice(&re[1].to_be_bytes());
  out
}

fn main() {
    let s: [u8; 8] = serialize(&[1, 2]);
    assert!(s[3] == 1);
    assert!(s[7] == 2);
}


================================================
FILE: test/core_cmp_lib.c
================================================
// this file provides the comparison implementations for various built-in types

#include "eurydice_glue.h"

// the implementation for `()` comparison -- the inputs are `&()`
// as the function interface is `&self`
bool core_cmp_impls__core__cmp__PartialEq_____for_____eq(void **x0, void **x1) {
  return true;
}


================================================
FILE: test/core_num.rs
================================================
fn main() {
    let x = std::primitive::u32::BITS;
    assert_eq!(x, 32)
}


================================================
FILE: test/core_str_lib.c
================================================
// This file provides the C implementation of the `core::str` Rust library.
// Notably, we assume `&str` to be represented by `Eurydice_str`.

#include <stddef.h>

// types

typedef struct Eurydice_str_s {
    char* data;
    size_t len;
} Eurydice_str;

// functions

size_t core_str__str__len(Eurydice_str s) {
    return s.len;
}


================================================
FILE: test/dst.rs
================================================
struct T2<U: ?Sized> {
    header: usize,
    my_data: U,
}

fn mk() -> Box<T2<[u32]>> {
    let mut x = T2 { header: 0, my_data: [0u32; 4] };
    x.my_data[1] = 2;
    let y: Box<T2<[u32]>> = Box::new(x);
    y
}

// ---

struct S<U: ?Sized> {
    foo: u32,
    my_data: U,
}

type T = S<[u32]>;

fn check_regular_field(x: Box<T>) {
    assert_eq!(x.foo, 0);
}

fn check_var_field(x: Box<T>) {
    assert_eq!(x.my_data[0], 0);
}

fn check_regular_field_ref(x: &T) {
    assert_eq!(x.foo, 0);
}

fn check_var_field_ref(x: &T) {
    assert_eq!(x.my_data[0], 0);
}

fn alloc() -> Box<T> {
    Box::new(S { foo: 0, my_data: [ 0; 4 ] })
}

// ---

type T3 = S<[[u32; 3]]>;

fn alloc3() -> Box<T3> {
    Box::new(S { foo: 0, my_data: [ [0; 3]; 4 ] })
}

fn check_var_field_ref3(x: &T3) {
    assert_eq!(x.my_data[0][0], 0);
}

fn main3() {
    let x = alloc3();
    check_var_field_ref3(&x);
}

// ---

fn main4() {
    let x: Box<[u32]> = Box::new([0; 4]);
    let y = &x;
    assert_eq!(x[3], 0);
}

// ---

fn main() {
    check_regular_field(alloc());
    check_var_field(alloc());

    let x = S { foo: 0, my_data: [ 0; 4 ] };
    let x: &T = &x;
    check_regular_field_ref(x);
    check_var_field_ref(x);

    main3();

    assert_eq!((mk()).my_data[0], 0);
    assert_eq!((mk()).my_data[1], 2);

    main4();
}


================================================
FILE: test/dyn_trait_struct_type.rs
================================================
trait Trait {
  fn method(&self);
}

// impl Trait for i32 {
//   fn method(&self) {
//     assert!(*self > 0);
//   }
// }

fn use_trait(t: &dyn Trait) {
  t.method();
}
fn main() {
  // use_trait(&100);
}

================================================
FILE: test/floating_points.rs
================================================
fn main() {
  let f : f32 = 1.0;
  let arr = [f; 100];
  let d = 1.0f64;
  let arr2 = [d; 100];
  assert_eq!(arr[0], 1.0);
  assert_eq!(arr2[0], 1.0);
  assert_eq!(arr.len(), 100);
  assert_eq!(arr2.len(), 100);
}

================================================
FILE: test/fn_cast.rs
================================================
fn id_ref<'a, T>(x: &'a T) -> &'a T {
    x
}

fn applies<'a, 'b, T, R>(f : fn(&'a T) -> &'b R, arg : &'a T) -> &'b R {
  f(arg)
}

fn main() {
  assert_eq!(*applies(id_ref, &1), 1)
}


================================================
FILE: test/fn_higher_order.rs
================================================

fn sum_lst<const N : usize>(lst : &[usize;N]) -> usize {
  let mut sum = 0;
  for i in 0 .. N { sum = sum + lst[i]; }
  sum + N
}

fn more_sum_lst(l : &[i32; 3]) -> i32 {
  let mut sum = 0;
  for i in 0..3 { sum = sum + l[i]; }
  sum
}

fn empty_ptr(f : fn() -> i32) -> i32 {
  f()
}

fn unit_empty_ptr(f : fn()) {
  f()
}

fn id<R>(r : R) -> R { r }

fn compose_cg_apply<X : Copy,Y,const N : usize,Z>(
  f : fn(&[X;N]) -> Y, 
  g : fn(Y) -> Z, 
  arg : &[X;N]) -> Z {
  g(f(arg))
}

fn use_compose_cg() {
  let x = compose_cg_apply(sum_lst, id, &[1,2,3,4,5]);
  let y = compose_cg_apply(more_sum_lst, id, &[10,11,12]);
  assert_eq!(x, 20);
  assert_eq!(y, 33);
}

fn main() {
    use_compose_cg();
}


================================================
FILE: test/for.rs
================================================
pub fn other(input: &[u8]) -> u8 {
    for i in 0..5 {
        if i == 2 {
            return 6;
        }
    }
    input[0]
}

fn main(){}


================================================
FILE: test/global_ref.rs
================================================
const C_VAL : &&&() = &&&();
static S_VAL : &&&i32 = &&&0;

fn main() {
  assert_eq!(***C_VAL, ());
  assert!(***S_VAL == 0);
}


================================================
FILE: test/i32_shl.rs
================================================
fn main() {
    let x = -1i16 << 8;
    assert_eq!(x, -256i16);

    let y = ((-1i16 & 0xff00u16 as i16) << 8) >> 8;
    assert_eq!(y, 0);
}


================================================
FILE: test/inline_attributes.rs
================================================

#[inline]
fn f () -> u32 {
   1
}

#[inline(never)]
fn g () -> u32 {
   2
}

#[inline(always)]
fn h () -> u32 {
   3
}


fn main() {
    let r = f() + g() + h();
}


================================================
FILE: test/int_switch.rs
================================================
fn f() -> u32 {
    return 0;
}

fn main() {
    match f() {
        0 => (),
        1 => panic!(),
        _ => panic!(),
    }
}


================================================
FILE: test/issue_102.rs
================================================
enum Error1 {
    Reason1 = 1,
    Reason2 = 2,
}

enum Error2 {
    Reason1 = 3,
    Reason2 = 4,
}

fn main() {
}


================================================
FILE: test/issue_104.rs
================================================
trait Fun {
    const VAL: u8;
}

struct S {}
impl Fun for S {
    const VAL: u8 = 5;
}

fn sth<F: Fun>() -> u8 {
    F::VAL
}

fn call() -> u8 {
    sth::<S>()
}

fn main() {
    assert_eq!(call(), 5);
}


================================================
FILE: test/issue_105.rs
================================================
fn inner() -> Result<(), u8> {
    Err(1)
}

fn call_it() -> Result<(), u8> {
    inner()?;
    Ok(())
}

fn main() {
    assert_eq!(call_it(), Err(1))
}


================================================
FILE: test/issue_106.rs
================================================
struct MyStruct {
    v: u8,
}

fn generate() -> MyStruct {
    MyStruct { v: 5 }
}

fn use_it(x: &MyStruct) -> u8 {
    x.v
}

fn use_ref() -> u8 {
    use_it(&generate())
}

fn main() {
}


================================================
FILE: test/issue_107.rs
================================================
struct MyStruct {}

trait Fun {
    fn f() -> u8;
}

impl Fun for MyStruct {
    fn f() -> u8 {
        5
    }
}

fn generic_fun<F: Fun>() -> u8 {
    F::f()
}

fn main() {
}


================================================
FILE: test/issue_123.rs
================================================
enum Gamma2 {
    V95_232 = 95_232,
    V261_888 = 261_888,
}

enum E1 {
    C1 = 0xffffffff,
    C2 = -0xffffffff,
    C3 = 0x0fffffff
}

#[derive(PartialEq)]
enum E2 {
    C1 = 0xff,
    C2 = -1,
}

enum E3 {
    C1 = 0xff
}

enum E4 {
    C1 = 0x7f,
    C2 = -0x7e
}

enum E {
    One = 1,
    Five = 5,
}

fn fun(e: E) -> i32 {
    e as i32
}

fn main() {
    assert_eq!(E2::C2 as isize, -1);
    assert_eq!(fun(E::One), 1);
}


================================================
FILE: test/issue_128.rs
================================================
enum E {
    A = 1,
    B = 2,
}

fn fun_a(_x: &[u8]) {}
fn fun_b(_x: &[u8]) {}

fn use_enum(e: E, x: &[u8]) {
    match e {
        E::A => fun_a(x),
        E::B => fun_b(x),
    }
}

fn main() {
    use_enum(E::A, &[]);
}


================================================
FILE: test/issue_14.rs
================================================
fn f(x: &mut [u8]) {}

fn main() {
    let mut x = [0; 1];
    f(&mut x[..]);
}


================================================
FILE: test/issue_212.rs
================================================
fn id_mut<'a, T>(x : &'a T) -> &'a T { x }

fn main() {
  let arr : [i32; 3] = [1,2,3];
  let r : &[i32; 3] = id_mut(&arr);
  assert!(r[0] > 0);
}


================================================
FILE: test/issue_311.rs
================================================
fn use_debug(_d: &dyn core::fmt::Debug) { }
fn main() { use_debug(&&1); }


================================================
FILE: test/issue_37.rs
================================================
fn b(x: &[u8]) -> [u8; 32] {
    [0u8; 32]
}

pub fn bb(x: &[u8]) -> [u8; 32] {
    core::hint::black_box(b(x))
}

fn main() {
}


================================================
FILE: test/issue_49.rs
================================================
pub fn f(a: usize, b: usize) -> usize {
    a.min(b)
}

fn main() {
    let expected = 0;
    let actual = f(0, 0);
    assert_eq!(expected, actual);
}


================================================
FILE: test/issue_96.rs
================================================
pub struct MyStruct([u8; 5]);
fn use_it(x: &MyStruct) {
    let _ = x.0[0];
}

pub struct MyStruct2([u8; 5], u32);

fn use_it2(x: &MyStruct2) {
    let _ = x.0[0];
    let _ = x.1;
}

fn main() {
    let x = MyStruct([0; 5]);
    use_it(&x);
    let x = MyStruct2([0; 5], 2);
    use_it2(&x)
}


================================================
FILE: test/issue_99.rs
================================================
type Val = [u8; 16];
struct S {
    v: Option<Val>,
}
impl S {
    fn option_ref(&self) -> Option<&Val> {
        self.v.as_ref()
    }
}

fn main() {
    let s: S = S { v: Some ([0; 16 ]) };
    assert_eq!(s.option_ref().unwrap()[0], 0)
}


================================================
FILE: test/issue_k630.rs
================================================
fn main(){
   let v = [[2u32; 1]; 5];
   assert_eq!(v[0][0], 2u32);
}



================================================
FILE: test/issue_shift.rs
================================================
fn main() {
    let x = -1i32;
    let y = x << 1;
    assert_eq!(y, -2);

    let x = -1i8;
    let y = x << 1;
    assert_eq!(y, -2);

    let x = -1i16;
    let y = x << 1;
    assert_eq!(y, -2);

    let x = -1i64;
    let y = x << 1;
    assert_eq!(y, -2);
}


================================================
FILE: test/libcrux-ml-dsa/CMakeLists.txt
================================================
# cmake -B build -G "Ninja Multi-Config"
# cmake --build build
# # For release (benchmarks)
# cmake --build build --config Release

cmake_minimum_required(VERSION 3.10..4.0)

project(libcrux-ml-kem
    VERSION 0.1.0
    LANGUAGES C CXX
)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_OSX_ARCHITECTURES "x86_64")

if(NOT MSVC)
    # TODO: Clean up
    add_compile_options(
        -Wall

        # -Wextra
        # -pedantic
        # -Wconversion
        # -Wsign-conversion
        $<$<CONFIG:DEBUG>:-g>
        $<$<CONFIG:DEBUG>:-Og>
        $<$<CONFIG:RELEASE>:-g>
        $<$<CONFIG:RELEASE>:-O3>
    )
endif(NOT MSVC)

set(CMAKE_COLOR_DIAGNOSTICS "ON")

set(EURYDICE_ROOT "../..")
set(OUT_DIR "../../out/test-libcrux-ml-dsa")

# For LSP-based editors
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
include_directories(
    ${PROJECT_SOURCE_DIR}
    ${PROJECT_SOURCE_DIR}/intrinsics
    ${OUT_DIR}
    ${OUT_DIR}/internal
    ${EURYDICE_ROOT}/include
    ${EURYDICE_ROOT}/karamel/include
)
file(GLOB SOURCES
    ${OUT_DIR}/libcrux_mldsa44_portable.c
    ${OUT_DIR}/libcrux_mldsa65_portable.c
    ${OUT_DIR}/libcrux_mldsa87_portable.c
    ${OUT_DIR}/libcrux_mldsa_core.c
    ${OUT_DIR}/libcrux_mldsa_portable.c
)
file(GLOB SOURCES_vec256
    ${OUT_DIR}/libcrux_mldsa44_avx2.c
    ${OUT_DIR}/libcrux_mldsa65_avx2.c
    ${OUT_DIR}/libcrux_mldsa87_avx2.c
    ${OUT_DIR}/libcrux_mldsa_avx2.c
    ${OUT_DIR}/libcrux_sha3_avx2.c
)

if(${CMAKE_SYSTEM_NAME} MATCHES Linux)
    add_compile_options(
        -fPIC
    )
endif(${CMAKE_SYSTEM_NAME} MATCHES Linux)

# if(${CMAKE_SYSTEM_NAME} MATCHES Linux AND CMAKE_BUILD_TYPE MATCHES "Release")
#     add_compile_options(
#         -flto
#     )
#     add_link_options(-flto)
# endif(${CMAKE_SYSTEM_NAME} MATCHES Linux AND CMAKE_BUILD_TYPE MATCHES "Release")

add_library(ml_dsa SHARED ${SOURCES})
add_library(ml_dsa_static STATIC ${SOURCES})

# This is only for local testing and we assume avx2 on x64.
if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64")
    message(STATUS "Detected an x64 architecture")
    add_compile_definitions(LIBCRUX_X64)

    add_library(ml_dsa_vec256 OBJECT ${SOURCES_vec256})
    target_sources(ml_dsa_static PRIVATE $<TARGET_OBJECTS:ml_dsa_vec256>)
    target_sources(ml_dsa PRIVATE $<TARGET_OBJECTS:ml_dsa_vec256>)

    if(NOT MSVC)
        target_compile_options(ml_dsa_vec256 PRIVATE
            -mavx
            -mavx2
        )
    endif(NOT MSVC)
endif()

# This is only for local testing and we assume neon on arm64.
if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|arm64v8" AND DEFINED ENV{LIBCRUX_NEON})
    message(STATUS "Detected an arm64 architecture")
    add_compile_definitions(LIBCRUX_AARCH64)

    add_library(ml_dsa_vec128 OBJECT ${SOURCES_vec128})
    target_sources(ml_dsa_static PRIVATE $<TARGET_OBJECTS:ml_dsa_vec128>)
    target_sources(ml_dsa PRIVATE $<TARGET_OBJECTS:ml_dsa_vec128>)
endif()

# --- Tests
if(DEFINED ENV{LIBCRUX_UNPACKED})
    add_compile_definitions(LIBCRUX_UNPACKED)
endif(DEFINED ENV{LIBCRUX_UNPACKED})

# Get gtests
include(FetchContent)
FetchContent_Declare(googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG v1.17.0
)

# For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

# Get nlohmann json
FetchContent_Declare(json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG v3.11.3
)
FetchContent_MakeAvailable(json)

add_executable(ml_dsa_test
    ${PROJECT_SOURCE_DIR}/tests/mldsa65.cc
)
target_link_libraries(ml_dsa_test PRIVATE
    ml_dsa_static
    gtest_main
    nlohmann_json::nlohmann_json
)


================================================
FILE: test/libcrux-ml-dsa/c.yaml
================================================
files:
  # INTRINSICS

  - name: libcrux_intrinsics_neon
    library: true
    inline_static: true
    api:
      - [libcrux_intrinsics, arm64]

  - name: libcrux_intrinsics_avx2
    library: true
    inline_static: true
    api:
      - [libcrux_intrinsics, avx2]

  # SHA3 (no mention of libcrux_mldsa in this section, please)

  # Keep the per-target seperation idea: each SHA3 variant in its own file
  - name: libcrux_sha3_neon
    api:
      - [libcrux_sha3, neon, "*"]
    private:
      # When patterns is the only key of private, it is optional, and one may
      # just specify a list of patterns that are understood to match patterns
      # (not monomorphizations)
      patterns:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
      monomorphizations_of:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
      monomorphizations_using:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
      monomorphizations_exact:
        - [libcrux_sha3, generic_keccak, "KeccakState_fc"]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_arm64.h"'

  - name: libcrux_sha3_avx2
    api:
      - [libcrux_sha3, avx2, "*"]
    private:
      patterns:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
      monomorphizations_exact:
        - [libcrux_sha3, generic_keccak, KeccakState_55]
        - [Eurydice, arr_05]
        - [Eurydice, arr_c0]
      monomorphizations_of:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
      monomorphizations_using:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'

  # Public API header for SHA3
  - name: libcrux_sha3
    inline_static: true
    api:
      exact:
        - [libcrux_sha3, hash]
        - [libcrux_sha3, sha224]
        - [libcrux_sha3, sha256]
        - [libcrux_sha3, sha384]
        - [libcrux_sha3, sha44]
        - [libcrux_sha3, keccakx1]
        - [libcrux_sha3, shake128]
        - [libcrux_sha3, shake256]
        - [libcrux_sha3, shake128_ema]
        - [libcrux_sha3, shake256_ema]
        - [libcrux_sha3, sha224_ema]
        - [libcrux_sha3, sha256_ema]
        - [libcrux_sha3, sha384_ema]
        - [libcrux_sha3, sha44_ema]
        - [libcrux_sha3, portable, sha224]
        - [libcrux_sha3, portable, sha256]
        - [libcrux_sha3, portable, sha384]
        - [libcrux_sha3, portable, sha44]
        - [libcrux_sha3, portable, keccakx1]
        - [libcrux_sha3, portable, shake128]
        - [libcrux_sha3, portable, shake256]

  # Common parts of SHA3 (this catches stuff that hasn't matched above). Must
  # come after the (more precise) patterns above concerning platform-specific hash_functions
  - name: libcrux_sha3_internal
    internal:
      patterns:
        - [libcrux_sha3, "*"]
      monomorphizations_of:
        - [libcrux_sha3, "*"]
      monomorphizations_using:
        - [libcrux_sha3, "*"]
    inline_static: true

  # Here, we apply the same strategy that works for bundling:
  # - start with the most specific stuff: MLDSA-XX-AVX2
  # - move on to less specific stuff: MLDSA-AVX2 (the "leftovers", or common
  #   parts for AVX2) -- it's easy to debug from there because if something ends
  #   up in MLDSA-AVX2 then it can be identified and moved to one of the
  #   individual variants
  # - then on to portable, same deal
  # - finish with a catch-all where everything is marked as private

  # MLDSA-44
  - name: libcrux_mldsa44_avx2
    target: "avx2"
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_44, avx2, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_44, avx2, "*"]

  # MLDSA-65
  - name: libcrux_mldsa65_avx2
    target: "avx2"
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_65, avx2, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_65, avx2, "*"]

  # MLDSA-87
  - name: libcrux_mldsa87_avx2
    target: "avx2"
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_87, avx2, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_87, avx2, "*"]

  # MLDSA: AVX2 stuff shared across variants
  - name: libcrux_mldsa_avx2
    target: "avx2"
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'
    api:
      patterns:
        - [libcrux_ml_dsa, samplex4, avx2, "*"]
        - [libcrux_ml_dsa, simd, avx2, "*"]
        - [libcrux_ml_dsa, hash_functions, simd256, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, avx2, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, samplex4, avx2, "*"]
        - [libcrux_ml_dsa, simd, avx2, "*"]
        - [libcrux_ml_dsa, hash_functions, simd256, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, avx2, "*"]
      monomorphizations_using:
        - [core, arch, x86, "__m256i"]
        - [libcrux_ml_dsa, samplex4, avx2, "*"]
        - [libcrux_ml_dsa, simd, avx2, "*"]
        - [libcrux_ml_dsa, hash_functions, simd256, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, avx2, "*"]
      monomorphizations_exact:
        - [core_core_arch_x86___m256i_x2]

  - name: libcrux_mldsa44_portable
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_44, portable, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_44, portable]

  - name: libcrux_mldsa65_portable
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_65, portable, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_65, portable]

  - name: libcrux_mldsa87_portable
    api:
      patterns:
        - [libcrux_ml_dsa, ml_dsa_87, portable, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, ml_dsa_87, portable]

  - name: libcrux_mldsa_portable
    api:
      patterns:
        - [libcrux_ml_dsa, samplex4, portable, "*"]
        - [libcrux_ml_dsa, hash_functions, portable, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, portable, "*"]
      monomorphizations_of:
        - [libcrux_ml_dsa, samplex4, portable, "*"]
        - [libcrux_ml_dsa, hash_functions, portable, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, portable, "*"]
      monomorphizations_using:
        - [libcrux_ml_dsa, samplex4, portable, "*"]
        - [libcrux_ml_dsa, hash_functions, portable, "*"]
        - [libcrux_ml_dsa, ml_dsa_generic, instantiations, portable, "*"]

  # MLDSA: catch-all for things that have not matched earlier
  - name: libcrux_mldsa_core
    private:
      monomorphizations_of:
        - [ "*" ]
      patterns:
        - [ "*" ]

naming:
  skip_prefix:
    - [ core, core_arch, arm_shared, neon ]
    - [ core, core_arch, x86 ]
    - [libcrux_intrinsics, arm64]
    - [libcrux_intrinsics, avx2]


================================================
FILE: test/libcrux-ml-dsa/tests/mldsa65.cc
================================================
/*
 *    Copyright 2023 Cryspen Sarl
 *
 *    Licensed under the Apache License, Version 2.0 or MIT.
 *    - http://www.apache.org/licenses/LICENSE-2.0
 *    - http://opensource.org/licenses/MIT
 */

#include <gtest/gtest.h>

#include <fstream>
#include <nlohmann/json.hpp>
#include <vector>

#include "libcrux_mldsa65_portable.h"
#include "libcrux_sha3.h"

using namespace std;

typedef vector<uint8_t> bytes;

Eurydice_borrow_slice_u8 mk_borrow_slice_u8(const uint8_t *x, size_t len) {
  Eurydice_borrow_slice_u8 s = {0};
  s.ptr = x;
  s.meta = len;
  return s;
}

TEST(MlDsa65TestPortable, ConsistencyTest) {
  // Generate key pair
  Eurydice_arr_60 keygen_rand = {0};
  memset(keygen_rand.data, 0x13, 32);

  Eurydice_arr_d1 signing_key = {0};
  Eurydice_arr_4a verification_key = {0};
  libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair_mut(
      keygen_rand, &signing_key, &verification_key);

  // Sign
  uint8_t msg[79] = {0};
  Eurydice_arr_60 sign_rand = {0};
  memset(sign_rand.data, 0x13, 32);
  uint8_t context[3] = {0};

  auto msg_slice = mk_borrow_slice_u8((uint8_t *)msg, 79);
  auto context_slice = mk_borrow_slice_u8((uint8_t *)context, 3);
  Eurydice_arr_96 signature = {0};
  auto signature_result = libcrux_ml_dsa_ml_dsa_65_portable_sign_mut(
      &signing_key, msg_slice, context_slice, sign_rand, &signature);
  EXPECT_EQ(signature_result.tag, core_result_Ok);

  // Verify
  auto result = libcrux_ml_dsa_ml_dsa_65_portable_verify(
      &verification_key, msg_slice, context_slice, &signature);

  EXPECT_EQ(result.tag, core_result_Ok);
}

#ifdef LIBCRUX_X64
#include "libcrux_mldsa65_avx2.h"

TEST(MlDsa65TestAvx2, ConsistencyTest) {
  Eurydice_arr_60 keygen_rand = {0};
  memset(keygen_rand.data, 0x13, 32);
  auto key_pair = libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair(keygen_rand);

  // Sign
  uint8_t msg[79] = {0};
  Eurydice_arr_60 sign_rand = {0};
  memset(sign_rand.data, 0x13, 32);
  uint8_t context[3] = {0};

  auto msg_slice = mk_borrow_slice_u8((uint8_t *)msg, 79);
  auto context_slice = mk_borrow_slice_u8((uint8_t *)context, 3);
  auto signature_result = libcrux_ml_dsa_ml_dsa_65_avx2_sign(
      &key_pair.signing_key, msg_slice, context_slice, sign_rand);
  EXPECT_EQ(signature_result.tag, Ok);
  auto signature = signature_result.val.case_Ok;

  // Verify
  auto result = libcrux_ml_dsa_ml_dsa_65_avx2_verify(
      &key_pair.verification_key, msg_slice, context_slice, &signature);

  EXPECT_EQ(result.tag, Ok);
}
#endif  // LIBCRUX_X64

class KAT {
 public:
  bytes key_generation_seed;
  bytes sha3_256_hash_of_verification_key;
  bytes sha3_256_hash_of_signing_key;
  bytes message;
  bytes signing_randomness;
  bytes sha3_256_hash_of_signature;
};

vector<uint8_t> from_hex(const string &hex) {
  if (hex.length() % 2 == 1) {
    throw invalid_argument("Odd-length hex string");
  }

  int len = static_cast<int>(hex.length()) / 2;
  vector<uint8_t> out(len);
  for (int i = 0; i < len; i += 1) {
    string byte = hex.substr(2 * i, 2);
    out[i] = static_cast<uint8_t>(strtol(byte.c_str(), nullptr, 16));
  }

  return out;
}

string bytes_to_hex(const vector<uint8_t> &data) {
  stringstream hex(ios_base::out);
  hex.flags(ios::hex);
  for (const auto &byte : data) {
    hex << setw(2) << setfill('0') << int(byte);
  }
  return hex.str();
}

string bytes_to_hex(const uint8_t *data, size_t len) {
  stringstream hex(ios_base::out);
  hex.flags(ios::hex);
  for (size_t i = 0; i < len; ++i) {
    hex << setw(2) << setfill('0') << int(data[i]);
  }
  return hex.str();
}

vector<KAT> read_kats(string path) {
  ifstream kat_file(path);
  nlohmann::json kats_raw;
  kat_file >> kats_raw;

  vector<KAT> kats;

  // Read test group
  for (auto &kat_raw : kats_raw.items()) {
    auto kat_raw_value = kat_raw.value();

    kats.push_back(KAT{
        from_hex(kat_raw_value["key_generation_seed"]),
        from_hex(kat_raw_value["sha3_256_hash_of_verification_key"]),
        from_hex(kat_raw_value["sha3_256_hash_of_signing_key"]),
        from_hex(kat_raw_value["message"]),
        from_hex(kat_raw_value["signing_randomness"]),
        from_hex(kat_raw_value["sha3_256_hash_of_signature"]),
    });
  }

  return kats;
}

TEST(MlDsa65TestPortable, NISTKnownAnswerTest) {
  // XXX: This should be done in a portable way.
  auto kats = read_kats("tests/nistkats-65.json");

  Eurydice_arr_60 keygen_rand = {0};
  Eurydice_arr_60 sign_rand = {0};

  for (auto kat : kats) {
    // Generate key pair
    memcpy(keygen_rand.data, kat.key_generation_seed.data(), 32);

    Eurydice_arr_d1 signing_key = {0};
    Eurydice_arr_4a verification_key = {0};
    libcrux_ml_dsa_ml_dsa_65_portable_generate_key_pair_mut(
        keygen_rand, &signing_key, &verification_key);

    auto vk_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(verification_key.data, 1952U));
    EXPECT_EQ(0, memcmp(vk_hash.data,
                        kat.sha3_256_hash_of_verification_key.data(), 32));

    auto sk_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(signing_key.data, 4032U));
    EXPECT_EQ(
        0, memcmp(sk_hash.data, kat.sha3_256_hash_of_signing_key.data(), 32));

    // Sign
    memcpy(sign_rand.data, kat.signing_randomness.data(), 32);
    Eurydice_borrow_slice_u8 context = {0};

    auto msg_slice = mk_borrow_slice_u8(kat.message.data(), kat.message.size());
    Eurydice_arr_96 signature = {0};
    auto signature_result = libcrux_ml_dsa_ml_dsa_65_portable_sign_mut(
        &signing_key, msg_slice, context, sign_rand, &signature);
    EXPECT_EQ(signature_result.tag, core_result_Ok);

    auto sig_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(signature.data, 3309U));
    EXPECT_EQ(0,
              memcmp(sig_hash.data, kat.sha3_256_hash_of_signature.data(), 32));

    // Verify
    auto result = libcrux_ml_dsa_ml_dsa_65_portable_verify(
        &verification_key, msg_slice, context, &signature);
    EXPECT_EQ(result.tag, core_result_Ok);
  }
}

#ifdef LIBCRUX_X64
TEST(MlDsa65TestAvx2, NISTKnownAnswerTest) {
  // XXX: This should be done in a portable way.
  auto kats = read_kats("tests/nistkats-65.json");

  Eurydice_arr_60 keygen_rand = {0};
  Eurydice_arr_60 sign_rand = {0};

  for (auto kat : kats) {
    // Generate key pair
    memcpy(keygen_rand.data, kat.key_generation_seed.data(), 32);

    Eurydice_arr_d10 signing_key = {0};
    Eurydice_arr_4a verification_key = {0};
    libcrux_ml_dsa_ml_dsa_65_avx2_generate_key_pair_mut(
        keygen_rand, &signing_key, &verification_key);

    auto vk_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(verification_key.data, 1952U));
    EXPECT_EQ(0, memcmp(vk_hash.data,
                        kat.sha3_256_hash_of_verification_key.data(), 32));

    auto sk_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(signing_key.data, 4032U));
    EXPECT_EQ(
        0, memcmp(sk_hash.data, kat.sha3_256_hash_of_signing_key.data(), 32));

    // Sign
    memcpy(sign_rand.data, kat.signing_randomness.data(), 32);
    Eurydice_borrow_slice_u8 context = {0};

    auto msg_slice = mk_borrow_slice_u8(kat.message.data(), kat.message.size());
    Eurydice_arr_96 signature = {0};
    auto signature_result = libcrux_ml_dsa_ml_dsa_65_avx2_sign_mut(
        &signing_key, msg_slice, context, sign_rand, &signature);
    EXPECT_EQ(signature_result.tag, Ok);

    auto sig_hash =
        libcrux_sha3_sha256(mk_borrow_slice_u8(signature.data, 3309U));
    EXPECT_EQ(0,
              memcmp(sig_hash.data, kat.sha3_256_hash_of_signature.data(), 32));

    // Verify
    auto result = libcrux_ml_dsa_ml_dsa_65_avx2_verify(
        &verification_key, msg_slice, context, &signature);
    EXPECT_EQ(result.tag, Ok);
  }
}
#endif  // #ifdef LIBCRUX_X64


================================================
FILE: test/libcrux-ml-dsa/tests/nistkats-65.json
================================================
[
    {
        "key_generation_seed": "7c9935a0b07694aa0c6d10e4db6b1add2fd81a25ccb148032dcd739936737f2d",
        "sha3_256_hash_of_verification_key": "67099a6aed1ca9dd645a73261cead798ba29e4a15ede3a469ad4cb620b0296be",
        "sha3_256_hash_of_signing_key": "bf3a87a7854f5734d73f9130d76ab6d25f9677c30e2398a1268507997d0bd1dc",
        "message": "d81c4d8d734fcbfbeade3d3f8a039faa2a2c9957e835ad55b22e75bf57bb556ac8",
        "signing_randomness": "8626ed79d451140800e03b59b956f8210e556067407d13dc90fa9e8b872bfb8f",
        "sha3_256_hash_of_signature": "190a7e1432955924b6fede77eddf4d6cd9eab49a7d254cd8bca8b7d6fd8d7ac6"
    },
    {
        "key_generation_seed": "4b622de1350119c45a9f2e2ef3dc5df50a759d138cdfbd64c81cc7cc2f513345",
        "sha3_256_hash_of_verification_key": "114dbfea406d98227a7e962050ed302be8b3be65e246416cc15465e07bcc39cf",
        "sha3_256_hash_of_signing_key": "d64d4b4d0e55508a5520ad2ad9453da553dd2c31652574fd1981790df01e9547",
        "message": "225d5ce2ceac61930a07503fb59f7c2f936a3e075481da3ca299a80f8c5df9223a073e7b90e02ebf98ca2227eba38c1ab2568209e46dba961869c6f83983b17dcd49",
        "signing_randomness": "e82fcc97ca60ccb27bf6938c975658aeb8b4d37cffbde25d97e561f36c219ade",
        "sha3_256_hash_of_signature": "e1fa1f379451b6acae60c25c5e0a56254ee8e3ed3e6040b0d1f782fb0a547d34"
    },
    {
        "key_generation_seed": "1d836e889e46259bcd1ccd2b369583c5b47cfbb919ec2b72c280247cb15a5569",
        "sha3_256_hash_of_verification_key": "dcad3c37aa5fa8c3b7d2ff78d98c7bcdbd9c7a44091f28a5e85bda9831279856",
        "sha3_256_hash_of_signing_key": "dc0800502b0fb99a53414637e7c64b5b87413a7e2abaaf4dfaf8998cee95a68b",
        "message": "2b8c4b0f29363eaee469a7e33524538aa066ae98980eaa19d1f10593203da2143b9e9e1973f7ff0e6c6aaa3c0b900e50d003412efe96deece3046d8c46bc7709228789775abdf56aed6416c90033780cb7a4984815da1b14660dcf34aa34bf82cebbcf",
        "signing_randomness": "f333d36590910e7a5a6cbe567bcdd154137eef62b92bf8dc1fdc900e7c194e5f",
        "sha3_256_hash_of_signature": "a78eb70c8cd092f86fc98d7ffb80fdfd2ecacf2f80aa17c8da452173d5d29cce"
    },
    {
        "key_generation_seed": "539577cb7f2088fbedff1b53f235d607321857db32bba645f8df3a89dd426552",
        "sha3_256_hash_of_verification_key": "2737f34481756da4e5ac813117a68d8d3cc705600df3d8e1cecab3554ec5bee8",
        "sha3_256_hash_of_signing_key": "a90a7c5420121a3ea1012d9535ddb2499bb718530d77963bca350e6a438fd64d",
        "message": "2f7af5b52a046471efcd720c9384919be05a61cde8e8b01251c5ab885e820fd36ed9ff6fdf45783ec81a86728cbb74b426adff96123c08fac2bc6c58a9c0dd71761292262c65f20df47751f0831770a6bb7b3760bb7f5efffb6e11ac35f353a6f24400b80b287834e92c9cf0d3c949d6dca31b0b94e0e3312e8bd02174b170c2ca9355fe",
        "signing_randomness": "f52a43f5358999ddbe311866dedcf629fbd5ae94919abde9fdebdaf93bb0c847",
        "sha3_256_hash_of_signature": "f644f588237fce0d20aacf7147eb4d6e36eee0da44b79ad279e1e67265e07fa0"
    },
    {
        "key_generation_seed": "2ca59c6cf33c53803749f69ef5abfa9482fcee7efd87fbf17135ecc3ff3fd7f7",
        "sha3_256_hash_of_verification_key": "02c5c3af108fefbe00d706bef947cc8550e6af31de2f38b7c30d11d0c468ff3f",
        "sha3_256_hash_of_signing_key": "1dfdd366de63ad9b4dccbbe5df4c8826c3e47abee46fe08b2ecd87dda60d65b7",
        "message": "1cdf0ae1124780a8ff00318f779a3b86b3504d059ca7ab3fe4d6eae9fd46428d1dabb704c0735a8fe8708f409741017b723d9a304e54fdc5789a7b0748c2464b7308ac9665115644c569ae253d5205751342574c03346dddc1950a6273546616b96d0c5ece0a044af0edefbe445f9ae37da5afb8d22a56d9fd1801425a0a276f48431d7af039521e549551481391fe5f4ebfb7644d9f9782d83a95137e84ea3aeb3c2f8099",
        "signing_randomness": "a685acf5e2640f2d085efd1c9cebe815e042482a79694c32e28e97fad3bef590",
        "sha3_256_hash_of_signature": "841ad87bff6ab73ddd2460bd453d60a809054cbf3a0764f1fccdb2991c0b13ee"
    },
    {
        "key_generation_seed": "e17e72290e49a44c9c534f211195257cf13b0d45405782ceda2d7f982a551721",
        "sha3_256_hash_of_verification_key": "1b3a0546b954f30564f22a7cef7e0ab4aa3b3431afa6126be936b7ce26a43348",
        "sha3_256_hash_of_signing_key": "6e12929b831884e079a3dfccd68893385339bac3412647d229a3ac2c5138ca4e",
        "message": "dbe5b6c299b44f8d60fa972a336df789ef4534ec9ba90df92ad401d1907951eb6285eda8f134277ab0a1145001c34e392187122506aa2dbb8617d7943a129eb5c07df133d7ccde94a7cb7f1795c62493ed375353d1f044257da799f7d112c174fbc35687e2f87fefbe2d83d29d7314b30a749fe41b1b81095638f112bc4563420af235280e466ffbe7050c4937c60fc18d1a6025bcbd489f0c538e088e906abe8597e2c8ebb64f01d225c847aae4b77bae6eba9269962c4b94a9732ceaa2cb4093d442ffbcdd",
        "signing_randomness": "bf7fe774845dd2519943a685217bbb9e641acf9570468e47fc0b6b908271cd3c",
        "sha3_256_hash_of_signature": "46b78160fed9cc2cce9951f2649f1a46d623bbc5f74f652fe5696e1ee0dc568c"
    },
    {
        "key_generation_seed": "3b7388e675de5c59a78af095481c7dd999c6eea898595b1e7dcda7edc3a2c25c",
        "sha3_256_hash_of_verification_key": "e2e718981a185c4717207288ce80e5976e7fc21749aeee25171d49e73d691abe",
        "sha3_256_hash_of_signing_key": "3ba60520156c6d8b72de92264d05534f3436948a7b5514efa1e9e99cba742bb2",
        "message": "0073bee97fc97c0fbc750d474aeb93189f061e1a5cf6600c04fb0464338ec7e85252f94fcbc7b2bd00e438480d9af3add92a92e3e2e8acb55077c3278fc7503988a76e9b6062996b20889aa55b343d5a003c8a8852d738f955799fa3426be5ccd3aa6b6eda04d4884941ffc0b69c5acf12b347a74d0580cc3335ba816200f87674a4c1d98097c70f2f27c74e94a661850610ecf4847ab5b58344f958c5719e06ba396225bbe21acb0fdc512b885d391e11b0c0ed5ce6b5dd8faff91f50025c69d43072f7706d80d9fd786e1104125d79a5f4b5fd838815d44fc8b1ab678078cc174dde970d448b",
        "signing_randomness": "83963a577ad1ff81ef4afe4945fea5b2fcbdeb6ac3dd714c3d9422cc5039066f",
        "sha3_256_hash_of_signature": "7b897f468c83531fd8443d3a6b516571b3e90f31aae15a55b488e36f382cf7c4"
    },
    {
        "key_generation_seed": "dc9f40cabe2e8e4f3d1538fbc1ada27b61b99081455ab0c4c41b5b3da8101000",
        "sha3_256_hash_of_verification_key": "76c003fc56cd54337937068f126cf361911dc0a4776245bf64c0f52668b7be4b",
        "sha3_256_hash_of_signing_key": "6a3cc7065430325595c623f71d497594f6df905a520d51c3205d000c79271d8c",
        "message": "a1586245d81f96bd8ee81aa30f10c0adb343d74cf72c4dff71550c12873af89fa1874d4731c996243c3749af3f6188ffe9fa45430549045134eb29ef3cec37e72904aa082b1c6161e6b52361e49af4933a8d8c0734f21cafd7467b0c02876f43211d6122e3e735fe36064df7a0c91449237c2bc7c3a78ac7bb0f9567f2576f05802c872adf183a87aa3b8217188f2f3535f877724f35b29e545de4bcf258f13bbc7edd8c6587f733c9691f74b4151cf8c060c3ae9e8d49fe7c77bf477dc9f23fd0f0b67320275529034b84f94176730923c03aa50f9584d9c2d60b8dccf85a13f243f30a51abefbbf2cda602bf3d75e849eb92422b808416c7e56b046ce38e4677ad24d23d7237a9",
        "signing_randomness": "d18cbd60c7a706d7ce6206aaea7ff817ddcb25d36fd0f800f0c3b38ce5853c76",
        "sha3_256_hash_of_signature": "423624f744e03724b7d8709c118d43e0973d93e67cfa3bee39e21704e4bc9bd7"
    },
    {
        "key_generation_seed": "1dade637ae98c393260f5bbbe288373100dd7af37eba913c528d2b7b998767cb",
        "sha3_256_hash_of_verification_key": "e72f681049c6c7f28c7bd96d98fe147dc8d388661ea2af15696bcd5973359f9b",
        "sha3_256_hash_of_signing_key": "daddc36619a69d5088f7f8f97d73b7043a62886a0f2d6e538ec0abb70a8403d4",
        "message": "9366ed7b3b623c411448b634446f1a3faabdd163a6cc1e2bcae4a98703cd8cee441405892fba051be2a586a6950a5ef73a255e5f86b0d7212e0c51c3bc79be4b88e76ed6f043fef3204faf044bfb1ed722d61eb5d0b74c66a257e8ac3a2206273c80d2ec2123a4dbb715d60118d99ed7322e38f1562f82379138da3ddb8baa7ce61ab729afc3748c0134633cf45a9973c05c75d04e82f631845427626b5799dc07ddf830ba01e8bc6236bb6d03b37d949dbb29eec7dfe60fbc17ea590956d251539792016e2a8b01e70476961bc9ada43cda682d0caa4fcc58810bba1a673ef8f6bc90baee701e8e4f7c04a346ca56c7b2862ff57756ce6cd1ee22d677bcdaa896eae96f87870e032c18b6c6a0c1a191fae2ed487ce55296cc4b6339eac9e8a742bd0a44c3525cc750",
        "signing_randomness": "f4ea973b229c69b772e8fd400091204dd9c4c453ef412830e0b9e3560f058b52",
        "sha3_256_hash_of_signature": "565aabe7a4bcaeed31502e48f44b340bb6c8fd384b931b4d118904dfe845d878"
    },
    {
        "key_generation_seed": "8866693cee12b909e32a0c64381796633666417e1246b51a2643564b464b4113",
        "sha3_256_hash_of_verification_key": "a12e36541fa21aa9fc1fd0e2e4d3e1575a7c62b6d4ff94d4e2e71096958e7677",
        "sha3_256_hash_of_signing_key": "bdc2e761829eec38d4b7701125ec21a6f555ec86ec0041355755924111a196d9",
        "message": "0998114c84f84080e7eebb47d248980fac9d28f1abb6dbab3dd59a5cfd2c7cff7f308372874dd5447c7b02e30165501c0c673128e4c543a414222bdf47e7f4e8dca757b0f4a3281c0d10c4f02ab52aaf5b9a715e012607ba310947a60a5f62d6b8cfa96386d27cfa709189202421c078934aa2d955468e550ad4d0d4acdd98b168a9568e232192e92789830317fbc959087fffe353b6c168f3efbe7164444f1d6cba5246e31658c65440a841dba78257e78502843ec1a6e9710229c8eeb85d6cddc7d543285624aa1f756a5dd4f1a5d4fa52db8c5c34880ed448fbb6d254509fbeea0fa022f276b6a66bef7abfea6049ff74291babe781f718683397077b29fa9e2b46bc6b09251e587cc5b182195dd4060cc4a319bfbe251a5b660a739dfe5d0e5b93f3cb7e440194f1c8bda922cb1a3ee3d27edfd61c1d31a7f4534e84889ec83b51f1641892766434",
        "signing_randomness": "b640be365c75e15331d37fbe6188f4136af1fde332edb2394f8c4b35718c34f1",
        "sha3_256_hash_of_signature": "71266363d9419acf1f935952cdd12ec721aa7a7e903f9cceb2994fdfe2a2820e"
    },
    {
        "key_generation_seed": "d6dad5b2746422f4487b72536d70df88af4b2f9040aa45999f8d7784ef696da0",
        "sha3_256_hash_of_verification_key": "b660c462d8c6ad75b3a084a5cc191d9b64bfa29c98e85f9afdd8fe670a1e066f",
        "sha3_256_hash_of_signing_key": "fa653dad8f22dde8b327edbaf37a5e7f6ed0df227273dd37e7664861b8a2d112",
        "message": "4cca95cb9f254c2eaa7dcffef662ee03320d5fc626a6484304bf62fc20f341fbe26e1537d7bd20e95440f7cc95ee84e1297c807a0bc9006dfcd5c22a5c1fc0865f5d70e5d63ad677fffdea52bf85d1a4f159f7ed16a745b4d971b620048b5f518eb2dc672ca35022578059e1adad7c07fe910a5d566b8321d9a12f34c250be35ce964dddea23c90ea77c9c1bbe3532feefda3637157786ec7d37775ae5cb0bb92eab45a0fb1e833e8a6f3d06b85946e31a79b64a02b31fa640ed514a85882c89f693a06354dfddb0b5e23e7792134c69c1d3908882df3a7694a05b241b87fb2dbd1a4d9f26943b69f3cdf730301663089d1ebfc23299da21300f735cedf7b109f3e0bbe273776e6aafa7054a6cd9682b967eb7903de549e9558e62dcf3ac444dd7042fea362efb555bb97fb464ad7faeaba3197c14a6740477db50ce3fb8b762f48f880381d510fcc836e5880b48f08bd6333202e838ab73f2e106cfbfb218aab802da8a00f13f78ffb70c",
        "signing_randomness": "3e747db13e9a2e367e467c1ac4b72a39854a56a11f040088fb007ec7e1f2ecf1",
        "sha3_256_hash_of_signature": "5c2d2d3c9e1f5bc1ccdcc563bee9882e9f53d42614ebab1f41c42c128c7e3e03"
    },
    {
        "key_generation_seed": "68e7818f33b97ba6166768c395bd010cef7bce9995891d164303b53c1123a991",
        "sha3_256_hash_of_verification_key": "adefc9577e16184b4042b13d38d067fdfe513e999b0e5672a64024e900e4c7fe",
        "sha3_256_hash_of_signing_key": "607a2aaa722b33a4f4cfffc877a980e80b9ec0d3470a7cab00d275d8f26395f7",
        "message": "5c4b2e1a344da1418b0f4be3fd99505fc30f2a1e5b696e943bee2451d7b268f722e04f8e00fdd9e1a470f8c977a6d45a5f621b8815e352fa14f64977d1fa08082a48af495719ea6ac1c0b3d898603b4cf7ec88e68dd7190884382896d953d612cc21abecfb01a04a1bb1bbe8986d34625756396ccd84bd1a6b5454dda98824cd4844d98f356ab485eeb19f9196abb1c3088c0c3c5846c88760b696d91a232d6f4cffc85bff33de1a3433a27a209a461fcf37f2289f98bea7ccf183db1fc42a7edf958e7913f8711dc375e43f09be7c7a2c2b1318ae2a9cf5988fbc2ce0735a2cd9fb6c8496c34406c538c01bd494193240bff947fed47b7cce99a1747973f1faa5223ac564bba0ca8973d1310b5bfa1452cace9110bc22a8d4080a8baaa8adfa3cfb6685679b648484e3a43f9b1b2531949bbb8fae1846f6d45d9272fc2caa2913b5d9f8d322e9b18a685122d74634c60730c101578bef2480711feffe02123e76d6c846559e2ea99a98923ef095630102a5573ef027e0ab6e52555a9ede0d15a73c8b2fef87ca6fd9f903f0",
        "signing_randomness": "4e180cb95a825f6dbb010d597cfb10eaa4c03e51001d9de7bb75e87e4d7f36e2",
        "sha3_256_hash_of_signature": "f33a5f0638e46d077b6c1f40da510892f87aa4c4c1ee71a382180979fd3bc078"
    },
    {
        "key_generation_seed": "35b153a7706109d4a13d7c4b26aa5b56d9e3fac53b47e91b0c10bd4e0eaafc19",
        "sha3_256_hash_of_verification_key": "844534674148299f520dfec9efcd41149b2d193315f09a92d1aa5a72c59f911a",
        "sha3_256_hash_of_signing_key": "e4ac716b58e7e3d66ff1c1081b40f25690172665f78ae26678633ce316da3f0b",
        "message": "49755a7b1a7cdc5c9bdf5149968061d3c95ee67bfbaf02750c45094303a9d9cd23a08f19b9c768adc63ffd1527186d09ca4e0356bb882e263bf015cbe3716c05b31a69dddb790ba82c341ac9b6be68a81b8bef8d882304baf0020d761a0db04412033dc369961a5213b04e81736a580f1162780599cc029e262d67f31b2773afb457a1adaaa292163144f17de384234f3303111fcd89bcb30333c6c6486f775ed099043c34e6c86450b650f1a02d03781b1d20691b767d166dadf1dcc4d8604d976efdc9168373a7316dda9b9fb02a4a321218d9f54e287b7167a08bc0153843bd6355aea1310824dd5d5ec458be694af176119d9e588a29c650ff5500293659ea478b39a62149f819cdb7e7cb32e1d7b1284f159e2ab1b1ea41af4d0ac94ff3111fc1ccd818f9b2cc7a259701405fdf6a51d2d3ef62789297bd16a659f14968ef902c4a23da409bf13a4913467b5c991854b2ca6cc006d3f4197a6aa58bd5dd95c36928da9583332c3fb134fa3890fe7e299f1c17205366c4f4230724c43e4803912e72b816658bbb1b63780865a1f66a2a49b96e93711b1be97b827d12173402828b1a065b94310d5bd6098d",
        "signing_randomness": "de9dbae947be3b65b9a827c65b99260c6a17d9cd8c2bef48ce0573f555de0f33",
        "sha3_256_hash_of_signature": "64f242ed08c3fc6f93766a1579bd2240a3665e1cc7add401581ea2a76b4fecdd"
    },
    {
        "key_generation_seed": "0e1a1634fb2396e187cd8980ef29663c42dc3ef963ccd491f817a84283a11fa0",
        "sha3_256_hash_of_verification_key": "f0090876cced062d8e1285ac11eb97dbb58e2396cea8d8e7d57c1eedb1280807",
        "sha3_256_hash_of_signing_key": "95564aefad8c50fd343a16cd355aa97bcf75d0bf523d971f2c9f21fb27c6ba2d",
        "message": "439529df1864297e33956afee00a60099b658a67830a6a6abddc329e87831d9f9b647917fedf1ae182a40402143285516fcab83f447354c72fae81ac26e7005c2aa561763c152e66bd80f14565f47defa440dbb491e7994ab9fe35995d5fbb3800ca030b43df611141637a5246ab9d9cac02efe14af60736b6bdb2babb97cf21e831e5d04d41c00f090b154977900efadd3a9313389a3f84cb3ac38e8b57b70a43dd08a8243f8154013fd5cf29de5a8df0b197c12b17e0610fcfe3625cc94067e01e23d23a243ad1c1f805cc50e1447d1df93c25b8d76396bb7199e64129522462c5fc8b30c132d4ee9e0bf6f52961fce7ecf650647e7064aa5a6574649a323e144d7c5491de4c0a1a76d08f93f87a2fc7f6955fef86991e62e2cb42908e83b0c0a8bc180b7453ced293f1e20f300431ec1d395e8a537f0bc36a673d491f14381dea90d8f176d06031b0a7afb40ea8f76d37fa82e2572b9799a5fc7cf4c49bc20ad78efa8cd989a84d72ed680ac3c0f64155c56acbfd7c7d628b418a489f961357f77bd62204adb079dd3106485a37fee535c9cf82e832d8aadcbf686976b806b02ae733db46db0bf162e973931c3e338cc86db38c66262d1b2ebc7691b8281e0b20bf36305fba996d20ecfdc695",
        "signing_randomness": "95a169a6821bc4b7a221c54caf7c9411ae44cbe89ade05cf95fa6d20ccf2d086",
        "sha3_256_hash_of_signature": "7846cb8fdb10654f9c835cad3978dd31468eb66498cd5a80faa889adea336271"
    },
    {
        "key_generation_seed": "b0bfa060f1c1a70f1ac55e321e6186a6613605dd732574b5fe6e14f0ff6f7a82",
        "sha3_256_hash_of_verification_key": "c4fd0ec2e4535ffa4e381d3bb5e92470e8213997abf39e42e40946127a296ccc",
        "sha3_256_hash_of_signing_key": "a8f1ea0eb2a9a33b5febce9cbceddfbf51b872e9ae05a5a5c8c2bc608bfb75f5",
        "message": "8cb18850e27d8416b88a9a71f4a66bdf447814db6c82098c371b53f61600ef5dfd88e4fb34200207c3f6f55166af4878d38fca7e2dc18fe662e3ea491b58a86246cae16090fb7ada53b9a67b3d0e3787d3323ea921274c60cffb19a889bcf0300fe10e242aae025f374dd83fbe9d007c8b9d9d75574c74146331ddec6f0e49c10dbaf15654897e33e2b4780dba484224aa6fac79015d5792faa2d532bb7d239b11d91420b98690b1fbde9632223927e0804bfb284368a426c414c3db8ea82f0d246413861475ed2dca9e80fb4f3c34fef7528069ae1975afc52ac5ad2cdbca1459e140f655556093210d7905a1a1e6ceeaef0194a0b2eab2c1ee853484e715d2a1db551fdc620d5331164c74ca4848b61d408d2f2a943fa09efeb63d524691c99dcc0b22cc61b98e6fb8039e5e0b2d7de2caaa900a44184bd56c9f02141a3ae8afc661e3e898ecd3004fdb0704272ba780cd5de35153b6fe223843024273642dcf8e4b58be2ab1f61668680084aa0b75a32e766c8ae5eb30d4e02a12e6798dea40f80d8ddfad2041a52922701c689f46f49f84cfc05eca6d7d4c356d50b6a0ba61966245d45134d6a1f5197540a1c39c36bb0b78831af3f5156e669fd9213b64e0cf1c5a31e88ae79ad61757ec67b551b9f0a760f646bf81f6b92403a62840cc29fa4f3949b3a9f0a9a4286ee7808a",
        "signing_randomness": "9cddf8ceb8c94c72c136072d09d7adc8ed40affe4eb1a5fb3fd7877571975ef1",
        "sha3_256_hash_of_signature": "eef0d06468651e6fbbd8e6520aef8241fa2f2b33d6ab8ce183530355a8ec1ede"
    },
    {
        "key_generation_seed": "a33bc0a7a08c13c0d4c1174ddd886aac4c5666e1f4831f006c9519d36b2ce882",
        "sha3_256_hash_of_verification_key": "cb702d5ed44ff15708ebe80918e6eb2caf426cb751bd9a0ddad41d293c3913bf",
        "sha3_256_hash_of_signing_key": "d08111b7e32f36632af98f411be7927eeb44f935298713230d2a99da1af15577",
        "message": "9b64813c058f07a09a796fd764604eaf58ce144363702896df0ab5ff26d5de000d14bb8fd358ff5532d3b909ab62c18ac30f1900f84ebd3f4f18bd532d16c7b3470f0f8bdf72938c916db18bcf1429dc1635b1c152c5f89a9edb17116c11815a6c06273a889132923da908ff39f4940a840d3cb575dc4d637aafd37968ec61fc4ea04b4c320491a73ecfbdd8e10f1dfe902fccef93dd287ed872f67146bb8ca5a6adcf0350e8bba7f2f9762c4aa748fce19748eb17334146c152fd63fae3dfbb1a2c2b3c78960369551fdac5d54643beeaa59c1feb0c21dbbb19977d848cd82a7ae0005f45956e0fe4700f14fbaa0c12fb8c65a6aec95c5a5c8e79a6da9c4e446872575c06ae49a31b82245e1757c7ce84d6d5df3f642d3434b7e1a15a8b8a9db460826b6cdca69022dbf87595b582ddbb90a81e09a13c2ab1c125e4435ff30abc9c56a00edfa979f79d9c895e800d2dd6372fae5faacd83adf8a6d55279d52df547e9bab39d99076ad7d297371344d35bd584e0fb5932f92fd5183b9250cd180fc645bef6028c405b0ef35daf783428173f1f2482aa1363640f66af0fe8ecacc0dab84abd2a1fb53af44445698cf1ddf4c2ea214dd339be004e75bf76e95ca5c16981aba5540689c1c1f1daf4d0f89d62ccb3496340d61e7d5f5156fd3edd02edfec8fcdd0b231697b0e66f4a3aaf46117532f5ee2cb4d2b3b82b0beae0a45a482ce9a976cc99aa82beb0fe08cb68c4",
        "signing_randomness": "86978657e78a20a881689d75650d01083209a9c6a41092aad3eee15e4846260e",
        "sha3_256_hash_of_signature": "05c02567565505c1c0c18b8189d3794f7093a06ef0cdedf2b461db7a4d26d4fa"
    },
    {
        "key_generation_seed": "c7e33fa5329142b668ccdde1057eb7a8619397537f2b4c6d6755b3b9ff936441",
        "sha3_256_hash_of_verification_key": "c7127ed8d40411230ffa8aaec15331d5d01f3e36b366f4fc1663c3a82e93b7ea",
        "sha3_256_hash_of_signing_key": "6afdd99930d8a3d9ff5ed280c9ff3b64cbc0f82c69db6b20b3b854b6b9ad2fa7",
        "message": "922320f7439e492f13c272a5738ff7122dd7a6b2832632e1f7a653fef3b8639bcb9e84f482f22a948ea17dde6958489593d2cb268bb52df8ed612f2317bd6847d1622cf0532cb499adc432233b93b6f7b1866b38975ac87859ac49f91e8d235846775f9e6e6d052339c741ef6178016edb3d0b1e3f3536667b3ea2d489f88d254b8582421a31461374f465d7ad62e896be0857134707a70477fabc09fe0a5cc3b3f32911f5ff3806b878205525af69007f50535df05c33af3b0d00e297ac7eaa012e1d863dd5dd5fa47fb09467dbad8bc42edbab42a9625bfdb9fe578343297506a3b71cdc8d5919955af4605fcb0c7164d96a187aff65d0f6210fef2d11ba08d90c4458542be72e084577be9e451b8b6f4909884bcc5d25316adccd0925664d4d91c2e56433c1b68c632b0ca56d856df1edd5e113d1f026b30dac4fd648a504f8f6809c701c97bcac2b99286cef5c1c923200b1bf6141ee1cfc51c5e14554bc02d7e058970254d2c02948360abc4dfb439e66946a8ad615147bd8a6cb0886211e8b15dff3c72b6f8908ce56bbc1b40e838103202e9f188d98e07555db61778f895f76fbd838b6d14209d28eb393668924ac0e61072cbd9f93b864904ff4302dcea131b2ca16bb04959acee096b1963ce07f59ab505fcc8d89fe08fc58751965f2f5ca753d76d58705652d3b1505e0f720ede3142de9776ffe4aa0c8a25e76c7a04843377c59f1002844e89189e22f621467b813a98bf07540a1649264f14a6844d65692617f7a4d93fa9a23829e256626",
        "signing_randomness": "d969c4147e8353c80d83ce2b665934ea1f9ff040946cd3f16533143b129b5804",
        "sha3_256_hash_of_signature": "315ff4cecce4baf97b8bb5a27dbb594809763b528e5e7375e6a72791a173e581"
    },
    {
        "key_generation_seed": "7611b5b7d4195d5f8b97244b6811748efea929ea272e66435a36d0bd16e3bf21",
        "sha3_256_hash_of_verification_key": "6cf377e18ffba98f78dcf853696ae6b124919f5ca693d472cd9e64744c404ea5",
        "sha3_256_hash_of_signing_key": "84edb0a99c81e5de9c113a9ffa846fb1f0e369467a5418f317195a2aaed4c93d",
        "message": "576289d10ab03d5699eac322d349f55c547101e4424bfa43bbba3747b79f075ae1153a7a0ac8bb51d24fc46b7604e42efe4343fa34aa4eb16d918f25e8a4d67c860cca3f7480e1221ed3ae13a138f079fc252c6d7bebc55cb81b86e74f339614bebcf7e8f4440df8678b01a4a41b3afb1d112fe1c4c8d8c6bfe9d3ee2a335d477c60fbf43b2e5fffe1546f5172ef51cffb2a772e1575eac79b24d49fd77f0be351233e57ee6dcc7e2e29994873abd434d34ace83400c026e27e27888ea0bdd1bde5a3e55aa8b5f2feb57b8b0a96cd831906297c8169d04f15843a3249c50523cf56a4e19492ea16927dba8759b88a99e0d20820e51fc9b6a6863115cf05c5bc3f4c869eb5a87124df5db102d737f3899cfaa5fea4dd62dc4fedb1aaff67906adaf8968020efa5b10190f70e5f2c0f0457e4341bd449201d3a80aeb791254ec1c46ddcebc3896c6df702509ba62cd446d275806438eb4c03132b2e6bd01bd2f832d1d3c053c48c5a9db1c4a22b130c4c9e96a2bf4c2a8f7de0217a52d9aa5aeee5e6a49708237eab60b4019a51390c3ef10572a73d436875bb8d7d78543f96376e4bf3bcaabb92f89215e8d1093f3b287945708b5514bd7e62654d3bdf34b29009c64829a0cbf33c54d7ab0e81b81bdda93028b341ab1dff3d752dc4a1e5f9636a5c46e137ea35919d99e6571c5370c6e804bd2e2abf566f035d65cf8f97e3e8f2ecafa153bc6d8ec2831667a37fc96d1c2da40ba84d0fb041def32aadaef3f98cafa957f6552f79d28a36b8ba20a9452671de1be8af5d66714232507edb9ff657f3d7e5fa7320fc0359a5f99280d446283bc",
        "signing_randomness": "a54ac9b7a0a8c85861a188726990e518d287f7c53c8b96ddf7d01c4fc4a6b9c9",
        "sha3_256_hash_of_signature": "e8ce9a6694c6e3c307e8d00651f8bd0ecbbde604f2f8a5552115439bdc6abffe"
    },
    {
        "key_generation_seed": "5a1e3e05c72cef1a73ef98840da035e4fd2552912db8dae28a79011de4bbc1a4",
        "sha3_256_hash_of_verification_key": "5f5e5934711b33adc020eaec3f1c886a6f4ecac70bd75a1cad4fe4b82596f199",
        "sha3_256_hash_of_signing_key": "173ff16fdf05fe924955c39142b06c2ea0750ba9889afc94548769106bd9d3d6",
        "message": "021e9c06a2e4ef63d1a61958620c40016783879080d44311e04f2a446bcaee5a486d17ff0f356ba70ff1c2b55bf957a59202903ae349878cb822e04275e0afaabc0803bb6cde3741e0bf9fce0c5d5c814977474533dc63f9ed4f32ac3477a3ec9893ef55186728c85b03f4c2e61ca7733e1706766aeb8fea80e233e8761b57fd5a3cef700196674b34a3a55f68b3368b688fb1ddc976ff48ba6a98e2d66023f291a3c617a56ccbdb8732b8c34369ed11f4ccea8fc8f673ad9fa0fd8990bef70af44c617fdfa096695d0c94ea8e17554f4461dc776db2f416448b17680fe4d29b09e57603d8ebf55771af84d8d4b9097302901c25cb6d73932e67c323d12c8acb0e74cb89755f7eb3999d4eab5e1b775e6b5c29d9733697030a26f3b93b3f286db0f2dbda71e1f103878063e77919d8892eb6a34f821b603ed4a898a9f30d00feef20985fef1a7b7af70dd29c269e88687f005d551ef05eb0603fd38745aed4f5bf4c2fc09f0604c98ae3a89e46bbfe907b87a1672de547d651f035f392a8d4db5e7260f43953028e312b95b9f25fff2c0c579218390411d13d9a25f22de4c7aa05fd11781db08977160d48e02372c7d826f5cac37d1a9b4230be99a2d13cc2e9b2b17f0a1044eb9e0a2fba376d35cdd2bc05f57dce4bbc3bf07a09bcde369929e6250efdc61689466b040aea376b09453a2c16813bbb685b54a225c49008ba6811e8bb5b3627f8c281244fdf5533216d126ed0e64fdabec533424bff77fe722cc438ca7587c19d965f0bf085d8692c27c5c84a9dee53256d978948d89abdf9842e0b765be6a507d8630cbc5ca7fa0fbca1cecc78d2e536aa7b2b902c4379777ac0920d69c57cc4e6032252bde99e1a555e80d4",
        "signing_randomness": "4ba7fa7a5623bb71d33a6bfdd38828ce60d91e75de165367e31007a10e0b8352",
        "sha3_256_hash_of_signature": "5c16e1b7faa25b12b8947bb45c56bab08e4196f4c4d2baceb9f597c2c2a198b2"
    },
    {
        "key_generation_seed": "8f3920a235eec3659cfcfe62931474204eae264959702f901d461b66d9bb563d",
        "sha3_256_hash_of_verification_key": "ea206ccbe881abb34306ffe034a26345cf15a78d2a7fea92879f1ac73455a9a7",
        "sha3_256_hash_of_signing_key": "902c25f9cca4a9aecbd77c77689b63e315e860b4ccc82fa0f8c6885ec89d74a9",
        "message": "7bedafebabbbfb863ce496475f54e69a905afa45899c3d7c16cfc73e31597d2404ae7014612e4cbfa238efaf5b396b0b7435ada5de817e013188c280423c68924e1fa2a33ca56e6b85b7cca7f00d3a6151f0629c1b92a13573320e0025863bba7f3eeb987ee1b1a6230b10765dfc1feea498ae4b83521188e7503b506259103cefb370e3651b06dd4f08013ff3ab9e2430626b0bd584232948462d85c0f82da07b96fc65f62a43cd2f132d1a1d691c085980dad8796cce2fa0b268395eac3da2cc400f30f75be87316216980ce213b48651ddb9e294f8cdb2ca05d3f2a507e4a03e2849aa8062918afb5bce9e4c3abf2ffd4751dddcf08ab09e36a29b830f3bac6feebea084575472e6f4b239af89965a72954769a83e391de467934237b07d8884a6b14cad034fbf9bd7531d50d742e234e227e1a2daf77a2ffacc579525134b15186d81ae6e5538871024bd2897475d6ee5b11bc51edbb928d98475073785a75b331bf3d2297165ae6cf95c3a05f06df747498462054f58a5ac736f96014b1a8cdb319d030d06dad9cab2b913f35fc392e1fc4b027cdbe775d64b04f1076a7c8f44c360745f98e87b84c18ab76f84f373f635af4c8a87df08dd4507899bad892ff8cc1ee534d3277b5b82095628b84a7d5582149cf46c50aa963b56b4b91966b106b4b2eaa45d83a10993e8f933370ab29c6606b7ccfc41b21c6b99f2b9ac643e24300b350fa199ec10e64e4af19181f78e8c43b2fa796241dc42cc8992bdfcdc39e7bc41be68cdce4fbc47c996db42e8249eedc146c216b514430c705fc939b9eef677ad87f9cee3398551fa0daf774302324a410f4a4f4fc035cfbe960b38c390441e92d9e5624a8745976bc88fa538e398712361b77ad4ca5ff038d9f6ce157eb8a6137420d4e57018275dceebc4e480a5d",
        "signing_randomness": "943c364002f410be37f11bcfb79ec1700133d441c7c1e37359bc9559d256d56e",
        "sha3_256_hash_of_signature": "b76f5533b2240276e7e2ba38b2f8bb63af80536e20981f15a5069623d359ebd5"
    },
    {
        "key_generation_seed": "0b2b3eb50681403a0b9a99b25041a489c6d45d2a49de0ec83e1fd10922abe2d5",
        "sha3_256_hash_of_verification_key": "644fb01a30bec6c77beda961eb71e11e9c45ee083f560f8d7ea2d670694b3e86",
        "sha3_256_hash_of_signing_key": "80936c4c6314a19a23e6ccd203b154014c5844d6e557d7dd8e11293e3549bf06",
        "message": "a86ee95388df139f9c5a84108d1e63f7a7842909b818e9a0425c257649abf125386fb5286031e7e6d0eeb85c452e254da39bbda51f0d2167ec0a51992753ddfa76874aa80804e705cf8bbadf3b82b6d7fba3d1cad130abcc0b44d6d893356f3e94bf8e82ac532ef8c5e5f4200207bcf6b754f14e57a889ffb753f516ef8de2a647fad8e449264f0bbb4cf48bd01501736da49509c3426a3d4108b98e6a4aa6c4430e8ee76540051fbd1dfbfc01750e26547f8718ef7d897a0342bb000fb99aa63b781c9a4b831da798c014e58725e03d2f8b1a029c3337f4099239244aa320965b2cb5075052d901b6077a18c1ecfa5f272850a475b5f6bbc83f3c09a27072f80743b23ec6a9870913ee2805b4d296b2f81a9d733e5c8d5c0b477e51f9328af3af8abed960408afecd27fbdd08fef50f4b07959646e0a02104a69674294a79de0b25b65f4dbfa797e5fa56d66e8bc07d5e2e7c7d2e845699acea3bfac60b2c0b988cbab949a5b598d8e2f1aec66196e115ad7f237a1c7fcfb95a1bbd6939a250e7bb0f4a02c23cb1bd81090cb770e3a70cb081d121bd0bd5ed1dc06d61282b98bf2dd7b13d2c6cf833891c67951d7d0f429ebde3f1da943adb8ad285e6f13f798d6cd9a0a06bcd6125ebaa48f8f3bd5100a122f617817e3c42ebc3c3b154258fa26b9fd886ebfad42dedc6a2c4f9986bad88a2a79d7ee603554e9cfc5fe33a3a171cf7ba94fd43228019b2f6ff96a8abbc58d2098ad95a95442f6858eb69e131d7bcadad81b9bb69d7682a978279b631e22927decffbefbe8fb2e51d46a3fca66225d30451cef9953ef94f30b99f2b26ea75b84935ea4fb257dbe5734454b8087b3a4e115c6d31e72709303e9f0bb8c86fc6b11b93b53f9781bb92851a5cb5dc00d0b4e15683dbe4edbe986966fe1f711f24de9a0e1beaea8e835c70cddc589773d31191b74af780eb69867829abed6d3ffa94d577",
        "signing_randomness": "8b7b9628988a0842ed6f7fbb4289a23a746df20188f74fd55ced9eae99889c61",
        "sha3_256_hash_of_signature": "5775e9189d7026715f332d7119a12f58b9321877e1ba199e49bf99ee23886375"
    },
    {
        "key_generation_seed": "8217d32cd15658d39cdca92c41b59f5780869a68838a3579dea48b5e3ea768aa",
        "sha3_256_hash_of_verification_key": "68f0014415da245f2f357c46bc9cc2e01b3abfb8c1c02df1d3859735cb6fbfc9",
        "sha3_256_hash_of_signing_key": "9be823f802b6a1fcb30e062c11fa5c7fd193c60cf3a6b791dfafc47c615a2dd9",
        "message": "f5abe373ce1f6fb14f2014f5bc0071b17ab2c84e8845fcbf4b15c79fbf2e5e06cffe6cad9a283014a975f81c9216b261cbc79edcd58d0e20c586d7c641e0ee97221befe54dbcc56a594df103ec24b52ddbb6052d1644972640f39deb98997fee7a252a65070798b7e46707fa440375b1ba705b3ecc7eac56d9c45297e585299c7d747b430f0d01e82081c70b4a87846f90267d5163181ded63e089a00afd33b0e2b3ace91182d8cc899223ce65a5d84b86bb3e8b34b13949bc800f2145468ba5411eacd6a6c331c340d4442d28efa0da959a2797c7181bd4bbe6e6dffd134cef373ecb0ec08590f06be0ce292d3718e2c0efc7cb40f1db26f5f38fdc82a72f81afbbc16591ee02dc818d63cae69ff0a28f942f7e07f6b0a741f3f0ebe3d0ea5859024aa408462d3d268c23f95d717c0a685a4ca73ad90ee923db57cd6cdd828b7ab0d4afa6a9ad7e32d407a44d7515c0a6af52a66ad72119ba1daec6514de3f8b462ec473072226aad61135b0f5ec646ba9a127c9894e51fdd1b2d38011a2a6d7497a55283133695d0af9b3ff7c5a8fd667231f9e511e3b8c4c3adc44d02de08c47b2382de67b32826754c6be5231ce0fc657341e20247cc6ce574f3d1a9376ac8237b49e5030e877a4e33cde25d838ead659eb1678706c759707fc66ce84cc968a8334c18f1632348824a6985a0331a93b59497b70c1a03a6848f18f5992972bc79f07f4222d2612797f495463836ae6cd3858d5b9bdf744a1cf361b5d454d41ac899a4fa61081b937cbabbf0ffec1b31c162224ea36ca2cd7fce54ec1a504932acc5bd0b17a156da7488f7017e4916a687fde7fcebb2901813b07964084ab0447a94dac3a0d3fda05b9f497cc1555a8c74838e29cb8ce89d304debe419d26ba7f3dc6e9526bd895495a5ff1d7ec83f70d045e306e7c2487a52cd7553f062d31888ef7fd27f667fcffa984afe0b9a4c4e85ca943812cdc157c5486b0b5ea6da05e4bb8697113190321a976d1806da129101e60a28b7",
        "signing_randomness": "022e7bdfb6918b065c56e2abafdeabe6de1c76919b7f004ec141cf7a2813ffea",
        "sha3_256_hash_of_signature": "c011f439517c40497f21b181482df14461c0335d58013de69c18f912cdd887c3"
    },
    {
        "key_generation_seed": "cc625322c9d52898e7f60ae47bc2847e20f3722794de41e30fdb20ca1a093208",
        "sha3_256_hash_of_verification_key": "66cffce17898249532dcd7cd4a63f2e56604f124316fe7ec24cc1e3e8a47bd0d",
        "sha3_256_hash_of_signing_key": "4319d254ac9da147c453563a4e6ee630fd58be563af183e4df1e5d9e00b9c0cc",
        "message": "4c4697a7d8195bc7d4b8f2fcf3a7e9419e8fc9ac6bafc5d658260511c697286bfe44e2ce98c21c98be42e5af0fceef8aa54c5770af287a81c7481fe3391a6111ae6243d545b2a651599b45931d7640579f8659a8bd6f77260f235f71476ed64714fddb70c549cbe089322130f7b0a21f530508970d55cba55baeacbedf684c7979078102ecffc2c3f182f710280cabc2decd3d3b5d3ce908cb2307b00fcc0c5412a12aecd041b5f70cc0149390312b9c81592bb0e2ece83d4495944e29aa798de67fd69e2bd0695dc573f78d8bb48e6b8679e1c50d1e6e58e218b77ee51597eb43ecf7301d86f457353d60e98cedc95b4a76844e889bf7e9d03503757569e40d55ab43d63293eddbb579fe981ffd4dab056f85006ffb5e759b9c16f5f6b235d7dd78458a73ef37118edf599aa504e9db9ab5dbc90b8e478f3dc1f35a7c4604a383bbbb410cfb2c5f746f83ef94bdb2f244d421818c26827d5b7d665b8a802181eb7a9ce95b6633e24d914feca7e969f64038acc3009b15168426edb67af2ccf4e859f5c616891d355f7910acfa599c396bbb2d2782cbf1432e6259faa77730b6b86fe0d67730152cd2ae0f9b0314048ccd25772c01fc9773ebf06618a8ce1e940f48663427775990cdc41c4dd3e9ac6eda1ea50e04f1d329e64c8532a7ae32238c131753d60a25810a5ffbeaa9007a6984ef69eed92b777e079ce0ff48c2aee9c18d1db9f49b5419ec6c0e2212ddd2e2fdeaf0fe9f2b84d9c50dde86a70fc28bbf8918a973cc67a36e97ce3027d73891e7aeb24baf4b12a9dc8aab5d6afa380bfac3703d2d32f1e40fbb532fd6d7d710dc0741dfc7eabfe55ba5c311a00e3be55c2ee74155e3a06685071a962d7532ac76d59fc187eff01f8d339f74323732168fa5d14f4b2a72c9164a04a6ef14bf5deb1833e4baa19a55ae590f542d4448e0eaff0e0afd2fb30fd671631b9325f4a0bac9a43dcd2840185a2f601117a625b0dad5503578537be2a535d2f556f371536bcf68c0e01c96301f08e1567dbf9d8504096a8fd89c086db695da191099fd1e8ea94035276d1d",
        "signing_randomness": "230612372c450898499f3e23372b3454a7785f330a70700ee4546fcd99619d78",
        "sha3_256_hash_of_signature": "16ca46734cd9f302cb3ad771674ca0af0891589513037ca2111f85a8e3be542f"
    },
    {
        "key_generation_seed": "950226d6ab0b774c5f439afcfd0113b5dbf5905960c445f5e6e03e5d5c687a9a",
        "sha3_256_hash_of_verification_key": "24b5cd03fef11197e71b4d8786558d206095ef7d070c2b6897e5d8759e735b5d",
        "sha3_256_hash_of_signing_key": "1dd9bb1b40e9f34ac69d1c2e7f54fa2ca5d08c655e91129a9842fa4e6a5b9282",
        "message": "72713ea55f1e5ccd5787f172657c6f6c74081de2d70816e8531497965df02dac04d91c4d09dcf8904cb152e2138f829386f4351015da253a5b5eb92d96e537dae3ce809443ea90332d9c754eb11f4de586a83b5dee7b1b9bd547ee7107530249b14279baa04683d74b69d7bfc8bbcd447fe7706593c01188fe6ad8d0e2572d49f83e93986b380d4169bdd94e3311941dd2b041dfabc5aea1297c65bb5c8352c99ff838d46b93b3e5f79e3cc5be5408fe5e59a10d488dd65a997b086fdd96cefb0247b2baf7b490317e34330a879d04e374c92ada33ee243d84da015fddec243b00bd7488aefe373e8ab1890273a7a2285988e9daf9c4e7c5a17f54ad6195ede2c79657e1bcced0641e20f7ee26eaf53dd8c82827f2d2783d44fb030c95791f41653e628062267a5cf534df00116c1ed1de9f360b97555c65cdd80724104fb1bd4da5785b5d9c24438557e48aee58d57a03e06d553b05b67e1c8d10085c2f153647f174f7922fb8d2210454f7014bddbc627756eb7cdef99b6e3a2779f82088e3f2da14c2dcb5b185aeb5d6acbfad43e286aae8f84a58e8df6abc64e4a8efd69fea18dbfa6808f25fd418de8ba923500b74e34dda3ca6ad8dc208102dc4a876d8b8cd2926aea4b3ae11a546f6235abea152dbdf43e0bcdfcdc83299207f294a707c8b4d1f56aa64a205c718aca69b862afe7489f11b324e7af6be68380d2ca6e0af0e2e20f890f2cf98907a9d43135c03e85e86c9ee417140efee9054b46c110a84f1841ae3cfafe5b4a95d6b2b606d8d0a70baea85c9412bc2d54146e9f866800e8e8615a0d64d1d595677e8c88699e3ca6097d47e9fe64050fb55033fad4d5f226da8eb5ddf99369acc7552927ed3ac7368b9efea2443926df26d1c172858fd8a5d4e1d7d39e7f7df047385d39131184087cdc45b299bd1f7048e918223da3f960608e853ee49ea667465dbbd889cbda20ffbb540c9ebba5c2cd16a22a57b561e01331d6ea6bdadbd6a5d2bd1441ef4e1d9dd11cc62a0fa5bbffcbed0d27b6acaf0889eaa5863dd9bb35920707b71a0805630d1769fea320516e71cb2b125ac274f16f7a6876f4b922c7c006f38ae1f7183ca768715d2af",
        "signing_randomness": "3e4e79432e2a2762b04cb428062cfb41a4c410ae490701f19ebc0455924aeaf3",
        "sha3_256_hash_of_signature": "14f4ab5739415d2bed4f58c585fc5b5297d4dbf3a590f8cdc9a9e636927f92d8"
    },
    {
        "key_generation_seed": "a6b534767a6d839fd19075ae0ba10147c46862bf7bbcbe83f2b72f72f1368a1f",
        "sha3_256_hash_of_verification_key": "d9657baac22d76424b30a25ef772a142ace73413feb23cc39feddb6d23e8b25d",
        "sha3_256_hash_of_signing_key": "d1093f8c5f1359c21d4a02af42793e01e3ada05251a07fdd6092cec3f72a28e4",
        "message": "209658cd1d801079ffe8e950bafd70a028cfcc35b9fb00d232c5603a1d51ba13e5de59e0277962c4474e9f3f60fcd99c9b79665b3839d5c037b921a4de8e144fa1d38182fbdeecda6934e814d9186591f01c5e23349b34f4439b4d402c4072cb4d702966ab473d2c39443f41fbdd0c48e566d33e076422ee72fb47b2ffd661f367e9efddc988bca02382ef93590d4fe3ece8b1d9d8b3a653219c7d131b43e2fde2851541f467c31129e6f9b9d124221cd52610b9f138eac1d01f193148fa0415b29f5c86d15067eb1e26c9d51f05655e8545f734f8f244854ad76c6b04c230898bea33efdceef100d79f8e3b894ba583466749b82007067806e3a7b3ba954f6fc5abff0e099a24d14d865f6f4538736124acc5ead4169ddf2144ad558da3c74cdabec147d2afa113edfd1e2280766b18792310fb6b4fe5d0d9f65906b1cc43655bb3d6178ef9093ac9c8f1a91bf49008179394eee79e1d8e3228f567770c1ba1e30ba4bce2465ab68f53ce21c0d8ab2f6e535828f211d4db957dc3af8b7e00dabd8f1f74c959b2aff45121c5b5abd3136c6f55d5f5ffdbcebc3cd7a430ff3813d23bcdc1254fe6949da4e7694028b7fcb876099e91b92c65d85c39d4be9325afe81703e5b18cbd7bd9eb59a9bb9408abd966ade9a60303807ad1b2c14c04cdf8fae6950a55b21c9ebb5e94713bf8c2890215c5da94b59cb31edc671093b15ff5014db4cd3ea8060260dc1612e9fd6e5ab40f0656121f689c8e94212269a7b24305c83bf0583418755ce690913cb081f2893fb42bc4750f2c053c48c1552430793cdde1a49ac9e21913210d727c4beb5640ab9b7505ea4e59af417a085394181784bf1bb0bc32bd71cc57ce77541581f14b8ba4b758500694796262b561a38c72893c77b548d779a3833eeb064cddba5471cbffbc769e139946155bf376a56415ab743de568cd21895ed6951b5bfe1b1629dd6510dcd4483f206954964e0517546dd96900a2540a51835818d1730b0c9123e7fd8b28e6843bffb659945a273cea944ff6e83c234b3e43db4630614e0b67778ea760ee341fe68c525e90475a1560821ae6b2a85015292c36eaa2e041ac04fb55922c48204525187c7e0476a9fed04efbba96f369d8ae709506620127fd399613a9796c4ff96d7e",
        "signing_randomness": "6e3210335aef4b760e5a4cc0eb4763a8d8e6a6172d4221fe966222d64152cf4a",
        "sha3_256_hash_of_signature": "64cc3cf7b941a053e4e656b49c81931a6284b68c39d917c8bda6cebd7b124153"
    },
    {
        "key_generation_seed": "103164ed522df0db131c15e139c0f83d9b1b7a1b6ecf7f89a5248cad7e68de8c",
        "sha3_256_hash_of_verification_key": "2edc6dd2c7b4dabd02535a8ed974269a8e87672d74d6935f27c94dc6ea0c6b97",
        "sha3_256_hash_of_signing_key": "1d636ff98ce3dd2588901ca941b91c0b3d4a9bc4ac8167b5e033b6c3f9510f26",
        "message": "8f37a065dd696ad437ec82909261b842ec0a3e66f8ac574105a3c82ec8b4926f2466fa550f8ea1b6a9a142c00afa44be6512a85350930dffc99b95aa21012057051b68c48581ae439b9290a163aa4b6afcf80ffb91a3321c7b9abad56d5dc1be4e67e5576c9f3a7db96071859b94eb22a73dd96c66ae67ab11d1ab62a86d826c682dfb8cca3259dcb5b34be635421cd4206e7d92147f14c36424eaa407b441f58e5c187e58a26b2ae144888a3cc1387ac7d0a681eeddc3b7781ab282e8185ccf33fb27500cfd119e0415db1e45237520a868c8457c88a1d3ee97ec9451da35d7e74924f8902949e7eb14ba87c8ac672d7e4f3bec1b2814dfa67a8dd2e2d4ff4661d64bc4c6d6a78d4e489689b6063cdff5a3f1554501b424284a9f4b8fe777fe4e6afb83a85e36200a9ab40b9c18678454b2a3f50a4862ba1e36f0c57ad004ff90192b5619614e37dbb38a1b8a65ac613f7796c70772128377065b84f122540106d1b4f9123c4e009b4c0a85d59b35f72debddd154abec7f3fb25fd1fa04367386098de610b26fa3ecb031a6072d14607e92ffbe195abff71e586a984131af24e18ae94dbab0544fd2ad217960f337111bfbd4046809ea03c7c47b7177757a4a43e1fd0134859ba735a8fc17597e593bb58322136602954d3a21096b0d1dee5cf0ad17a5fcf561ffa21caa70d33998840e4cfa18ba481704a8b82d2cc1c110fc9a6704751365ae9f338afe4cf9c811697dddfa8635a2f3cd02dd1845251014bf2f2d6c02a907bd783207c4773a937048a07c500d7c424b5f65a2c376523740df9a0b60437cb8ae17d64dd51dd4e433af83b20c4b6b890b97976df09e3a86ac19006c229d59fc7a2923245b7b1f0acf7c42e486d41ca1ac1d7051aeef6003ce94182f97d099c74317f61eb47ae18c2bed6a3cb253c21ec835e435123e0a657ed926f880ce8e5de3155272328a467278f52ac50a1121ae818a3ea3a2e1f7401ce23aaf66a4ac289748a7e98a5124c586d8957bb4edd3f091492bb1a64d75efcd45ad51ca420f15da848b20dc6bb765e7b71359b3a9e95e121266ae4a40dc2e9a3d81ea1b1a643594b3d4e6abb7d1202201de92bdf0cc1ed977e2d5851822a01f48a6f23180822888ce345ac9be0cc69bc448d41ca20b79c35b1dad73e6c683e70c4439b404cbf07fcc39b0e5a1d33f3717a6bad28a6da4f091bc7a",
        "signing_randomness": "9af4e56c2162c6f7e78be0487f6e2d9a08e228641ce3b1b84ddb00d7e17ba098",
        "sha3_256_hash_of_signature": "5bafb97b676fd6d5b8f5978e908897b70c2631c861fd3ecf8b0dd8076201d446"
    },
    {
        "key_generation_seed": "bc962d978f38881085c1b813bc90eee44ad9e7651681c20ba46402f557c454de",
        "sha3_256_hash_of_verification_key": "c58eb8f3f44b6e63fa552091cf2f0c2c92a9fecb25a2fafdff3e641c41934b69",
        "sha3_256_hash_of_signing_key": "75c75569a3c90d52fa90fe52b7d5b04a040ba5d6df12ccc9748d8238b2fc6fd2",
        "message": "30d61c6fbd64113fced8c5205026ebac0d9f3522182617cb00b6e70c8da62ecc1bbc8e1fdaf17cc61dd01ce85a9072cc1d9d34fdadba5b93e0aab4c9c4c9e26d3f7f145fcb23673b6e0b373c0fd1a58f52486b72624ef91a539519ee5305772a006e49521744912bcf3cdbad424f00428aa96ccc21d000efb09da5ce652e361a6fb649a060835e3b9dc9cbec660c7531620115ec905dca6ee2a1ce36554c0fc1d6dd6863b8f3843508ed5c214b6923e7f5c0304e9b0d5e5e433bd029116a33a60cb980737ac950577d0594bfe0ad2225cb8d3fa42f192b0ec05a49391632a32fa931c0fbd83a7b6ea24301ad0906e7911f9d900d19ae1247ababb1c0e9b9bd165185d9d7413ea068fe8824cce5b3ad51fe8e2bb2c4022c61b002c1df4852e4910f38613787ca12371038b6364d920e07b4b417401253451ddc25624b5d038b2dfe29b8494ec960f87803caa256a95c9868af819747e4bf26faaba6ddbaed93a7815c795ad5eb7fb4592df678ac1375388cc7ed3a6230cbe80abbb113c80b70c789cf0c66b943e67ce814f12d3d83f3b90a4320feb7fb81dc93b05d7fe2d36584399214d3d7c71aef322a5d04b5470703b3660bf86b0b17ba9ff23e45f7befec3758786d2111c81ba4d81b83feea35a0668e5eb3694963bb4db3acce4fcba6f3f6fed9627580dd2d2dc103ef7e52bb9745bd42a7fbdb459b5c8aaeba67686eb899e3177faf0897c61b008ace3304c41b4c79e2ef9c865e9958d8716bddb69154fb33187d927b5296c1589fb1ae3d553f116ff6cae56910ce6717c446b9947ab2a981a8f5999c1c6e517eb3fe584f5d10059910e22f40fbddb709c9f686f51abf7d7206a8bab4a346b51523c362d749238d7ef6671a89cd86a8540604f134d760267e91eb92fc0fc275cab69c776ef81dbad35027e5307f1d34ebf5d6e4df424d709666a1e649c044c4930098b2e6e3782a93976b55073c504563c7e052b6816c07f0fd54a759d2bc189fac3ff54549fc4de192efb58a9e301863a77380967735910f63d35ef5fdbd8751de4bc6bf2e3095628dc7f67c1f5571d17aa342593b2c7f953c3f0f22da1862122031bbeaf0d00a029c043304e3e2609c4fed8a7404fa10e2ec846a70eb0e37c5be61e698cf2296ec1fbe6fed75f6fe3113c23b29afb5a6d7e3a9e46e2d89d8c06450cea11492c1a97f7d6be8ff6c014930043022b264fd32593952bc606f779598631e48eed86ec2a013d8eb866f311a400",
        "signing_randomness": "1f00e4c1b7706d8f575d69cd0a0520a2be98d897bc8249e95d08efeb68bae7e8",
        "sha3_256_hash_of_signature": "0a7517532e7f81658094ece5a3de33ad5c5f420c6811b7fd0a14a48428501826"
    },
    {
        "key_generation_seed": "c3de54854a4060ea09ed92a363f71c7863eba64195e9ac79e7ad7eb6a183cfac",
        "sha3_256_hash_of_verification_key": "b677c73bca228361ec07a46260c6374668b8eec6f7e2ce23240562a1cf590cad",
        "sha3_256_hash_of_signing_key": "e8d4e71530178bd6a96cbec09e3fb1fe6cef16cb59665c2441bc33b077a200d7",
        "message": "c83441b16b39bd7993766e7260d07751af2f19a41e70689b0eeed0c118d9ef109866aaef31b2d2962a25a3d1ca999214cdf0eb54598382eead64435b7122d275ea8879bd47b41eb64ea908867fd78ecfbe8e992a2636aa7477de5058179565d3a2ceb8ace5c0302018043c411d89975a64927b48cb622a13f1ed85cc1113897a68488161afa1e636ec786a0aa37b928ba88a50164a9ec372523aa9ec8885aa9c95b29f7ca1bbf0652bac195ba94e976d336b69a9f5346b4c7c81457f802dc9757c7a2435a617317340f764c1a2ae131a716318f00af0efa89d3b57d8f31e155598b3944d950d6a1d6485b509358efb3745b95edc30dcff02574f54dfb2d31b259d132d18897df868115679f06d41102cd4eed4ea290f711148b99b647b8555a4c0dca1d2d0871c59ab1382a2d6417e6236d71e2bfa1a75cda54f93e6c087d611878ac7670a04fd7d8cb0993f456e3bc1c3b5898076e22d2d9e0eebc7d7bb8d142bd2b5f6fa42b40bf676fb69c532d7520a4a105ef0c1337f53d6e9b4ba17f1e76af4cfdf08f794752d2bf71e8777e2a209f8891b1a53d7bf2a5786b00b9a0cd0fce79408f26befa2535be188a68201b1514074cd70660971f86e8d3e92790ae7ac591aa7a996149bcdf060c615209ffab82e6000f41b2a5606fdaf4cd08cab0c2f1103b2436b1fd7dec477c6233fbca3b07a0ca01bf3476bfe5334e32aaa2ed35d5747d673e7bb622e1aa7901c77f28a3ab2197c8b8253a1d28c969eee73d17ad71c7919e7f217ba2badbd1ebf986cfe981024fc347028c1109cd4204c7d53535a9b677e39a43193e054d0fd68104d88934dc7ba6cb3e942aec744b935cdcfeef4221784f96798e650ffb0febf2715d75339d0cb6c2e57c1e9d10f13e6786b7f041ab307b8cfa51a2f10b622995230fba54b70d94ae278ec224d9d0950ba97beba7eeb0e2fbc4093e548d9ec09ca1a08e5f0483024d7c1927ff8dc270900d42d31b81b13a29839bd746cbb3591bc33817741a31dea308f549a74f3a4e5478844183b8d7363ac1f4d4a5e907d9ed98afd08fb8baa84c324563495387a4f12c239fb63f0810447131311b2d2ca302c7da2da57c94c3b5e844f537886fb766ec0e977254dbca8fc84ad77430428f0692e55d8e2cab294b857ab51a2ce4a725433df28d9caba86c770743ad987bba58c0565bd18590931e283292889294b607a5f19d9e905aa3940836e2a74a2e94ff3062e85a5c6c978b5eb2b254bbcde128280e6cf02c11a0c2066f349e3c6c083965d5b8a9c000e15ff36c5bf3a6d42",
        "signing_randomness": "b1120b7ab8fcb266fad775c13d6bd5e9ec64da2309bdb637f5decb141b377743",
        "sha3_256_hash_of_signature": "15a3401d0483d83245f08da9a03248c309aa1523b6108840e12280c4d2fe5fdd"
    },
    {
        "key_generation_seed": "828b9804524bdd17d0eb387368b01b0e95b4960057ed63fc2289d858201e207e",
        "sha3_256_hash_of_verification_key": "d2e927d9d861d3982a36b36eb57c45b0df4e624230f2cfbdadb4a7eb2904fff5",
        "sha3_256_hash_of_signing_key": "810837b8557431e04095d1e0d5ad6b284c2d04a533239b730acd1620ac6fd5c7",
        "message": "86d27c1fcdb8164f8909073f590d0a280e5ef193b0c42863ba518bc8a51e625658dbe2184c3353faeb674c991eed3f1b0fe3bbe50a21ec70e9f57b97c38d6e436d3dd577d7056b07a401ff0ebbbefaf8212b993a39281190e309ed0c50b269e4852dea85432a5941269fdf63766b21d25d8816de5e87ffa051009d232d6b258c5f43f45f2d48be09b2ccd8fc963fad81fb368502057afa7c865d62d932f652802a299295b29411439dcf832e8367a749b4d7adf7e8abde3ebfb844a9b1d32f77b2bf96b5d29fc15dae83ea80a990aef6590776ce1cb81587ada80b9a7b45aca3bbc54dbe67df090104fa196701280b97607a333a9b56a728710cc1cbb7569b79ff034572495181a92d2380a7ee5e9cd1b0f758c2bfbcc4e11464f1cc7d91f117319c30ccbf4c11e60b5dec724225b8d77b71aa58f5fbd498a3f49115687d58393be648805ba1737bb921a08d738243920c3834f8782a8256b7dd22ccd5f4ece86b8a0860bff21c5c8f0be987f2d510ed4df9cf94bf698680b7cfa22a575a3d1b5b431734b59a4b31913019c1f42dcb76a9ff32bfbc6e16d2fade26e3c17bae49cc415e4b370d1fb43ff652be62d18b0affdf286765f4f30fc8d6f2c4a58cd17b3bdfa013bb2daa075be5f522ef9bfc2e1506cc1c4d381b3342edc19c955a5fe48a712af5ace66a028d03fc859711c9d33231e48d41e58a2c2ad81da77529ad5e6b73e1ac96f0c8e53f153faea7903f917492a1d2b1203174a08551ff0f9f91e32bd0f31d606c80a505d5eb55265542db3653c2621e7eb3fd677f49534f261205f834eef1645af419ef6be5cfc16d54c7eeea12d2eb9458831f77fa558e4d5c7fe446ddaac3e1d502c941c95f572ad545ecc7cad21f0dd50845cbdedf589505fd34cd8c00d57243c3aa3615d84c39b0a72c28f40ac72da25ebc6987df5a7e390399463786e75d524ffb6c961bbc9301264bfe3c699101d18ada4a72d193971d54089e6fffa684cd3d77570ce0bb9179a156d3e2dcf266358499bfc158ac9a6913f622ca861c968ebba0a59a12674bfe39389a2125a02563b082259483e80c89a3763c0a9c3db485aebf22c844539edaa28a3fbc0053eec475679b741d9afc16b5fa109399fdd1fc3574df8a1292b8d7401aac1be452d38f97d531813369ee4c50f36736b95ae9c3e4f91ae85e2d664337daa40f75cced2f4a4d210bb4ee25a56dc217dd176db5aca43c002afd63ed8712d89e266674d9736fe4a9f202a81d177970411dccd289b25798272d2647ce6451906a4f7d46e87a46cf6cd048b6bdb62488a24f48d1ebd61ffa474321b929e0a7b6f9d0f6d777acc14815f343e1",
        "signing_randomness": "34f2a1e37ff2d2d8bdaa7a828b98fa44211d5c16b783abc86dcd399011ef2864",
        "sha3_256_hash_of_signature": "9a23ca671e70ebaeaf47685c03ac211249f889970bc946b1a111a64c40f28d42"
    },
    {
        "key_generation_seed": "4a84ca5c3954faafa11ae87fcbe701ebb5afbcc5f8ecae7786d10821e01ada5a",
        "sha3_256_hash_of_verification_key": "2a72987b1a02c08bf97ba241540c4ad96457ef6859d045163e7b59524592149c",
        "sha3_256_hash_of_signing_key": "65776e127e19fa9f28b38b0c96323d8fc9a75d59e2000f930d47a5ab62a11fee",
        "message": "56ed7708f98432fbc623424c2a3634780470a01784becff01bea5ba192d02c33675084263c4315420a009579ef80dd15eccbb812652421872a9577ef7d07896a727a64141bae7173426dd5a3925159bfa927ff1039e70f729847b48365b4d3551476206aa049ba5ae8f605847aa03965f058fcfd478961ebeed06530abe900042321059c297dacfe76cc12d52311b2ff8ee1231c77049e232d9fdb751fb27eb7eb6a373b4b1c06bd0ff46b1b208072c873e6f938e689839079e48c6d18f678769f5f28a903467f2ff2a8b02cb19df675a8fc7560a7d38a918ab8be083ec4e0ea148517ab90f38394833304f245bffc47f9eca771fb80b9c71ccd05fc3b0d66eb06d24b914b63d9f16ad2f2bc454b591d01ecfc527277ae71e3dc683161a53f129743f3428fb82a89dbd5d42f3eed237cd2f8d76de2e56a2143ac6b2ba811f745cc72132028eecd4412b76fdd87a2e396adce72dc69b8fe053042e798b220974587af96ba419da6888b13ffe217c9d01434347f4162fd554b760883e8eb1aee46c4c26b990c6ba10d2d939f513bf0eecade8b5deb8de2bc8c8894aca51e65aa696e390c11689f1c2cfbb70bc5f72c1872d99babe8de8fe2dbb446a8129af0ab8d9613f0cbf3cfa6ea3cc409f4a97581d5012707756994b6c8d4fe7f64e0f0b85a85d0a5fe23224dfd7abeba8e3fb2e97ad87fa8dd477adf48f64faf486d0df11ae9c3bd3a04abc962c5b02cda02d48f0b52d84d4920c116c22455df291a96e6adff91e3cd35cb8b5b4e70e3da8b87cdc969643a32b1f97131c5e0bae7f6dfbfac32218eaa596d444574ee85ef7c9998dc1088e5813d50a4377d29506817e4234f68b32ad68e00adbf6462f8d4e215f15a19dfde452f0a65360f7c1f20e11c42eec55565ccb23ce248bd62e9dbe8a7d6639028a92b422ab444c5688b5d191a4ba8956f358d131e2ff6dfc607accc5d31af9678f1a226530078ff9a73d681deb697670ddc3e9096ab0fedab664473dcffedf9be62a5c7c54fa2eb5059e9a1d38413b1a4fe6d531b799453bc7185abaf78cabcf65f365b00827cec5f29c4737047e3b2932a78757e9626a958486d1740ecf1ec17a01aae6adec5104eb934f432207ce31d7096acb3a0fe2f5dd7890c021892fe7d3f34596cf20b6b12fd55911acb46d7386f99a9e9ee067a45c6a1fbb463e63d69cb582da6ebd6330f4f80a1fa72f2ed24ce9bbcd967118cfc7e21f6bfb68a905f532bcf8b8befa03295d362b41d25cdccfc9b41767858f651bc56ab2bb4a8675513c5d6f1c943a20a27dd29f941ad141debaad219e056510bc984063fa0f389090d434157438bb1759690c453a2f55f72c033797a4b0c534ea2ea084b3b6f8966ac56b106fcc11ef08902f2ed",
        "signing_randomness": "ad050b9fc35d0851c155c9caa3428967c1268e0a3d19319314a91df98c56cfde",
        "sha3_256_hash_of_signature": "1957eea82c1889c4deb8e11f9b6ddc2f61c8c22a9f8c463c54e9784037d32d81"
    },
    {
        "key_generation_seed": "3e74ae2b1d49ee6f149076f0bae2d26a5cadfd5de7bef66dfcae6b588a1f4067",
        "sha3_256_hash_of_verification_key": "feb91ab9ef56bc634037d52803cfd16e04f70662a7af2496c95d4b48b35572f9",
        "sha3_256_hash_of_signing_key": "0fc73a2694af0bd4657ff2fc3750d54ca907e6a203716763436b374497293fe4",
        "message": "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",
        "signing_randomness": "fe7b70da3b78360a10c14cae7eef4db2906329d5ed4bd1ec418b43bdec7b3eec",
        "sha3_256_hash_of_signature": "d240750aa9f96e65fabdc44191826d75bfb8d52157bb5501fa508a9b925278a9"
    },
    {
        "key_generation_seed": "39550bd2782d66fa95380f5f101d827377b11410f8bf3bccfbe0e504fc09ae38",
        "sha3_256_hash_of_verification_key": "0fdf813f240bd5ac91d79f9b84c4486001902d58ea621a9f07762ae9285c140c",
        "sha3_256_hash_of_signing_key": "e40d1ed860844aa850dc85d119cca282d7237a6da8e95b5ca9464f673cec7e24",
        "message": "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",
        "signing_randomness": "7fdd2cf4e1e5d5ad2a80c4075ed07b30eb59a4b4d96477f25716ad9549346da5",
        "sha3_256_hash_of_signature": "24eacfac896a731396ab934997103be1e2f82a2ff49ff111f190e652f022818e"
    },
    {
        "key_generation_seed": "b18f0fdf9dc4f514107f88cc43fb29190608ebc5a2cd00b49fe20631761038df",
        "sha3_256_hash_of_verification_key": "a3c23888edd8f70945d9cbf57642db66efe319c1b3861e40f8f8ca8e57a4b645",
        "sha3_256_hash_of_signing_key": "3b545b1e820ca9e16c5a0df1ac282746c7d4625dcc590121d4ec96f6545c5bfd",
        "message": "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",
        "signing_randomness": "c1ff0e9e3f024036d0b0c1b7db341485685def89b0cbfe051fd31d50401ce1bf",
        "sha3_256_hash_of_signature": "a6287b0cbe9a4088ca418e2e8831c1424f525ba83e51e0446c7168ce5e437f93"
    },
    {
        "key_generation_seed": "d4fa14da39548392300a41be413ebd53bd7bcbd045b4d3c8ca44abc9599e269d",
        "sha3_256_hash_of_verification_key": "2c629d61e1d533559d3e2c5e02209630179097a507599b7ca1d2005a9b4cf425",
        "sha3_256_hash_of_signing_key": "e009752e08f73ab02fde63de72b910f1b94af7564fe96e1e0cae0d8882b36b8c",
        "message": "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",
        "signing_randomness": "35c3848bb8ed68520a67de0a06f41c58d38104eefba7204a7cffcf76891c46c5",
        "sha3_256_hash_of_signature": "9211e651f580bcde471cc06464ae894515e417718dd8ee745228ffe9416c5d59"
    },
    {
        "key_generation_seed": "c796fd12d1feb1df46b162c38292684c09059e4463cb95dbdbf498a4dd4f7f00",
        "sha3_256_hash_of_verification_key": "16ebc42e34e232b0b152ad7d4548c0d4428dc39bb90a97f41aa0fd6497bec783",
        "sha3_256_hash_of_signing_key": "796c03cfc5982f7219fd60691672f378a8a6d5cba34befcfd4c7b51870bddec0",
        "message": "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",
        "signing_randomness": "e23d6768de6e3ab32855028cfb7ae2d7598584cedaa314c70759b608c86edaed",
        "sha3_256_hash_of_signature": "f2ae81b75d8f6195ed3f3fffe9c6c8aa14f5048a2a37ff83c4ef634b2b67ad23"
    },
    {
        "key_generation_seed": "a18a366a5ecacae4732dc9e954333ead153203013bac4e3c50bee15269f983fb",
        "sha3_256_hash_of_verification_key": "f569d8852b2a784c23794f87d44cfeb04f0621dbc1b7f7def75ef58e33caf93f",
        "sha3_256_hash_of_signing_key": "e832c2c06a5d4e28d2b78556f2015daf920f995248b7d65a8046dcaaebdf3d54",
        "message": "e82f5acc7c1a326d430475357629d568ea3d0dbe131114781d5bf8daa32fde9f3cecd288acd14445678c5ea6d3afafce48ea3957a6af8d8f23f78d84130fb6419f706eadd430cc85aff48283f15602265059abb075e011e3941834ebe70787cdd55f1e604c6b86f761d94c4f5e525791333df6d43869d6f36b212a8f35583d38a21d0947cbe26fbe6a36e189c73137f2f2d89f48566d04d2dd9125d2ea4e0b2a7e5c1e9d2ea036cfadcf7bb28f6df3b7d6395230c9d39d1e7558ea25340252708be23ec6c0c9a0946c5c5af0fe037c254d1a5b2b70b8f916cf37945bef76bdfdfb19a0daac5a83a6357e986b3155cff31024121634c3700ca99e5ecef1f2e411c6621fed6092c1ab59860271ac7f431e568075d59f71aa18096195f30bbeb1a6bac20e034f83c72be0536315879f1d1b7f31d38c12dd8e97819b4803d02becd436b61d1296ceb78ebf857e34087ec8ae8395269b5b0770b3423b39638910d2a3ddfec8502389fd8b5b09ffd10caad1a5c86e7e39629ab09a4abcdd00fbb9821f92e7dd24dda83d1d9762f52a89bed6c20648ea04fbad4233e5920ae83ffec28fdb5e432929a41db782b2cea8feb40cad0b27903050b650477e5d9443a536ecdfdac673952810596f1985427359d9e4797cabccd2fa0c0a2394d853b4e6f8e150b3e3ab5136cf476605ff5ffa9067c0fe58a143b50b18b09256657cf091132d449a6e7ee79aa870e9dbe46bf840edcb983f585ec2856c059808e72b8c901a25d6afd5372f168d533052a6d26418e035d87d0bf818adea19915047c8d824a425a8c7915756673e0f5fccb1b4fe7c1fdfce505f7e18f023fdd32a605906ec48e0fa755b6d87e47711e158d672c5fb4cd3b8d1d13fe9eece58453987cfcdd87b621b870f3aa27e73b6fb7fc0a6757893b978c63b7723c49d1005a1e5b1a4d60c4a2fef392df7ef97f149b499164455633fa485bdf92f804a47c8703d124522d73887a2b032f10f45343993ffb009d69e80fb54b6999a5bdb2760f8bcca648f3c52bfa1d887ae49862db4cbccc7213acbfdc48a57c3da1f1ebbea828182432aa1c593c3e5591c825e5706a5f9503311e91ec3d8f4a9554c3df915b5fbe0516a7a5597ecf8862a8df286ada96c90c9f2783f7f947a18ebbc64c1baf24b29f77521a9ebe09becffdb902efcd024046fd3e6182bf0c84bd3a0a5410eedbabfc60114e5db28b0943d79f58f766e2edb16759850d4cc3a9a57ae073cf6f3b24d36a4365e2bc64674259170b6d11dff63d0deed085b6321c45f218e09351aa0d4155189cc98de5627a03396a067ab3fea2c133062e3823fb1cafa5d592070c8e82abe812979dbdcb6d2e595f33830ad0e8e2f9e6cdc4d9c74b8026ead1815de36772769c4e00806f79950a40c979c14a4bdbfdb79df1de01fdfcaaebc93ddbad62ba166843a121d2b144559064e9de9e310dfc93d624c1061bad3195d6c9f46db64c65a31e90371f9b644e2a15e01c262395269a9ae83f50776f852903f86e5518bd008cf1b35e78f910d48c0b7bbaaad5dff2375c55d56b8f65b922229d5f494edccd2d676361619fedfe6bf0bfd7e4c77fc459f181120c4430c409ba89d2e5a8c36cc6200497611d9d705da6ae1aca4e16b389d632a982e017e1dad95dffbc7a7d7191e7b8fa1c0ed",
        "signing_randomness": "77389d1b21d40a49d3c39ada885422bfd31059e24ed26c549293171568c7cc21",
        "sha3_256_hash_of_signature": "13e0b9be0962f2a54e8988f310f24ade30964c5f701f441125a847ba6df8a243"
    },
    {
        "key_generation_seed": "585e714d565aa66078bc2b12699f1e86c6ff30a1abc8cbd19563bcddd2f1f6d2",
        "sha3_256_hash_of_verification_key": "d15c24493722f5df0756c5c3c2a9018022a92d9ff6d4136ac44fce995435d328",
        "sha3_256_hash_of_signing_key": "49f4a1a292d2da63e895a43961e7df05f290862e1efe508e7fb149029937cab3",
        "message": "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",
        "signing_randomness": "151110d1cb8e5e42a3917527ba7a5cec33036cac5d0a84bf0f1b7b0e860bd0a0",
        "sha3_256_hash_of_signature": "528acce5bfa732fec115c07ea661c28d4278426a0c8dbe642aef6163ce4cbebd"
    },
    {
        "key_generation_seed": "662cf70d3d5e95a9c6a33bd7c6abf0e8cd23ab2d2d9420878c4835de14a6c606",
        "sha3_256_hash_of_verification_key": "66ad53809e8d7d9134d17247cfda51164786a9bbd7e2d9036d4e715ffba0ce38",
        "sha3_256_hash_of_signing_key": "608ad25a785bed98280bf8e4f1e5dd95f25f1f92a3d5c04d878b3f7a6aa4294b",
        "message": "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",
        "signing_randomness": "7ad0ab708452cee65cd6b0d46ae27bc92b52753064161b4069ad82a50e65da4b",
        "sha3_256_hash_of_signature": "96c99e01cfab2ed735d016f8e96cdb188e45ee4b2939f270264a214887054b77"
    },
    {
        "key_generation_seed": "1924a71628292aa3d2d34ea72e2bfc2520864205f54ec6f19f7714733aa34cc9",
        "sha3_256_hash_of_verification_key": "dc9e717682b6e9d864f9ba5776386c481f80634963b8404f5c7696e533832960",
        "sha3_256_hash_of_signing_key": "dea9d5553e22e88893af1e3ff1ea12987271b7c0bd42c88b5cbcc2d692b5125c",
        "message": "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",
        "signing_randomness": "c873b18e32e373e33b6299c960eb6db2fe8d9274aac0d9252bcb5394a8242a68",
        "sha3_256_hash_of_signature": "38de1fcfe1aee3785c00b110037fd4e50048f4d38920ed96c5427964d27437e2"
    },
    {
        "key_generation_seed": "ef7ba21809ae7e0bc3230b6061c5fee206d805572cf1345198e1ef22a8fe7322",
        "sha3_256_hash_of_verification_key": "14c9e5a62a81c176b86a885b7d1ad045d63872ef581be780b14dc2ebc66c8f45",
        "sha3_256_hash_of_signing_key": "7e571cd7209468176d33815dd31c7af0d5d006f9ec13c4aa93b5a2a2b580f1fa",
        "message": "061934748c6758ecdeddf3a2df78574a470621496ce3f12e5e4555febccc1a46a772fcbadeba8b2eb5231b5b15deda5a38076c737e5d091a8ca8482f84ec4a20a51ddda391088f2c3926f8e1d8b77dd0abd606e9ac25a17a86a5c75adc215c5030355c4a1b307c1cc80a3bc4a7d4b4044fd35d173a2c7c081318f707828a3438dabe0836c2d6c14e1643f05ef8405531d5594411ae4dac6f3992279cae379d7c1762b122037301d3ffe8efd1beb4e027e055527d485d0871f2013e7b25cc26531c2ca6ddb98b31f0ac2c3bdf400a0bae942c9d4c4003f9952b67af67e85f572edc3345a84b6dc3cebbaadb7e3c876ab2da16ed0eacf4858033bf5a4f739f9e083a345c2bb5d8611dae90d25ac45d8b3d39b4de584cbeaccc6f5b6e61524349b50e818bb6b03c7e5b86795d49324ce6b1603791f20b3500a1b8ade82359263470d777b35dba38276096445842ba5d5e960fb2ab58730f970a15aa42d9737c33be700127a7ce7cade024d3abca59ca49f9a7edf44db62ccc07a595016868aa97a140178dc92530eff864c24954464ba886db7d74be7b540baaf807f1aebd014680ff4a51e16e1391e32069ee823f3d23db72244d657233578cb7d29a33e6ec31df1fdd43b51742cc30efc54be83149177e7bcde4450dcd142eb2cb745f8865dfd99dc84ab92750f1cfb0f3944e4e4eaa41261a1e8c58d9b230add792dce20d2612823c0ff9f82e04b61e48dbb83f1a6dd5cc7f92bcd0a37ab3053803d1188029aa1fed9ba04f4c961588c9ad2ba7ef1cfbc50fa69b799898eb0dfe9668260ca5680f91a10d2bef8f108ab28fcab693ecdb942070d2b9b8bbb22609c8395c23d7482c31b69b0f555b7c079d3defaa5fb302ed92619c058adf334e845eb1c6edd903c0de2aedd3d9830943f8bcc5954b65df37c901a17ef13fa75b0f2c8c1d2e38681874aebfe90b463f2cc7831958fdc0de0446991eb3c3612cc00188dfc1078fe458d2e5b80efa7bfce800c6b4ca0e570fa5858859633551da28f36f1ff418a9b7ad18aa89b4612f9d676d5fd98bce6f144cd7458ca9f2bc732a36a4d186ea290a009a870da3c1f60617d56ea7554062367121f3e5e569503aa573b172c6278dde5aa4ccda79d9d8faf41c6c9040c1d1d3cb78b41ffa8a0180395439f0d1b72e42471a9100973ab3bc7aec559d94d2d6402374ba5a584de168395a156324e1e4149abd35c72ae0f79863cb59ee6ba22145e36e0d85d3caf8a427d38c96ce489cd0aea20d7960608c074ce3cd0494b6d6d5ec8895f0f03ce78982ad8fd6784bcf16825286c51325662f34726ba66d3a91eeb598124d6755da090ef863fa31ccd5b08909a3279a35cfdce24d2ba16f42ad280b029a0e27137a671c862b0e6f73ff4a1de320c4daffb5cd4ac3522ef1c10e8a918005535f355ce6366b43a757938594366831dbf7ee72f311be4953edd1ea1c598960745d3dbb7f1e2d882cc063bc0791d18c6376a8497f2f91389a13aa96dab78feca081d761479848a5b4cc2e3d015f343b9000583e95e785a45a06842d7c6c0fe9ac4d70f085503d7ac954516953c497635ac8b7698bb784f73fe6e7f9d0ab9473e828168df4ec142cc1fe18fa067525915adf0764e44292a0316ef3c0a443683c92c4661409589eabd7b4dbd43f54317ae0e3d1c69c35a7868991fa0bc2f83430d89821b91a08ddc2d314a717f5bc6f3d89daf163af73e10c61630139e3feda723feb2edffe6c7f364fba22e6aab75e267065b5e7575946c56265743816b2cf12a106ae21921e3e92bfb7ff80e105468f8409d6698e8660b5b05f3f4bb19a0bd4be3569d24f51795752be74c429aeca5be737de8c01",
        "signing_randomness": "12d9e81275b7aaa3ac53c5bb1b67de272495ba5b24285814595bd050cc6bdbb4",
        "sha3_256_hash_of_signature": "ee77f89cc87c42db2de634f3b71db23d18922d409ba6f07d3b3d3f42ee964767"
    },
    {
        "key_generation_seed": "cb0b305fb54e1cb23b63ec1f6f4689137e5048d095fb3eadc854c852ca86be93",
        "sha3_256_hash_of_verification_key": "0afd54c118bf9ac9f641e5bf2747415f54b544cc1cbaf61068b181080bbdef2c",
        "sha3_256_hash_of_signing_key": "f482dd551460346e5a4549ceeed540a525c79da2b3551618c89d8b1d105fcfd3",
        "message": "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",
        "signing_randomness": "b2f1c85588d0220312b9c2050408076301ef1442e150d199a6634e34d5bd2c42",
        "sha3_256_hash_of_signature": "5aaadff9669c7c96b1acb45e4d809f2b37d018ce2d9445458f075027658da3c3"
    },
    {
        "key_generation_seed": "f92ffa3a36f43f9177763ad320fd651d9357c6d99f09549fe6af12943b58be90",
        "sha3_256_hash_of_verification_key": "8a2e8826aab0ce83e08fff5b0ff5151b662aa157ba65ee53b95c9bec1d75aece",
        "sha3_256_hash_of_signing_key": "0ef196133df2cd33dbb8d23820d835dac6daae9e5837215161977654e295999c",
        "message": "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",
        "signing_randomness": "048add9ddb845f46a4c1e3338dc78aac49fb30623f649fe4fabe6b9fe23f5b2c",
        "sha3_256_hash_of_signature": "04cd4ee4ecc1e98b4cddd673ad8f03b45fecd1b508aa11922583438624edfef2"
    },
    {
        "key_generation_seed": "5d3cce926a795abc5f6632cabff8bf66275dcc7e4a4ab3b8399d23e62a28bd16",
        "sha3_256_hash_of_verification_key": "4842d8174cc2ad575292f8cf2fc1c124ba147e0f8a979acb6ea823a1f45b4f51",
        "sha3_256_hash_of_signing_key": "073958458c2138626452a754747dae7b5d4124cf083cd6ea2c92592d17b35421",
        "message": "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",
        "signing_randomness": "7d9a08d9689af9f8f89166e66d981740376a98d7d38c2ab0997050201319cd4d",
        "sha3_256_hash_of_signature": "b799a379617a105496662997e6801c6c4c56b4fbb8d500e1c13a1ed430b1983d"
    },
    {
        "key_generation_seed": "ba2386ba92aa89049c64ecfe60fddbe136815d3874527414b63ed32215f2e06f",
        "sha3_256_hash_of_verification_key": "672987f7551fca5259850de0ab90e77f24bc894204ff5d85ae2a89d7cd87a085",
        "sha3_256_hash_of_signing_key": "56c04d24ee6ae3ac225913e10fd067018619e07852fcd737f68ccb2003eab75c",
        "message": "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",
        "signing_randomness": "d4eb2f8d476734c94dc74d41d4bef21b3b2d9830db37d326b43de0843e1bd51e",
        "sha3_256_hash_of_signature": "27292db35606a1dfc3000c6891ae4b3868a1afe139d92d22a8d1cc8caac6c82a"
    },
    {
        "key_generation_seed": "b4e1af25e8dc6934ba391a89984a358702bdd36838babebd982638703f20eef8",
        "sha3_256_hash_of_verification_key": "f21e3d18ee0b868777922ef63cb8d4a2d233d0c43f49f5d18cdf4b685bab76d2",
        "sha3_256_hash_of_signing_key": "88a4e539efcc2c46fc4ea44d341a7b889b0fe17265b0555d701b239f64832ec8",
        "message": "96e2865a0e602ea4e3c5657a7f761a6f771007989ff885261f5638c14c1bf80aade34cb956d2b5fa1ce38fde831423201d3692e8e6f40e68a68c085dbe3c4cd8e35394f74072f44de98a74e42c9176a86ac06bed8c0ca937db4c3bf92371106b7a68ea8fde1d1e082ccf522a397401ad0f8da6c82bf76eab8afe101c7ff023a0fcf015b40ada0073363e7cb25260c18662d651222a4ccf1b290ee6f7b111b9a963211d67d7674b499449f760352feeb9fb7265a5f2f7f20c0174802c7f48226d92620d3e009e85b104230c21ba2fb0012dac4bdf9fd184e09cb3e593eb1f3eeb418a8bf3173e6cb91fd8080c7e80dbe6730833a4a9f22c52716731c7cea4f70cde0f81d2d9aafb6b60820598a7f6aa1b963b7686528e6e7885ae085c3d26c4acbf9fc15080d972ca841175b343e59fed79ae3cb4dbb4f0d7d463bd3e0c4b2090139145b8d7db5db10abfa51dc909c5cf7809030d72a5090cdc765eecade2b365f719127548ca601ae0d21e402e18050acaed30ee13cddadacc9373a87a218787b585319a7e66fbb13851f7ad0d2bbc1efe6efe4f7ed248d844f58b6a5a21fa9295e0044982af6286de296550f72b5e416373f1dac006687ded1e7d40961e5177c207579f25e77be808a6ba33dce8a2a6f88e97ae98ecfbee5296d4a170e3574d9ba592a384cb0545bcfc32b3831c0b736ab77440722299f192dcad519523995f71f2983ba87aad2261e6e01c19dccae00f8d6914501d1ac3d4aff0c12fa125ecdca34dcdd8407f0045f8e8be0763e19eb007ed4dae36e30afb07f8daa7431b72f4a0a8017b3fde27123ac3e8ee575f8be310f68f81b696db1fe63ccb8d32b899b209b2205956d209bd6e48166bbb4372a607e83c47698db5ac8f9b40d05f38efc4a4a1309d999d5ce1e1a5828d56eda4666995897c8e6362d0b5054f04bccf79d03852d1003c80ccd55e9f4578d8bb2c8e220a4d7a4e2190024c85c718654ccf174ac96c1bc50ea49f961ee7697c88e6bb718679f1d1f1118376b31a4b8c0471f6d7aefc5ab426515d1b2cf0eae66246b3c4132a63c63d7e33eb9df8d8807215d58f46ee832ad3ec893d74e00c73510b9625f62d4eb5b500eecdbc7d088d3d318077a4a0f7d64adb13220232c08da75d23ca7b20cb109c972b7c159863991c32508339558b9383ddfe7e7dda740e5bed0ebd14ed300c634db01f359f81a7133669183eb187c17a2c8ab855bfce73e34a1f59adb0ec39ec0c7573ad3620a819333ee79d5e09cb8449f91923ef4c5e21549eb7f56075c014e1c3ad2805e682f07ba8aa265745cb600a460069678745fb9638f6709d62d2dad8defdd5a4d0c2ae7401292bd1da5f40d4cf5d59a403932ffb677237ad74691cae29fa31b955172efc5e83c225f2dc0430ab0c909a97bfb468ae182ecf91e9026de819f3440fbe69b9de26f812ff3f3ce8037f124ab368b1153c1cc127d140f754c525d4799e1a19d93b90460e6518f0b6936dc6310b7e9e6534b595e00225978214ee5aeb12a6f45b5c73fe86771818843ff7a6b88379c37165d9dad48affd6fbabd11b1fb90aa5a78918b317c5f9b2ced6b9647f130da9f91e1b1ceb84f6e1618248f06d654e159f71033072f1517064bd96a5c138402771abe7f39f53a798c2423b748eb7f310485d6376722e204fa33b9740e7fa68364289a677c5c78a19a7707d2549bf9329334478c64351fea1634388acd4be57e4abe9374a0e999b770cd81b1bf4a8ff300c297b116ceda1a4a1c1bd5a2275581a0589a46142139fc596a1406d16293076527cdf9aea2d0919f9678423b7d95b153dd1d9d62b72a12f6491a36604d19e7bb83c476d232769425557d3480623d40b7ac27c0f67d4ed5ca4d487be915a68352dcb03a3929a4bb795248ebe2fbe0612833d9305a0a31d195718bac193fc59b880042a7f61358104a919c7e7c210f02a856b8b1057dd8527fd4ae1ea81f9e1bf7c614ed8a312c95154873f86632cbd60c65176f13cac695bb4c23675331058397d6e96e4f9deeb859e3937553d94bede3c2b9a5ebf00964a49ab294bccee09e5a97381d2375941aa775a47f726e9",
        "signing_randomness": "aadb9c7f9de8a127c541254c2b2b0108175d9b51c50b0547a980f235906bd895",
        "sha3_256_hash_of_signature": "466d0eff5df60fe5668e2ec8252b7992747a43b41c19fa624d84047f7aa7468e"
    },
    {
        "key_generation_seed": "a62875a3a6d305e120dc7975962552126cd844554857c2943872a4e524a6eeb5",
        "sha3_256_hash_of_verification_key": "466f7b8bb0fac5f93d2a5e4a8464c047118920dd5a868d5fecd1a9263e031017",
        "sha3_256_hash_of_signing_key": "cacf81f17d14deae5566f1a419e7d3ecb1acf18e85757a79ab2022d0dfe802ad",
        "message": "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",
        "signing_randomness": "84603efb642ef6f9acf327a4ce66eaecfe39dbfc124e3f73496c21f57996ebb7",
        "sha3_256_hash_of_signature": "ccf04e8b41ab4183cb05c70629b5186034ca4b6a0a95761900b375e9e6dd3c74"
    },
    {
        "key_generation_seed": "76ae71ded1f9e73af77a2feae4eef80f87414dfb7580fb4ae0325bff20d74a5d",
        "sha3_256_hash_of_verification_key": "13f36b14d0e2b5224e23888fdbcd9e6c51f2130bb4523c9b8dcef555c0c3b387",
        "sha3_256_hash_of_signing_key": "ccb1cb493bb9578340b90bf748939d91b67e7335d27a2c259f1da3186e8c9ba2",
        "message": "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",
        "signing_randomness": "9676de1c72b3c9aad4e68e465639a7e20862a243daff96802342dd24ceb53d23",
        "sha3_256_hash_of_signature": "2edd316e8328163365db2e1d4522d15bea62c8e975965b08761564c6f2629c45"
    },
    {
        "key_generation_seed": "a8f65be046001a6814f537915be3f03f3670e1169e4aaa6d7e726174acaec77c",
        "sha3_256_hash_of_verification_key": "833936ca4de13ea4f1cac0c4935e4b71463ec8999b1fb06425c610df1df9c045",
        "sha3_256_hash_of_signing_key": "159241fbdaf613ee19737719e12ca36604549ef6b3dcc4401ba0116629516c53",
        "message": "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",
        "signing_randomness": "3400c994f2f97d69e54a48514146f45fc88597ba63fd836a6fd9a6f56da3f9de",
        "sha3_256_hash_of_signature": "88ebf673b4613b1fc56746ccd2a1857e4b819e304e2816c007e1d3eec714af1c"
    },
    {
        "key_generation_seed": "802e08c14f6e3446bbf7f4666c8ddf7755dc718c3e02b7865ff33e9d8290abec",
        "sha3_256_hash_of_verification_key": "253159ea4bcd9c5ff97abdb1c9f6aa369e03bf207d3871a1b612b7ae31f41f8a",
        "sha3_256_hash_of_signing_key": "da0fdf3ab2755e8ad831bfa05235180daf8f5898143d3bc154413574a4f823ce",
        "message": "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",
        "signing_randomness": "64d6c65c750512a619a02bf3e98cba9073ee368195f22185a236fb9e3f713131",
        "sha3_256_hash_of_signature": "700ee7c67b27b2d00de521b582b8b9027dd08dc516efe02561333d703d476d07"
    },
    {
        "key_generation_seed": "23d7a85a824df3d904a511281a973c979f67f5bfaf3ab0546e85d0597f91120f",
        "sha3_256_hash_of_verification_key": "8f74e57e50cccf8fac253b0d36e5db465181210753f29760dd6d056d4b05fb4d",
        "sha3_256_hash_of_signing_key": "5b5bbceb129dabf192ab358b37bd607d5add9a87edba24db36d5e6289b1086a7",
        "message": "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",
        "signing_randomness": "30747c584e1b97911f9c202a319429d5f6e417b80be60ac63c4592d8ad891316",
        "sha3_256_hash_of_signature": "bbcbcbb6e5649025c4ba18de90ce5094148a647b32b4eff75ced4570e6d62eb3"
    },
    {
        "key_generation_seed": "771cbb7c9fbd9fc5db93e3e4de6c034e58be9bade93748c42297142124696234",
        "sha3_256_hash_of_verification_key": "26769788d868838355b3123ec8284413b9282beb10bc6b4ead7ce7fe63738a08",
        "sha3_256_hash_of_signing_key": "795fc29e60c3976f26b7be191fb0bceb84c8f8154a2f6dd75eea049ffe735026",
        "message": "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",
        "signing_randomness": "b1a71602133377b68a905d8f67b2199dc11b63ef8ec1ca9fa35e7f0fa859d14d",
        "sha3_256_hash_of_signature": "351bdb9f36317e8b73156b670c572adf4e2f26eb49afda05a913a816f5d77b9a"
    },
    {
        "key_generation_seed": "fa812d8cc3a9631a0239474eb93ad3a2a3480f2d973d3324228ef92a3b043163",
        "sha3_256_hash_of_verification_key": "6f927f4c5a4aa43c51c3e7d395b2cb92d7632350007fd332557a0bce6aed283d",
        "sha3_256_hash_of_signing_key": "eb615d8ea6baccc9dccf19481dbfd1fc5f1ceed6d400deafdb53c70a15cf7eee",
        "message": "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",
        "signing_randomness": "331c19cae713f365f5d17110bdb0a1d64b2ee06e58693c60a02556bf4e53a580",
        "sha3_256_hash_of_signature": "8241492959e4e80b33775da4d9b43a8f12806a95496483b2a30636d1e24bdf20"
    },
    {
        "key_generation_seed": "c660b84d558a7e6b4eac47c7b62135668e0ef0fbf74d514eaa3d0d428014282a",
        "sha3_256_hash_of_verification_key": "86df17b04d0ada27626805e5109717985c00e36ed634a4a5067834818cd000a5",
        "sha3_256_hash_of_signing_key": "dbdd65acb8f4c5d0713bd5fb56b8fbc3d082c2f6f8cef4e410eddc66e8e6b8ac",
        "message": "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",
        "signing_randomness": "ac6e80765afc5d0d647b5e4472b83b585f3a173155d444a4996545ad84e11fd2",
        "sha3_256_hash_of_signature": "eebf7fdb14ecbbde773fd1b261cc595ce44c463bd95cb90228b25b43e7731071"
    },
    {
        "key_generation_seed": "929f309ab3f90cdd9c21eb77a7ca762ca3afcacbfe3e67b056290835694ba3d8",
        "sha3_256_hash_of_verification_key": "2cc0f22cebc40872ee3a5bb2f5d39d4624392d45ae2da250eda2fd25fb77c377",
        "sha3_256_hash_of_signing_key": "c193897ccaa9e5ee48217be4471b4e6d6ab7e42ff3336993816105c399b6095c",
        "message": "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",
        "signing_randomness": "3ca92fcac81ba5d5e4679e71084f56b85c718cef79cba304573a15ae9d814944",
        "sha3_256_hash_of_signature": "887a5a0d2a83e615e1fa2b0307ad53f7c4e393d9d51518391b41c19079b6a649"
    },
    {
        "key_generation_seed": "dae1eba78ad1568590348088aae88c1abeb59626ef65991cd76ab81198e52837",
        "sha3_256_hash_of_verification_key": "c902dd1d01d56540d4e918c5039ef0eaafd42f0a10c2c0a688353f2d053891b1",
        "sha3_256_hash_of_signing_key": "6b5a4500fd43d3bbb5def0aab702314b23b423db399574af65b709883d71fe53",
        "message": "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",
        "signing_randomness": "539bafd63015b77a86a4569148f6c9b750d236b1bf8893bd23b56651c47b2b24",
        "sha3_256_hash_of_signature": "9df85e5dfa466a30618d5817fd8d174a27c9c542d7eb1ecf6e5e782a6778f68f"
    },
    {
        "key_generation_seed": "15ed428927a7eb0c7c2dc7a98cfbb77bdd773fa8747b8232a6ec4b87cd7dbce1",
        "sha3_256_hash_of_verification_key": "e0317c8476592b14a907e2fff1c8dac28a2a46f7156665a7ce293e6c18ac5d9a",
        "sha3_256_hash_of_signing_key": "245a211961d3fdd9a97171e331761dc0d83b998f7d6eef16ef61af2919581e6f",
        "message": "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",
        "signing_randomness": "fd3cb9a6d1c92d8919767779c088a9d5c67b919d2de1b6b630107ece8950baef",
        "sha3_256_hash_of_signature": "ea0730010c67b7e6ffee4d86646528a0957a335a68b26c06e63cc4a6215975d7"
    },
    {
        "key_generation_seed": "ba7e359b1f669783521ad35edabe97141a816c2fabf0ad0e001e21f73ccf7736",
        "sha3_256_hash_of_verification_key": "a96c9f13b52cc4554d82efb836d7e635b4628cba343ebe6f88dbb1823910dbfc",
        "sha3_256_hash_of_signing_key": "5211e0a6fe89c044d668314734c6865436efcd1da6e36751a9f166b2e138e0a0",
        "message": "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",
        "signing_randomness": "bd322c5cbdf5c481cdb9aa66cf453d5721a97e0055e0ff3604d690163bfe90d1",
        "sha3_256_hash_of_signature": "e9752a3447fd25aa9967b9decc8c38a15a9bdf6b54c5d27045761d0a5ca04648"
    },
    {
        "key_generation_seed": "9daef95c8d5a61d3a3a267fefb9f37d6e677d7ba26a3a5bfdbda8c281be89ccb",
        "sha3_256_hash_of_verification_key": "e2301852a398e8410e84ad5fb5e1ef24c21acfa57f6d02b66ec5b7f50a1fe724",
        "sha3_256_hash_of_signing_key": "75468b91c72e0ef999e7ccf66553690712ee57c93440549ec5cc4754a8967228",
        "message": "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",
        "signing_randomness": "8e128d60e2ecf0925ccd6440e04217f4b6cd4ea12c1f3066ba9148af96d2806a",
        "sha3_256_hash_of_signature": "96121be07a8631a6c71b414d71fb17728302cb4a4dd4ca9873a151ee31320549"
    },
    {
        "key_generation_seed": "0531b4105cb209585f9fbc29caa57e64c2d40f0829931a42caf7701717d9096e",
        "sha3_256_hash_of_verification_key": "c35756d06d6a96c9f2b0cdfc3827fad7f3eb9879d84a4149ea277789104f1d61",
        "sha3_256_hash_of_signing_key": "0bdab3a05996c544defda441d85830a9af4dfca6025d1d134af641ac586de6a3",
        "message": "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",
        "signing_randomness": "8ec405f4b0485cf9e3de3bf57f23727d0fddca6f2eb0c91d162d9d5e84297980",
        "sha3_256_hash_of_signature": "aa5823dd467f06db228145c7ccc3fb901a240d9fd58f3b98e7c8b8030d5cf176"
    },
    {
        "key_generation_seed": "7f8515aa82dbc9ec8cf1ded5ab58ec0d08cf686e25a8c01fb1109a3c68d19e48",
        "sha3_256_hash_of_verification_key": "89db807a9aa86e4e11e66106198f616792f20dab90cc26669d4c0b2407f27d20",
        "sha3_256_hash_of_signing_key": "2ae15d96a30f990192412dd03b1b99b5f22190bafc8e590a70205c06d23f6036",
        "message": "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",
        "signing_randomness": "234ca1489df44ffa34042a77d73748f1e621eddfdcd2cd35708566b941a1aba7",
        "sha3_256_hash_of_signature": "0d0e0c5bd96d003a4e02e22aee3f347b593b0cc74aebbc3df039533b8aab956a"
    },
    {
        "key_generation_seed": "5af3838060e0f83352a75a0ec4ace2ce8ba119bf89f34cb4d6b8e27007cae7fb",
        "sha3_256_hash_of_verification_key": "6d6256f1a50d61f29a400b5cc62ce8c80a33207b6b576835c528f5049edc9f2c",
        "sha3_256_hash_of_signing_key": "93937c31853d8e8d6b5772ea4085ec8a7a0eb7f78c91f5d08408b646c22caa9d",
        "message": "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",
        "signing_randomness": "4540537cdf98ad35f5bb40da1dd2e0ca2340d3b3cab1693200afa0104fa5206d",
        "sha3_256_hash_of_signature": "1ed0076e695200db0b102c351d9f4e86e0d2a28bc9b85a5333673a60f697cee5"
    },
    {
        "key_generation_seed": "b323d48b567f7effffd47a7c9abf0add5f11141737a8af62b56e042ee498ad6e",
        "sha3_256_hash_of_verification_key": "017cde602ef5b05cc7450d45ce69d14aab9f21fa8cef94ea02b81a65c2586ecb",
        "sha3_256_hash_of_signing_key": "0a5fe2f570c2b692d0746a5a9b895dec3b701f210a021507c329fc00fd0304d4",
        "message": "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",
        "signing_randomness": "627ef60168ef6c8efd1cefb403dee572635e57fe9504c647a4f9da5bbd5b029b",
        "sha3_256_hash_of_signature": "7f733c8ebb42840623ee7e516cfda8898cb89d4372e4abfc7fcd1c592f84381e"
    },
    {
        "key_generation_seed": "c1cf3107ea9b283419e27dc563ecce950bea78c048a3f49fb42128819959e51c",
        "sha3_256_hash_of_verification_key": "4ad012bc9a3098a1c05d94c41db9cfc344c2e87f18b047a50b3139d3098f89b5",
        "sha3_256_hash_of_signing_key": "5cfe77a8860455ae39d889981827f5037e12b99a1a2c55aaa6c15bb580c2af96",
        "message": "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",
        "signing_randomness": "e1425191d9b51a40f04e93babc2c98cd6a21745a48bdf5745bba964527075185",
        "sha3_256_hash_of_signature": "69f9c46eaac6408cbd9b727f90ec0c71e31d77509f1ecf6a9e305da2b15bb339"
    },
    {
        "key_generation_seed": "a50fc40f0d9efa5d254943dc599f7dcc2f6d197a4d2666d5d69cfaccda560817",
        "sha3_256_hash_of_verification_key": "a363fda8ab50e3c28a60bbbec1c422c4c027e7035ba07a863ae753093a7f6e8a",
        "sha3_256_hash_of_signing_key": "e5e8a386296ee78096458b3648181dba7efe749866839b75ebec34736f5e01d8",
        "message": "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",
        "signing_randomness": "6601d5036d7237da65053579c4fa739ed41e174bd433f3f0946f691fda702000",
        "sha3_256_hash_of_signature": "098dd8208b78f470587de3fb620023295dc385d8edf9103e0a9024463f0f40a3"
    },
    {
        "key_generation_seed": "4c0f0ef1ca8073a562d5414584edf268913d53d5fb39fa639e02e900891ea82c",
        "sha3_256_hash_of_verification_key": "47662d6b7e0538c46fb19a8498742b1c93121557a6672dda42bcb58bbcde05ae",
        "sha3_256_hash_of_signing_key": "598c4e8b846f65e5a7b84a90cdb5edeb3ac28f205bdb45e73e6f38860d2cd19a",
        "message": "5180b7de9a84f651da10d334009b3d65582f3912d329fbad4ae39a9eec78943338c29db4f49ef41e3c50dabbb530e99113440383f20d5a3a8ae279a6201a0c84b003f6717c709c21ae893b6e412d87f8e0cee5a89e60a14ce975a4d42e4f43f4710fc9fa29e9b2afa93441ef5570123aa88aff009e2507a3e60a79cda25652e3ac3ac0c10a816bc04739b6fc758ff9ac467879bb67f270e4eab43f10a633e5932b8d6dcf23814de8643407b17b5e2a91b340f7bf6882db694de4dee4c480ce037b9f9a220acdce84b03746f307a6026531d712c0630e7de3add3a8516ba602d2463e3478008b3252b658fea54de41265b5c81e4e913ea0e2a63309497abf961ec40ac374adc0ff3c6fae9bfac5cc2df475885b0bc636702828489183cde1a2934f2d63828ad1f2b8cfaffa53151b0ffae6224df54c2ac47cc8844b76222c2a3b6e132071150049b6e46aa75dea28c13477980315fb64ce500bf0c6f633ae621d65b331ba96cfac162dd7897b8505257e228cb621bba9176a7afb3a2cc20d7804ddb3aae4b87ffafd3c8dc541d05624db02bd62491067ec1cdf73147014febcfa5b561756d5e7a13b88d1e7b2c0375e1d0de71ed20ca9cc4e6dacdc579f1ab024aae2a0bec9004e5dd81c046f00a2a4cb767c4eb240d205278cb863d1a61def16635c6a84c2406288410fa4b73b21077d8f7a4075a1ddca3d0d334725151e434bda80d3e73593338b07958d27337e32cde0010dfe5e58b99eb27a97dbd1c5e6f9a552a02726aad5a4aa63edc336d83e5870dbd514193367af2274804628b4eedfda3b2a155694e89f5a6798c5d6e036159c1f00d8dfb03d41940e775974b11c3fe4456e07b127ccb44e6fd6b2918f57a6523d7f77f32478d9f1bb539846793d4284e2907830e5ea76054802a266c85b122a389eaf4700629036716e2869c0fc9440856d562711e903a1853bc68582a95344b612e5cbc7c5b2aee23cce4161a75829b2048742fbd65abfe2397cc7d66023de34df4f2df8540cce9781ed6482d29ca4e906716c8cc9596b158eb51bab8c2e00253d6589a99b3d20fb494834b42bbffb80e7b0441e356b541f83877736985f6330ea459c007ce8bf18d84e78e36482d581dc7df97528ce15f68e604b4de62422b3aa76f3e7e5b33a49cba9d89fcf50deb65ee45173795393a50fd4c60cf6becba7e733513537d13f89fcf1c4d6437de0eae608fb11d68b9adc0c3a19a3565f6d62ba81a326ec334b239b212b87320c03a75c58dc8f828c4195ed9d7acddce493123e235d098e9dc60f5d3a625e1ff66f245e9977f9630a40d26e3afb6676f5122a88ce5507bd825757d9ccd53fe574fd0e6e728da355403ad664ffdeaaf636256fadc3283d6f15b297f79216833cf2c745c4c5e17d03260a69178f2216168bf8f00c9889e1e35540254f150c587a884cdfc9e5f7d379be474356c06943e416eb0697a1ae989ab4872d0bdf436d9ffaafec1631c9939fcecb84db2846f12ca395f506687b4a5638085bc6ef58fe8e2abe9f8d51f272ee855e2db84a89d348dd66950b8f43939db897c519fa302594fd1fbd6b6e94ca8ff63a7949432dc2d35c60803a570b1dac95ee0a60c62fd18b3319601ad29a156400d392dc9a14ff50af6752c1f6edc2acb7ecca71097b6e82227de429f1a29c5e38abea1c74de06e6788cb1790ae9f0e8ab35afe60b001f45971d42949263aa62519b0d630281a4c5788d5591b1ef5a003c58987e8665701e5b1c6063f93533094e96820f918c354903775ceb6675c4ce9cf940c4beb8845b4f5e1f642bf505821e5a23122e2d1adb82a63ad18cd1e4775a96ca9ef9493d75ff784a2d4a99f54dc3f87828bdff4b3a3d98fa5a29b62a85caaffbace4592a81bfaa5b8bae6606ad25a92a43140690a6003aa2d617fc707a53ec9d868e33596e098773942d798263f58fe5a1b23046cfa136ea35203b90bea2c5f0aaeb5ea8c24b8b8cba14cdee28f45d0278f193228484bcc7e08a75d0064d605d674aca9019a0a9aaecd6ac672cb8410fee4192e6dca7855fbb1c584cf288bacb40707d7e6f8ba2956f6d099f52bc7b0ad72b5a3ffc03c7b47086330244ea5d393c6b9f256fd82d5cb9436a469acc3f8fc237146895be148749f82d39b7ba4ce47715bb393a96ab471665529ab9e9958b12396c1ba7529dbf289184ff0f635c2ba9df301036c869d52d993463222b70ba778e81c8dc668de41c0356eef5c39f1bd42398bff30f959e115c6b386e73f0fe28a2665bd463c781da1c46d6d4ea284b152c8c12426dc9cc467809bfda6fbfbc0bb4793babbf6ad564d57ae9f5e2b7f651d6ed980f8b1174a126cc58b23c32ba73f5031b3fcabfe7bc360aae412d799cc14d8b252d9f9ec9005b7fca04a88cc8ae9f7aefca94137003d5764faa3c7c45670585c84f74c4ebd1f5ad1f97ea093595592fb90e3cab01f98f06e114f13de67cdc36f3ffb01c3d51ea643c25a3f6aa2c57690e42b98583d925ac7b06a349782a1d33c06bd05a82a7aa3dd679326d948d74a1861926b45db78d36070d3087aa9c5f4f42ca57ee9ce7035bd88a85ce1107c8e07e5ba3a62ecf012bc75fbf97c4c72331b55ab9a6effd78869f1cd3f330526f262f7dfcfa2b084b61e90772d5fce8f038c0f72554467192cc8a27f1f53c8714da1864815974b00991f466648478c5f9bf036dc4083d72e8d144ab10fd32408da7677729347febc79e48e7b87388d9b59aefc84b5b3b589fd91863811a6436ed76b43e657f7ee03eb796285a4d93be9aaad1e1a1e81687e42ec83f3dd059b78bb7f8ec70e6c831db5e90c6b3aa511f36507dbc8e7a77df0f5b9ef03bfefe9471de7c7fbe67b9922260d3703d95a5bfcbcb62d830e20c23c6cfddc210e47cb575957d8c3514a2ed4561c738928f210057896eaeb1499d4ddc70f44e30661e780aaf5c0a20c8553f40d7d3ff6d120511c1073510d04f2de544121ab851e98f666906367c21302eefb1aaa723f6a531c454eea0be7d50",
        "signing_randomness": "fb391e8f6b6c6cf4e8e20bcbe3ac3e06718ee1e191951b5fc97a74eb1a51126c",
        "sha3_256_hash_of_signature": "46955dbab8672ec664818613d82c3e30ad0e67c6dfed43b5efb62b53b7e0cb8e"
    },
    {
        "key_generation_seed": "5ba8ad9b66c93cde7e7e616a97fed8aa91bc7235fb4db086cb4021877780c6b4",
        "sha3_256_hash_of_verification_key": "1a44dab0c38a7bf802730e1946ef8fcb0fdb89dbf72bdac9929981e64ccdf665",
        "sha3_256_hash_of_signing_key": "48e83fab2ed0c0de0d4904d7da869cc7c84960f389d75bcd336b13f07b101245",
        "message": "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",
        "signing_randomness": "e5580b2a7b9d30906d0d6d9b88ddbd8b5a3ea18e231cd8e8b05b35bd03a24695",
        "sha3_256_hash_of_signature": "aa90178fbdd8c00b733ae8987781bed28ebbf9474f3b3f00a9dc373cf593e449"
    },
    {
        "key_generation_seed": "25d957b9bf68326d2efec93da464f43e3df16dd6571ceb1ab68bd58e87734a51",
        "sha3_256_hash_of_verification_key": "c49c47d2286ecefacf1f7d642df907f748b1549841982dbf182889c4d1d30c08",
        "sha3_256_hash_of_signing_key": "bd5416a304284bc092ad7c8326944b5228d065856db4d47572c692b075623ee2",
        "message": "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",
        "signing_randomness": "6db925e3f0c18153a88305735b7b63fbfbbafda43d53f6db06b50acff0d75bcc",
        "sha3_256_hash_of_signature": "20618e11ceaa1dc2dbd5f6e0b3373fcb3c84ca39c6c5a475d7581dbd14a1cdfb"
    },
    {
        "key_generation_seed": "24f0cd3b05d964f82d3702bf0a613139808d49283286294be57e13a983c3c961",
        "sha3_256_hash_of_verification_key": "fd25bc085c31489f12e4ae7ae4cd90d28b1c92e04644cd3e6784c3c0f92b403f",
        "sha3_256_hash_of_signing_key": "c859646dff683329cf4e0e72878d415708cefda8ecad22deb30bb803b671a192",
        "message": "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",
        "signing_randomness": "d82adc2be24134146c202bb857089860941df6b4cc218d016a3257520bcb61ca",
        "sha3_256_hash_of_signature": "c1868aad502967dfc6fdd5259e7b7f60b4b977330481466f80dc45057426e71b"
    },
    {
        "key_generation_seed": "5ef2732b63a1cbd2cc239ea6fed62f7feb3102715a5bafd8c83aac33702faccf",
        "sha3_256_hash_of_verification_key": "ac48c3bf7f59c30736001116e54c97857efdae4324f0bdb12b2a34357db4495b",
        "sha3_256_hash_of_signing_key": "17c9e6501e1cf9c876b6a400f88dbe6c9ceca2b3cba1b5f2389d42b5f68a670a",
        "message": "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",
        "signing_randomness": "a4fe2f6f39d216be4b44712577c349cd8c58a9ea3c9d73926603f8d86c4b6c4c",
        "sha3_256_hash_of_signature": "d9a42e18a617ff6475996044b8cd1aaf09b97278fa43a5769558b2289aa025e5"
    },
    {
        "key_generation_seed": "6a27b1666ab6fc4483d14cf84ede49fedfe05bb24e008ae8a01c52d83b8d40fe",
        "sha3_256_hash_of_verification_key": "00522e2973d622f03ca25b36c20afcc812713200aef3561fed37fe131e203b14",
        "sha3_256_hash_of_signing_key": "47bbab33932020ff2e61ddd4f58b79942f34d2bd1ba3940c37c4bb621c669d5a",
        "message": "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",
        "signing_randomness": "257dc9807e7f9b6bef97dfaf0f83be41ef3cf3a97ff5618ce44d1360ef2389f9",
        "sha3_256_hash_of_signature": "f6441dfe3523b2fc9191bde5b37596f3e57d4131f8cd86011c668637e04149b0"
    },
    {
        "key_generation_seed": "2a855572e7e2add2888022bdb585b61577a75a31aa8acede59acb27eeb2936ae",
        "sha3_256_hash_of_verification_key": "f4c8cd2c1f03a68f45343b92254ddd253031fad1a96aa18f0fea5cafe9d0ffa7",
        "sha3_256_hash_of_signing_key": "87e5d8e540c41e81dc735d70cc4fa839f771f7af8e8509ea24627708d0933206",
        "message": "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",
        "signing_randomness": "a697aee697ed8142be668bdf28f92c4d653b3ca0100728c490ff6980ecd15308",
        "sha3_256_hash_of_signature": "12c50ba1760eb1b345db8c6708d3831cd0a75539155d4c159bf6d4b9f66e7b09"
    },
    {
        "key_generation_seed": "7967e9de70a7f95e69371f812c2fbf932cec07ab4c235ae9e8a6799f3f537d36",
        "sha3_256_hash_of_verification_key": "2c899b4959d0f65a96102ca530ce36629b1a1a705c9dee9c218025e0d823d478",
        "sha3_256_hash_of_signing_key": "3f87cda81be2e7305f46f676f7b6f0cd188cdf0aafeece73a50323ce8d403a52",
        "message": "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",
        "signing_randomness": "b289f87e11a5321c883ce48f016495f83ccccafbf4b4d428aa043305ea04dea6",
        "sha3_256_hash_of_signature": "9ce9b23764bf24ef83d7caeb3613ac72dc17a9dcb54b8592533e3f21518c194a"
    },
    {
        "key_generation_seed": "5aba340a8e541568fbef49e77f94cfb4b3a5e9cf14c6755ce6412cf86cf62898",
        "sha3_256_hash_of_verification_key": "e5cb43b52572502b1ed6dfaa675b6b0073ef32fc7fd3df5837f25d9c0fff69c6",
        "sha3_256_hash_of_signing_key": "7ec80af54ae1cd5fd8694a7e1bd3d731b55f582caebfe0e637419dded220bb78",
        "message": "efc63dd588a7230ce08efcfeea534f5a0eb005480ad1d169c386e476715238526e936fea7136e2d8aed60de31cc91dae4e764ce5f93624fa7f72b87562fb6ad8996b5e41fd478af0af8338a7fd9aa250efd2f2d20364e8a88a8642e8e38f38583abf8d3be97f14c3ede66ebf8ebc84385cae646cded8c5ce8f06910ba7fec05d828446d558d6fed766fba347da2e84da247c34266aa31c328804f4e3aaf6acbb0ad50feeccec00d20b3610785b9f1ba06a0badfb42a8f43de3f7bac36057ee0b4d2a15db040a8903f767f7352995c8fc3e06ed1b1322587eee5b31806192e04b09a7b433d08cb2a340942cb75c51e0f8409f907f69c5f8dc316a227942edf7a458974fda76c255ff4f1a85a352cd2cd2a21507e0f37451060d31d0847528b3ed5da3e7168cbd0302f1b03842e63b3dec6fb37357e37fc3cc26721f290726a47ab3d4dd8fd1778fe5133726c240e7b3e398f3d809c6c469680b9efd25dbe890d6936b76a52f97aef3f93872b76506a95685eecdcbce203400d182252471b99b7f4c6ced4cac8faca7682d0df07bc5904aae042479855098cbc41534f0ef17f38f1bc8c272cf72c1ac4a5564dd132130ee676e7d7ec3cabb4e85ac81945c87de08ec60ced3fa0ab3e83c18ae493a851434bfa2c4968b42acccf3609539c62a4e01f8bc159362e15ee91d8aa399d8bd8d67ba1e8fd646eebb4583812293406b05ba5be2b1df9620e6fe3daf8cebd9652bb04494b899f407c7d9ed1c4e77ffade24abe56ad597bd438928e05b0363d6d2685d34d6b51d71012844415c46f13181b146a3af25ae4e8853cc7c7ef6387306c45180a6ef9e97abe1e7d5e10115752c3071b6a213367e8b1a3d1c3703cc1840735315623901d772c61d55ef8c47db10f0eb7582d7a043018dc1363e93f315dd984b8002ea7bf5bed38d3f273276ca577cf99a635cb6ed9d6525520793405be27c86e6effeabb1e5f84a0076bd151cafc59853424de4b3460c673b0820d76e15ee47b6505d2d5c179db92a44042f3631c646d350ea9721b8984660a76018dca5c6bb1223cd03cc844dc9371d32549d9d645f75d2683fdad1df6434bbe43200e506ed2a815fab511172c70f99a85fa3970433e8955b2f9389f23c10141b5779a23b8671eae8b91991b78f635fbe8e627d3e79d91fd1e6e90699640ba3ae8d7e4cf5145f1259cc76ae50b1fa150d8338a9450a5b6b90eec9c94318bc78c9c7715a3eb215aee6443540d211a0556813529023e5a581623cd6d19bef0705a5f69aad4833a57c308144e92899ac5683147cdbd279d5c3a55bbc5e8f8e26a158a3e42f8c5b858909b024b4ba4069e26de66460ff4a7dc92bd54ac244007b6ac6ce07a31a2af3323cb55f07b8f480d279308fe10f2ddb001da6c4aa132b988ad03fb63e0eb06544571f5505cf377a81153d6fbd4fa2b7562074cfaf587ccf28dac84afa58809c0b296e0d2594d3582c28596f5af7500e143be7b49c63d04f49bbfbdf60b024daba5533f945ba90659758e06984921efeef79604059eb808c9fe1bf9bc5351a406fbba7f5d8fc9f891488e537db14b216a0535c9ff7bf8d5c68a2453a8a48e58fa7bf6eb76448d6d0bd05bd4628c4b852a236a11bec0f67118f1267ca42647f6f2303509094c9a7f3a07b2724abd2d9b56b71fa7ac6cdde456ec209be76c419855a5151ec9ebf0e0cf1b86f4e8e81b8173960f8d1c8affed1ac7b818af8e3bc092e2b209d693e80b11ec7da39ca93223e1b47c6127e8ad40a78bdb0ecbfa1f39c84cb9ecdf960abb39884627bc4105c53ee7bca4802b92af60241420cbb36c407f46cc2e953d7e3503cc82287a8d68d0e673e212173d80a12257add5256652188c00590dadcfb7dbb6b35507b853ea5fad4f52e02230cb3d3bbdfc43eb74780583e8dbb851e0257117f4a39a6676586216220c1ca21de16cdfe6e1cc99ea7c989916ad2fed4a8373cfcff02207529bffcb7b7601317450bf430bac9ce111b0fba8d7de6627f863078d8e6286b2d34856426ea90ffd58705444d0dc12d4feead0ffe543811e1ef306f40939922563832d06e6dea7109087ac051a361ea9e755856fd4e51388bc7c40c63e0953c8413ab0cbff70c466e15de5b089d095e8ee8a64e929d26ca3b71ef0b2360aecdfa89284cce08c666f4e0146362f0bb84b87a49fcf2324ebb96dd941f00e2586f7246436eb66b1e04af84482d8ecd2bc8ef9955cbec62afdd754a7f235c7f3c41cd0b36a9024d426b7388d3c33a5a6e858846c0fb0d88ba5798c923f9b43d14a6661c65092d5c5ec0f97d84784fa336ae6ef57c7a5d04804b96d19849ff9074724a5faca538e32c6efaa5209317543159272ce50454fe1e7d068c8f5ff3797a66d5f87758627ab5d40ebe1fb7ce9d69287ae7a5f349a5daabd8a8e7778baa26da0eb237034a3366448280237a165cbb303be6b33c0f11c1e56c50a84384a0f6878f2a99b14cd3b6820abd27d2011e0c37f8439bede65747038a5ff7f00daeda094331523cdb7e10f1063b64a584d3e9f0655268f89dbef3ea3fa4c6e54feebf8f0046c6c811f0767cf6fcc9b3497db05582774047a8dcff6a0c1b5188076e64a9d5693195075f2a05e507a5a523eee4537079f9e5e79210e4af056d6624d45a0eba553ca9bc92171451970102cab57dcd89acebbd7025008325c61145264f42e4d14a76e5c2f1c129d4c054da00501081617d1a27012a6e160750dba73becb5dc05105bfde1f1d0cdc837355844b291b09015fd610628513c1c86ead373730b99fcd4a552fba07163ce9cf6a3d3ac0525593f0648256e8b33fbcf92af58ce26d0f036e11230879dbb789507bceefd2960ea320236a224ea74dd2aaac541664fa3ea9430d4fb09c878169a8af1e7fd4be5e7926cb0b6a352b25f452454474107286edaa145c0a0573361522eacb618dd9c8b32bd1a8a5923f4c698cca0139dc640c1d5d557ce889bb69ce32d85853dfbb0f34da2cf18cc79472906b67f6bacbf287f31de0b9e7a01a356ec9b64653cb922501ea1eda940089ba0f293b667f482e92438805cd6851776cea0920cdefc4062c9b4e51f5aa1d7ff909cc2608b6f28ccf28d574bf67ce80d4ddcce28f2ade0162cb66894b5b2da0eb975cd95ee7fe72fda2736616c8b571fac94bf8c64acd1642d9431118f08a62328d99b2b9d90bbc915db764c4935951a59c369c72060cd9f4273bdca0c295294008c0ac3a149e8ca5e8bf21042f5f21c067147f3bb52b13975026a9df7246afb1d053670982ab316509f2850342913e1322758ed89da02dd79126726b1c5566c1831ccb1d62b3e271875e62cde0df0715d404f95f580b63923f362d416f83fe5ad98eed584717fbc2cb7d1b00101200f4eb4ca5",
        "signing_randomness": "72560d4af60a2d3f9f644d3d90b2cf16bfbe93708b9aaba4d5180c1f10ad9679",
        "sha3_256_hash_of_signature": "4336fd5277453b321f1df6dbf2450c4e4ad252280641780702ccc7164b2b848d"
    },
    {
        "key_generation_seed": "df4853f482cc1d0b3a2d71e9eaca064e57c5d100df79bd004ba81b43eacec401",
        "sha3_256_hash_of_verification_key": "037e1b782ab5515a3911723bc426bcf20df5056eaa6899eddd7896541ab8109d",
        "sha3_256_hash_of_signing_key": "df53fbfc8be782a7bba6db3186b07e170cbf3d4c3a22417d2879228836fc4f79",
        "message": "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",
        "signing_randomness": "d69ab8dc675f01cda87b86f4b9b0371ceb1f1e861100d21bd22186263d4e0e6e",
        "sha3_256_hash_of_signature": "af8ed6a96fd9b506c1147be7e5dc3f44f961552f9d7628995592cb7b65015779"
    },
    {
        "key_generation_seed": "95da16b844baf559c2cd6e68b237614bb9927d90811106347b5849fee2f48640",
        "sha3_256_hash_of_verification_key": "1b4696b07a8ec6dd8451b1f22aeeecf803a4d08bf74fae86621e6b1f5741392f",
        "sha3_256_hash_of_signing_key": "b57b5bf6331566dd2f9e5bb000205f3d99f41f07d1fee779422dc6e61745a9ab",
        "message": "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",
        "signing_randomness": "88dfff7851225e63b200f8ca04c7df429f671c2f1799907ec4e04f6aa295fa75",
        "sha3_256_hash_of_signature": "2c4f6a9be83260150dc14346cc598f1a9353539e63836376de8e8e58a845aa47"
    },
    {
        "key_generation_seed": "f258ff1178cc42a3cebe238c8418b4974812a05f43b8fa95639cc46bc0738bc5",
        "sha3_256_hash_of_verification_key": "94452f3db47d1ba284033e9b8b6d5861fae398049bfe8749f1de5f9ebb4c7e4a",
        "sha3_256_hash_of_signing_key": "76db4e34f28ad0de94e76f48d90356795485a5eefbcb0c5f5e9457f67dd3c53a",
        "message": "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",
        "signing_randomness": "865525fe521f48e2591933a56a03988713ee151a81f6952d4640cfec738a74b5",
        "sha3_256_hash_of_signature": "3bc1888069915574f01c31c4c2f55595c54af80511dae00e8a81dafcae9562d7"
    },
    {
        "key_generation_seed": "5efbbbe99cf5c2b6830fb8e990250be308e662200526889ea973c8d33823ec19",
        "sha3_256_hash_of_verification_key": "d7ecde4cf8e75b051fc15383856bf36d33a957c3b0c6512e4cc838125036f6ba",
        "sha3_256_hash_of_signing_key": "7f62cda485681a08b0aed83a92d308bddd8bc1ae394415c9d5b373889f7d9fa0",
        "message": "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",
        "signing_randomness": "74de74032fcd57139698e7b190efc6fdabb2fe369a05cfe73074321fe0491018",
        "sha3_256_hash_of_signature": "79201e52cffb4aaa35f03d9e421cac0f0b04410152786fad3c6119eafca6ff01"
    },
    {
        "key_generation_seed": "47a048d8799784f6ec385eb984e70c62ce7c8a107232871b69b99f7bf4c3dbb5",
        "sha3_256_hash_of_verification_key": "87d2a85cfe2d0f7566566984ac429b879e64b4d31450d508b486efc8991c5944",
        "sha3_256_hash_of_signing_key": "9a2f7e1a7d106b5854aaa55c0fd4ff1358ac1bb1bf35d81564cafc5df91e42b9",
        "message": "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",
        "signing_randomness": "f76224f0024cc75ca18d75487e0edd88518965dc6dee53b98341db6894165a91",
        "sha3_256_hash_of_signature": "b3db75251e97f98c83f1de20a8311018dbc38c571e18dddf638f012bd16354eb"
    },
    {
        "key_generation_seed": "1d9e243a35118bc7c50a50746e1cf19c9fc310c7d54181fb95f44753eab1b94a",
        "sha3_256_hash_of_verification_key": "8be87ca63bd1de72d9c1e031a2fa2a5458059cbdb1c051db033078ecdd1ecac3",
        "sha3_256_hash_of_signing_key": "9642731178df47e306d40e0f15d70bd62f281a9a01746541d45684896f547111",
        "message": "96ad5faef409b8a4c21acb1acb596badf387d26656be3eb17987af59737e324b7bf8412a306b0e706aef73d79af753d9b0064ba9ced8dcea966543fe748e2611709ecd1ce6e4dd8fa812d485e91809a225936675369574b0d104a258e3353ee0e021683615ca5c7c531fb29a5025cc7f7323860443dc19c9858f741eb9d24a9f6f04fc839b67153214116e8b7fa982f338445830f915f7c85c88c23ba2a3ce8e2020a9d8dd7b18efe95563e3924d2a341826af51a8584cd026b1c433ef0221145ba8bdc8f73a467b33a9eb3e8cd2a4d671c17d7c28aaa539d1c5bf2f4138639afb89ce791daf0ef0281d52598f4c13d210974cfa1f099a0fc70b1dc120e5c00c33a2bd360bed57cce069060d6380be2204852d8bcfff4918ba0b70b0bd1e1d55dc1d68db1d20ae713b0093eaefa1e33d40d9bd95cff17568393e9bbf5cc1287325d2668f65dfcf44ace2f6c6cebb62f1433e69cd19e6c6532ea93682b22c4c4a62c6abcfaed08ee64f32723e56205222e4ae0831ab8fca8c265fea0cfc66aab1e367201752aec11f752b963792c071e42a8a1ab80658a0c6960147ed740cd07f307cf6a644a98e1d2e56c625acf458d0bdf6216a4f1b9c78ec3f14850c803a4207c894e61a8aa88840a27f2b439fa7cbaabbc789102a95323e06e2c324859db92c6ceaefdca389f677082180fe3d6202ff60dab9f87e3b84841c0a4eb5974d893333f7f1513e54ea4ae0731ec409f69b77089fafb121300042880ea59b7927e9435eabfdcc1019a96e145d5d157998d620e7bc6945dbd6cd78e94c2d89589f8dc8a01cf1b295a26b091847f034937f764adfd811f52b3aa187f3f49273eae5949ff34b64bc86ff11eefe378825d526509483e7191b33333e5465ffb025b269f898ce1f83ea549f1864b556c729f510118921b69594f67b8c229236ad3aee55bd7082e027b5d342c976a549e01618288944de0b2c77473a25201b61034b334968178afab7f8cd1feb6a25cf8dce3586ffaaa861471e2ee7f0c22538fb3c95d2145965c4673e6489764ae24b4f048ded77fe3487ae175f6d4898f69f9fff276470a93daf986a75f685919d98c9c609c795d4785ae941c782b551ef382f47209aadea19066ae5d3eba7bbd99e91943f1e62754a42ffc8048f7b87f128ccf6c96bd760b45f07f740e94491874b06cc3450aaf55bc664b407c57369cabd2708a9c478dff64d292d96ab71eb997f8b71cdd6ba02f52c5035ec26e8111ebf8268cb00df9ecd63bc0d557e2d2e77a6363b00daf25237e77dad03f929e5e9b39447a70d4e5f4b90958f312c80d594e1b1f3d0d23f2b0d9753bf3544061cf0c0f841c440319e74f9b9d15b91eba1e680ed6aab7d63a97b48c0a4aaf314e8e77e2ea6be9dcfc7b5557fec1b996a37c86cf6941325ec356ee75671726bced7d2157be8d4c62cf4bd0420baf2c4223597c0ef75f7a7c9533d14be0d21c37f06faa53ed5ee0ddb025862417f98d2f188895395cf2fe72185acbea952f55cad7ec2d684a5ab94b1257d7abb565b8c07b88c6335ffb9d2fc6f6779cc24fc3cdf92bb3b12ec54360a7cf3579632a2a65c518e57015df1c616c857f83f5f1aaff693acff210dd1e95ce04cca9a0bf385ed6ea2aed894e79d5133799393469b666209371e708d4d279e1ac5ace28985d0db2765d547c2902b715baed5a4fa3e7aa42645f3bbe1e9f3cdb87b1dd8dbb5aab08626591921cb49e552f8ebafcbcf428470719ae40b9ca847f31848f39e4d42049c5d40b0bff036e5409a6a12e7924148e60b64bb83386079b54486ffc8187302893b8bf826578d9ca03a1291983f21de7f6e65458f8942dc1b135c6c8c1fef4f3863a58db17112419590ae57b9425592ff22e596191e5ba7c513ec315ec3476c95a149f6a5ec1cf24870400fdf46217a23f42e0b61157c3cee23e7916b4475a94b96b917c171b1a34db13ad98833e457343f94a76ee226fa5b9f3066c2fd69f14d3aaed1b31f5114780442ebbc88d0de5f689cd910e7464d73423b9d4e03718c5c51871250d11e27e28df1268166e3af328a80d9d335f2d27d2e91dc61cddc7f733e345d56c11b6130875d93d527f93542fb352407185e7ac07051af7f642e34fa06b1376ba15a35d837c1bfe090ba67a89fc1e307dff3f02a988ecd48fd229733f641f2609ec8db14b1a5ac170b104f03c2509d2ee6844c716766d06a6a25d957530fd68a8de6f1753f83ec19ea2deb1a4f9c7986f20ff60a7508ded6547a85baba70577062e8144ba0496777a5218595e021937febad4bfdecac29e3fff2efe7d598fcb86f93a734e4c573e1496a6282a3b40e817dd3c9d631939aab350adc703899ee3bcb1b5eaf6ea8420dd6eb2d4f64a1818aafa97b73c75610b6005f1edc1ec7d8f8db1e5d3e9666c1292515105037d26f2c8d83fee1f4ef5deeb287cd7c1e11960218c1b8bb50453488bab019435065aedfecd8d218bd1e751fe736442e8d09ce7176a71c06415a30b070693a68bdaa5cdf62351ae665f37fefda9481e62ec181ed24f0d0649ad01c89ac422f1b7e27895e55dcc2fd817346d361fa559094b37894c0b478c68a1d7564d089d9d4417d5c7372a33ba475a81fc129f3259c5407bc7435825b415782cc84d85e69d9b44b32d78fa255a895cfd55319dae677ff89d93a3884ce9401775563ff1788cf3ac11cf96daa199e7f4579a0264378a323fda64fad2349c09465fb23ba09069c7fbc79e7288a82f9165268f6842e0aff0e250c21bbaeefb4347d4ef1cd51161dfd29bfaffbedf71dec93f4157a5c18995379ade8d15db59ec4a8b308c2eade1b7ddab55ce2220f3b3ae8cba7c8211cccb3846a225b438f4b37df54363a987c5c4e6b9d20ec3c0096317d11f982184b75d8effd168b7b41317d40f903a23a2649999db36caae31ba5d91998a684d30aaadbd3b1ec154bb6c92513bfc0c47c673254f42b1fa36b995cb737668cbdc2a0d1ba838e74e0e50b22fc22dd048f48b6d1e89e1ccce5a226f63ac7b8e6e9e8ce27050bf3dcd7d0f35f47bbec1caabd4d619cd77302ab4ff6f56dfbe9f5821aff2d72ee6a628daaae4440edcc070473bdaa54ccd775331ac2812fc5b9884915da582eb36f85c7923f06d961594753802efc5883ca484fc64face42de6c3105e23cb90663a3b381d0c6a7265b740bff0a1a017058f06e39a74bb07b63f883cf914fe675e7e5ad5ad44c9f90ddbe23a125d9be02264edc13972ff22ba48ece8890a223ec13addbe055a8b4e03882677fc0d94c9053da6ced34e132fd83810a793350446d60ae5dd0d174b534a3b6f5bc1b497f9406b5cdd414401b6dd881ceabab12cc51425e88a81bd9e14bda18273583cce0849aa48dba1cfc49cdf29242c73c99c87f063b8b739aa787570459c098405dccef78d6d97c21545f2959df9cd62f9c38ad9a849507c23a51714565642dd76c9103154327985f7dcc701b795a7af8625f06367adc11a7fd7b6abbda5b2ff6a825dd43b64a48ede4eff8603a82159a6011f9e626171e4593c0e963595a6e068ad05feb12378c71ae515a82c293eb7d2b01b333cbc7991b44685aa7513b3a58342ba5d094b773e6a27f8582f3dabf54def59974cb8a2499369b5b64c7ac08d32d75fe37371c578073dc83b82a828dfc325976ff282d3f6",
        "signing_randomness": "070ea4fd2436b311dbee24426f43a86f263cfb8706873a4454bc5a75c5575b29",
        "sha3_256_hash_of_signature": "0792719c4a597b3c874ca110be62be9128e54c76243a91f32b9e40094f8e446e"
    },
    {
        "key_generation_seed": "0a46fda6ba71125f3415e8bb6c2d8c00601107fa563e7f6386486a88f87701fb",
        "sha3_256_hash_of_verification_key": "ad6ff6dad23c86e77f2480b2b0b265a521886988877fb9110cd1dd63348903a3",
        "sha3_256_hash_of_signing_key": "26557114c4bd9ba162f9d3f588ff290e7a28b7711d68a0539282f937f3f1a66f",
        "message": "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",
        "signing_randomness": "5d6c5adca2bc4003ff2a26a67c7b7627c67ccda8cc493cf2d0f782b5e25bec3d",
        "sha3_256_hash_of_signature": "2084e015df7e0e1397226d5902d0bb11341925cc874427559c7a02d8b26369e3"
    },
    {
        "key_generation_seed": "5229dfe11090effbe94ee161054cd5ff58b31e23f567b282db42eb1fe42e44aa",
        "sha3_256_hash_of_verification_key": "ba527f9bb898f35079db43a401efe30bb6f6e1b76cab72a41314d37d5d457311",
        "sha3_256_hash_of_signing_key": "152087095d32881b8d2bd0bf0605c7e53055586abf3cc7d7158b3eb8c78931a4",
        "message": "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",
        "signing_randomness": "ebd1c6baebec97f440195e3be0f8d98ea95b323dd3ac532accc676f6aac784d0",
        "sha3_256_hash_of_signature": "3f314de412aaed511ba8d7b4120a8ea79f8b5a9668c4ae904886bb1bc379e7b5"
    },
    {
        "key_generation_seed": "18aa77795aa6d7ade8b6cdced81a1959a8329677f042283dc8ca71e13eb3adee",
        "sha3_256_hash_of_verification_key": "bd09e4b8a16535a3b8a3f153bb8ff24100a48844bc95aac7ab7f112651b6d031",
        "sha3_256_hash_of_signing_key": "37c3aa1e4c0b5bfcce2452c5c8cfdf312ab5a4c487d7b27ff6406b8cec5ee537",
        "message": "63ec08b711ddf5c66036a13f574bb7be76445a1d1f83c7732b9f4c25fb9e799d4afa55817bcb39b974af92f3730767ce7d863b6a3406450dcbc5e0145d10b7d532da6e80196157c38d1b6d3c173f74d67ad8df24ecad4d9b59921418863a38270b982c4392225edd1845aed2199e2c38b36c7e0e5d2f3cc7f6803926d977c59ecdac67ca290658e72bad633358fcdde2a4b9c40169a0c7cccfdd93e4da3c3838e9308533bd468a9128c5a141c4842840e45bc8e4610a7c5e7535834c5ec73312a50197c76ae984b3521883f549be04e27d97580e6d85d0ee84cd0b8c65bfb1aa005c607de82da70021f8f90b7912c67dc5657e1882cfa6da3de1ba4ed823789c052649debc9085c74528162243133a6ae5c1c6bca3f730525b167d816485e40c208affa8706e3d74631eb4413032730a7647548b77579323eb03d36c2ec37d2389d4a17305f607c78f3073a2f4b4395bbc94af163acbe3c990306ba3f89af9affe785c3f6d102fb2bd55f0c1044034d6a871293b31a1b38e383cb926baf3ab4b5f79a47e9fa7b77bcd58aa35a7f16ddd11ff642069a8a327dfa800049babaab4afbeec9fa98adb9796fbee925bb70ee9e96540436e1473e3ae4c56d7099d8dbdde755a7e101bcceb596b9415f52374c8a3a73ec66b229dfd8cd7ee7d2cf1c5e7f490c7d9381d9321b15f84f640017851eced1dc80d32da3a0a57adc3ef37e021031866e278c7d51ff5ca8e9ecea1082423b41d772c5adc61a8c71c3d4caaaa3433928d7931ee715875bde2bfacaa0a7f799b45241c21bd2ece4a5944fb6890bf24908de58dd3c76173373254a36b0b2ac7d67926948cc0136dd9a5079d776c297fb6a585c290d5dae1c45e91153299eedb731e527f0f62e83c1e93c75fc74f9c7e63311562b0a55459a0d41e034c3af637eb29bc789e5920daadf265f42f2707dd1ad490b5f8a8d24a9968bff11a0c364a779ec385a9a33edb9cfc7dbc672ba60ce5f421b40634270b982d619f8e7960d32e1b8a76cecd13a3b0214dd34214cb5bb7fd530058d5de1fb9e4e88adca05926ce1f5597100f55dcbf64d47fc177ff87c4bd9f6ed7670fa7b7d339edcce6fc1eae069e0c303138689ddfd23396c145b79afcf68125989c8477bfc318cdbd69d1aa6d3ee41f4b1f9be4be9fa58a072412078cb9196556ee56fb7b2a2761dd04120fcd9ae9736f599c8b96bf8f964b305530a6df1f94874f36f07962f87acc0b285eda64d2e4857e26bed40e9a5dc0327f1d91259292c608d6c6d59804dc23a34d1f9f1b69331d68771e41542fc5d669cbc3cd7f8310f87e8fe8f6201e57b475de2318ea6ef9f7d32a728a44334cc9df28df77038c37cba62ea8cc5ee80e571879ad111f35b6a154fdf8d40fc93360d547d02f0743a37ebc4af178c6ce36c92ce6b80b6350202d2978621684a19afe1474155bb962014587b1f5a477092f42bc446d7811c0eb439a6829e538077abbbf03f515f1e6ac018efb05af79069c2569d2cd7140c4b1b47886064dac695d59fde2d8fddb35318d33edad94ad4fd988095b1156fd59551f0658ee666186369bfa84e30672e4659bfbf7963c377f0039e08de2c2d9803fc12d97b5e67ce9536af12daeb3b9903d8d95f336ff53286284bfe8d7ad13ec21c2a9ba93c9a97bd7f6148de7c8cb41ca75a9ecc8f9cc68d888faf6b3e75376b5b16f41e7e6b76a686eb365365e2074fb1d7efb1b285a2357b020fd3e47b89943fbc1596f3fa8289ad844386a691f33daed4b7a6a6729526160f2d32ba7f68ae6678564fca05bd811f208a8fa62f6731f23d46027008246fd4bf3c454a39ee225245e74da5910e7937b36661548a55a2270a9d27114ddc94dd9b9d4122289df0a5700222a977f15fd8e36afa1c4870bd3ce9b658e2d83882aac5f3db814346240ff8c8fba3f36e52ac9b441c76b6f104a0931bc45e202addcaccfb93a486a7734a6d82b9f6ca911448f988626846d413d987c5ac860fcc0d5f734269aef88d41a055794dce832babb7e306f622e5eaefdbe1cf195e320a1aceb4834b3e70061ec2d624c12eb35b16e5aae73053a3290d4bb1f51ffdf48c1a7218d365db7fec15bf0f710954cdec54917600014bde3a901dab1dec0844d7ff148eded9788cc85c0cff26e5895d91c56ba6950c0ba8fc6c773ab4a6091a5de3ac335ddc2110eb0144fd89b3d815ef4a26f718c1acb5723af1da5515442a03cfb9d90623fb21d78daf441000e285e9e7c235c0f31e258e6b3feac048db652b83e07848d2e9357649372b1a55975b2ec7fcfed19d0b6613bfdbb4b5b01a9aa3128ae137bdc1d8ffc3a38b597578042cf183ba8383c289c3d92f6b70aa9b3364e9fc5d43f3cd3f310d229912e91d5806c2a11e0bdd208a2af438be77b43680e2de67918fd414338a763910e1316965bf96bbf7df639266d075e90ee9c073011f6783750764fbe4906ecdd94ee9fb7e4aedb23ee88ebfb018c44fc8bafc66e6b454a3d0e332c7a6b34c2e8d1d26416ff43d768cc36ca9d3168355f1a281a6b2eaaeac7b64aabbad2156a1d781a78a896248c56f3491a5dda8c22c231aa7ae14bd558f66e6280fa65f20b246d815bff1d3c6cee6df9b4aa7f750307a7bf73850e6bcd22ca0ad74b4afc13cd4aa2fb7e7b588adb3a46a23ec88a34f13214b261a283ae8fbce8007c6ef6be255c33218aebecd3ec27edafd252994b70bd67407620d26e8567f4c7f6d636803b6a27eacc3b853706a8d57adbf7f7e142ff149c35119a6172d5884ede7c71e6c34d1b485a684dd56c9d670576b75cacb870a68ea7ff2bb461d9e2fdbf500b2f200110265a3cf24370a3f480da66f98fb5327b4cd796eaf0e559a5519f3c643b59e3b89d05d2a9f9da6732cdc2996408b7fab5a734310fcd73fa3fa5cacaf31ab04ec0b9734407c6dc575350212239ac9092da5812137bfc40f7735bfdf9827f768fc0363fc8c5739c7df828075ea2bbe6321d5a8ea2eb7e397c3d58a953c7f0baa69a96ac8110b125ee2e9701f43eeb87fdf58a6e6266be1136437599e26e8e6e853dbb6ed9df3931c5f402fd09b7e203ab36eaa6eeae72e908bd2b9cfd379bc9b407f0c882807bbd2e91f920eb24137002a48f1aaa0cbdf89fde5c51079f1d8cf7a014207f1b40773321ad952d77ce18ec7b48f2ca054e65420c1132ab67c832ee22ffd8672803cce3de7e9fd0690e55fa1af5f11611e3e2c71ced55e3e347f4cbeb9c93bec2b98e48495585392471af0ae589257ed8d01792112c798bca5107030f207ce567594b8433490d8ff1811f21b03a42ad0678927183321355e3d6908dc1125cdce038cd0469d72458b6cc5e67eb0d78c20819c6f3c4518b15cc63754ff8679915e329dd46feaefda5249ed7e754e7bd55c75cb764b6cc36bc06267b2479cafbb3f0bae32a93558190b65c85dcdc080cd56d51d4105c5b0717691d4db1893ef8ad550f55855b4123a38d18fd67b588a3a4c2a6604e874d721359352b235c17ab1da2758712af8179ff433211b93078735f909f985f557d0de52cb9203ddc67bf9dc8632acd8d4f90196af6bd2e79834371c5e9fdf5992adb04aea186af36f56271f763acffbf94df4b0512ca6b7ca8ff486504e565bda367e044fcd0f25fbc2a6c720867f95bfd92109780d2e6dd60ce90a4ca8eeb8c4cab289dcf99e687b017b37695c3b99b4fe97d7e5d52bb9813c04d03c9ad71770fe0986c7f3a3ffd3a261ac771de88c7acdef253e5ce2b50bc5c576d132b68ccc694ba883770b80f5ed7d527cee816527f69ca2c101747a0088879c3663037db5b",
        "signing_randomness": "9f62a11e9b25ed3d43cc846b3f45629e99688cfcf09af0a673676bd209806b51",
        "sha3_256_hash_of_signature": "4b5fd5766b0ac02fcc57be08d0b1395273dd77949f39758e495df462b1beea1f"
    },
    {
        "key_generation_seed": "4b2d6ec32be9c5d8fa11f3fc0008f4f26b945064d98362ad912f452692ac383d",
        "sha3_256_hash_of_verification_key": "f68e1a59fc40fe15a32a574b795c8ac4e2229aa943b7ae7669ab8bccc9fddfe0",
        "sha3_256_hash_of_signing_key": "a2d0919196ef925812873cdea2a29491a25bdac91d8ae52a020ddc24483f297f",
        "message": "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",
        "signing_randomness": "fc6d0cf3c569484851b938f5ac018b833460575e28b2cb84f11b91ce8682e088",
        "sha3_256_hash_of_signature": "a39094f5c3d19942694cc7d9b09d47ac9315ea9f5d711be9ff5a94790e073141"
    },
    {
        "key_generation_seed": "196b8144dfbfb47ec01e96a6b8443211d6c9c4aa7853a8131b5218349bd6d953",
        "sha3_256_hash_of_verification_key": "75562961949e7f4f1a7598b281fcd521b771b53152a09ed56bf38053a6f74aa9",
        "sha3_256_hash_of_signing_key": "204214d34408d5bc4c16ef9bec0cc6668ccde4dae6600f88fda0fcc9c1fefe98",
        "message": "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",
        "signing_randomness": "1e6d32286c66aee9b6e0d5971669989bde85591faf4ebb36b343a4ec4f8eb765",
        "sha3_256_hash_of_signature": "b44979d0b6d98ae328f9ac301a63592738f66025161655c39694e86510b4d77e"
    },
    {
        "key_generation_seed": "c171793029d0cbaf8d2661a823243ad50d67f2619533180f25b50c94b1310389",
        "sha3_256_hash_of_verification_key": "bb5c997d081dcdcd514e31960226cb0379d583dcfaf714d4e25d47b172a538ae",
        "sha3_256_hash_of_signing_key": "9468f2168985efcfda3f7940d252c55f47f5f3fcbfecbc95be088efde88e58e3",
        "message": "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",
        "signing_randomness": "0b0f308ad57477b710ca5e549115be1d4ec0d6c3509bffa0e662f441f7248779",
        "sha3_256_hash_of_signature": "338e7f23e47a55b5f1b5629153e3f1f18561e951750a5277709468548a9dd4f9"
    },
    {
        "key_generation_seed": "615fa91f3d206b908649399f216950ec7b2420eb04aec6abfcb7b4528e8e33e6",
        "sha3_256_hash_of_verification_key": "0053e6abde4c5422ee3a08b197b8cc6de9e300c674fde49a1cfec84f5280066f",
        "sha3_256_hash_of_signing_key": "1d50336430ed72c06178961a9befd4aa59241798b94c90b7d8ebcec6cbfca11b",
        "message": "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",
        "signing_randomness": "8dd2a9abbd92d21f6962622708f696df6957961c0e80046a9c77a7cf9e3e364f",
        "sha3_256_hash_of_signature": "e9552217cafec8c51547b87ecb65a00ca49aa4e382bc94fe26a635d671407a5d"
    },
    {
        "key_generation_seed": "626c19b8553b2d9e5a47a758615d80b15be11fd016d3a1962d8de58ed5ca2219",
        "sha3_256_hash_of_verification_key": "341d917532646e4ea27216fb932fd47d6dd4664f538ff6a0a27e2dd1f4e60e11",
        "sha3_256_hash_of_signing_key": "1e1d51c0f5bad950ba5f7eca8daf1824dac2c4cf9f9a034633992f25aaf2d562",
        "message": "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",
        "signing_randomness": "78becf9804af979bd36022bcdb8e2b5d5a5096a3f0a3fdd0e82b0d636cddd1f3",
        "sha3_256_hash_of_signature": "51bc4ab5e0dd46fcef4409d25bd8dd2201a37d24a9b52dbacf422f533ac7c80f"
    },
    {
        "key_generation_seed": "b0d4ba39adb4e8712b3a3e6495aba2f04a29e45c68671a960bc0d8d89900c97e",
        "sha3_256_hash_of_verification_key": "2b8428ff7fe1ba35ade75d5113c1512787f6329e8f0957da33248477448bf6a3",
        "sha3_256_hash_of_signing_key": "56ca33efa260f1cd77266d6e57655aa0a4fd2fdb8151cf13232a73ed6e9bd29e",
        "message": "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",
        "signing_randomness": "dbeaa87ff265e2594594bce653125b5235dbdabba4586bab30c34b5a3283aa26",
        "sha3_256_hash_of_signature": "60aa16b39dd41eeb12dacb7e421f9fb6a863548e92c307f112d812a447f3e7b1"
    },
    {
        "key_generation_seed": "e04328a783c10dacd96702d2e726bb11ce4ecc571564ce7cb10722d1c98c2842",
        "sha3_256_hash_of_verification_key": "5b8eb91b534654f607d655e728bd5d00e87683762e095637b9ea651e82dee333",
        "sha3_256_hash_of_signing_key": "f52d3e75233e3db45858d1f7e0e8bc9353acb89e3e66a73a5f569bbdc97fbdf6",
        "message": "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",
        "signing_randomness": "e5d67df73bb08e2c77720037ee0b4b671d14efbd493cf3f935880dedbb2edb7e",
        "sha3_256_hash_of_signature": "956956288a8c6ee9eeb93f8195e8193e7ee745783a25ded0b8f2dcf3476ecff0"
    },
    {
        "key_generation_seed": "cee2e53099d8cb576f8f76c5c155470f87a6ec5f7d73256a0a2aee62cbc53597",
        "sha3_256_hash_of_verification_key": "77ce5e3c7f7bab0c4702070ccfdb2bfaff64e958ad98a392f4918697d64ecf14",
        "sha3_256_hash_of_signing_key": "38720a77b43964c6abaac74875030bd408594f68707f97cf6884097ca3f41e8c",
        "message": "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",
        "signing_randomness": "608d2f9e284f6aad9a362af4a3b89cd2abee755a0a286e8efe4f973f6f24659f",
        "sha3_256_hash_of_signature": "58d890927a7831fa6e376fbd047f136e6ca33890cf764ea352f33bbefb0f9391"
    },
    {
        "key_generation_seed": "02d9755c369932e7f99a2e1614b03e2c86d713563785965e008ba987a6c89f49",
        "sha3_256_hash_of_verification_key": "69e9507bb47377ad482ab87790f346263abd9fe9293116a4305333e1ff95c6b6",
        "sha3_256_hash_of_signing_key": "4424aca6e188f24fd7510bb9a2c7544dbfd217e947763087d54cf6c53b797be2",
        "message": "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",
        "signing_randomness": "3564fa8a5675b141d97e6e832cb5ba14a8472437d7b64514b7a9440b88e3675a",
        "sha3_256_hash_of_signature": "f0be9e932fe810b8cc0992b49b168623d9bd3ee6309470620cd6630c2cfbcc7b"
    },
    {
        "key_generation_seed": "2b2bf7cbb0957a86bbec97001b60c7c6ad98a56e94542ff561f78fed211da755",
        "sha3_256_hash_of_verification_key": "8280c3ee838607a95a4086ecc042eba315e63566731f19617d3fc70d81d9ebbc",
        "sha3_256_hash_of_signing_key": "0d20865ff21083b769388b0cee5dd6f49a28bbfb7948b0fbc81c7518090eeb81",
        "message": "2601a39b6d7d91de539ef11c3b67ae3eb1607716f587bad5f60d311a9f4fe7f04350ca085eda6d41c4bb6c6e13e376bf8a314ddf791ae18be2ec0544afd3cc27bdf270c4550e9e78d497b92349ac07755bf9167b2958bde919123439d6f49c3408e8d88021e668a0a5fb6799330188e35ec5939b77097e3737c4f664d01d85faad0f583b3e95ede125587e2a79991750d5cf804325c72dc8ddf3471ee8fde02519d2d0ca7edd651eee30b3be335ccf7fb02059bc3a47ee3c056d4929ead4fcd82c8cf49625d5da460daa299718556bf0f77cc5cbadb99b64c8ead4474601fd5c79309d4e63aac392853072619efd7b958f0ebde5cbd40acd57df269a8810776d6dff2e637ea57adbfaa08df8d2581c38cb262dbb4d1f3c65a4fa068539d2056e08dcf03baff006edc688023a20728b227a99fed3b8f2bcbed2e3e6ecd8b8665a2e4d233b78d7c33f6e3bd9d0a24d13c8eacccb53a21dda9e7a34f9a0f031091e65f749c9ebccf3ddc4097a121d8c68eb7883405ee34f6a8b0208ea8d5a3fab53fe2cad1110bfa6e094f78d5314880bb67bfdfbc2df8aa250f1d7200ff9a3247c4976dbd1bbe99df02a3f246e5d466f85ed2f68e0b2de06b0f2448a7b98fbcbf5872bcae71bf0db4e70105b020ff130141e8de86dbe05b7d2a234ce2ea83a38e23a262e46ffbc837e8a71f657e443052e9a49dea4e344d497dd2de2afb4009d681f232bff4feeb173546cbcc4c80c9f85b1ce125be678e5ec62ef04433d55d4b8829b01ac165a440fcd6594f2c0cb456c8a47444ab05a0f0717b8185930d9738e885d24dab98e11ecff7d7a48a4527f94fc4c9d1b9d71f5e6bb39cf92b1a6d0509fffd42e77ac9ad6f50f8fc649b96b8ac08673f78ae8d0ba2b7243452b33aac44b06a2b9be1ad6a12583d3590a3f9af0e0dc35da88a257170d315f32f3a889601d6729433b7ade0f719386723eb2a008634749f5253cb7d9b2fc99a1ae1bbbe7f00a536cd38f8a7237d3992c3897df412f5b1d45e1ef5b5dc974d49cf8dbf785160bc527543458fd9378b3d4d3124214ae5676185794209ad0ee73b063cbd5b7830d00f817ca0d5cbb597c44d28e4885d935b7bf426c1339c500daf4f2033fa6a27a4196f233256650472f205d2c5e00e7087fb73027b0c6c9ac5c1d928ccd190b8a6bb33f512ca8e2369dae6111156de47a24469683f4721a25652ff87474dfd92a028b3ec5bcfc244ce442752a7da1da6c33fc22573bf0b13e371ca9fcc86c76fcf7a1654eef4442e47399835a06336e62952770c6e61c573cfd07b3ab631b8831fe3f5dd2c6df68ebf2f8e02ec9f6b90a371ed5e62c8463780ac453ab6f72d38c8f5212c8b650f63b98e3c0886b6a85ae8e7256c1efb30969532cdbf72184aecbde2a17b9811dd4222d080049c5d36c532cc0e910779d64af93d750ee96bda87562ebd3830fead07a3960cd6de7146603199563693392d3cce1332df35c2c8a2c251911d38e95815ce5a4ce5596e2d77711d87cdd54d22e8f0ab431bf8b24ce9c7bd6d077e436543c70b02f338841af0fb86b5ea4b6a47e27c1d83e1ab06801044f546adada437f3ce7d788a1c92a74ba540664658e70d4f2711979153ff1589792859c3bf122628479c7c35eee951dab8cdb0d4d150c2da338346988d34f8c5e589b231b5e00849611ba09711bd3a0516fd515e6c4ae1e8a3657c282c8120c97aa7a2e3baa22b6eabb8d8212a9a48e7759a9daaa51b538f662a05fb897067b7cf9d2ceb47a1897214ccfc225ce47cd60e86f7dea49e220f7ddd6894b30b66460decbbcb2e42b31f4adf0aacdde544b9124ea5ecb04b03c448b17e8094d489f516d23164d2317d3a1332e0500f1423136c8535d69065e880af34cf7e36db5ff2c18122e41880585b4d188411e86b370a024bd6e28143ea2eae52eb46be334a21a02e21c6755c0182b9a055a7d4c7b056e4930ce63edc79c9fb4e2fbffc58f776086f3487f02f8d1e7c8519c7f452e75ce5686a037b3642b95d7526acd4a81a47112cf96a8da7548016a22e9359198e871dbcc5852fbe14eecf3ccc5eb2fb5ec31d10474df7d63482a03e11f4aaa2eaedb714786e21d03af1cd644d06bb05ff7b3959601580bf50e5f7f82ff42e9cf2ffca0c67ffc52cedc53c7a5c9efb6c21092dda374d1cccbc78bbd9f5ee0fdf6da6ac60c95f7c2e96f17e3c379a52d5dbd1a92dd76d1f5dfa19ea0408e0e7f7867445445cfa60bcefc016e68872fbac9098fd6a8e84731c285570b1beacca6f4728958e7924f7a7b7730b9bdc9aaebd9e045f464071843c650d06c96d487cf8397286f81d93d0cc2008a62ee32421e5231998140909474f6d98541d899ea53714aefe652a3d792e4c72533332c3133707a49293e3b2e06ae18f2f81d601aaddaf2fd09ec59350e0979a5ae2b721771682a1bfb5748d000f9736031ca971288f34993df10fc06a16a6dbeed8cdaaa8127f3b71432e723558f0281459820a0f4a75a3b2716f976bdeb88be9c73f31623050d7c1a96c84988b01d847309e1b6d7b815883f83c9bdb7fcdaefa8ba69e25b824812b7d54530a3ecc96611897661158dae1b4aac112e9ac13d07fdc03dc7d5af23c08c5e4bbff737238fd3f1c06f94215bf2351dce9cae14b4dd4745ac0cd626054469c6a5286ff821ba192706d47ccebc443dd67fddb76797a8b78dd0daf850cb5d181c82298616e1d3a92f7fc82fd256857915773c7ad97cbb9710373299ae8516b8a1d647a13c7be848e0269ed6c8a91dc50d0cad21430a3bc9e718a13d1966a0182d9a24fff7ecbc7876c868af2baf2d8b782172c6719cf140e8cb877fe6d78779e1bb31c70c6c9a6a77529c51cf78a5e4fbd7ff6153b5195817f80603e5c5810c38cf43ca812eca52f73f045e33df4e3d04ec8c5f8b4a7399f6cbbf0d39dc951c476b9bcc002720ce89f09c3885673bba9c90d20dccca4a82ce5beb38bcd60afe2ba65fcfb01c8793b7ecc0f0b17a9da74f2e0fef4c90b5132fd6baf8c010fcb5e8e7faead7f2e0db29bfdd1811072623cee274ef2efb0f7d4191f332aaf20cf36ff89a2edf15f7b284cabbbef46901271d8c1b180f736125c8a44fe164ac7e687e9a58c3b1775238bf1a11f99bcb583d0e3c44bf4f76dcf9496a06f80ca52e24d55b54ab849d3040b4798bf5292b0574672e9f844016a52a4d4e4dad2053207bc97215bcc1bb93271c03c9ad2dfc7485ee2ed399236aa06cf9a12972e21afdc587a6334cd1d71a7539362d714ba26214664e3b4bc39cdb1db847583db8e002a2aab451b4e5bd6fe200730bfb2745d03c82b640f4ccf58701708f724effdf98cb04c78df36b7a866cfd596bf5ea18445eea0e34ed514d0dc2625039049a0cc82711dbbedce339c77f9fa1dc60eddd8d58c8f144b0f3d00227afd8710bdc66d29809728d7fbe85f08aa38aebe5605da29a09cc0526fee84691eaa54dc3744bf5a95275037fa2f600b1f91e502d5d81af48f8ec4c1834fe625fcdf2364067048727559047e07062b4d8a7d3851853bf28be9d2c511451e5fdd9459270328a2612dbff42e1dd34005a3da1226a023162f454923c0337e6c74b44bb27a3b1ac82dfd68b0a6daf93473d97a9e4591ec01a51cb6b47e2c7a85c1ffa73c35e5ce3003bc4534a2d9b16ebf9fed6464cb1e0cc665a451616a62b6a8481e4506a73883198c144a06331224d358196c815c811b103959edca35b26bcf86f41d9c7638547496787885ee62b14af431cab2ad4e0224d33476c58b8b0833bf13b50be2b1d682ca7dd194b793ad2c6e4ee25aaf95459302f0b4daed907a317bcc6a5f8d76ca9aa0d799f8ea39f330d6244bfb9f35e6223a0f665a65f55eab9bcbab446d7fcd424dce87f234864d2c27ee84600ed9193afefb6e7681bc94f514fe0748eb32d32262cab880d79cd4fe5cc963a4f688d448f2db2dcc5b0ca87ac26dd8506512c100273b8d4d902fc054d48d8bf9ee818ad9619f68a8904b613256db78c881cea3373f0cbbac336a78cd91ad9d60126e05cb8c16e9aa8482cf1b806b2f9c57bc8d63bf008ab2e49ede8e788bf96b9f1db2918dc5063f3f1d5b9b1c0327141acc0b4b248ffdcb8bcc127050d27c805e154a4825dee6be9c8d4e42b1f5efc1eecc6a45dbc119afb15ccad19789eaafa8b1715111ae32e2aced2278803b60e2fd63a43317498244a7cf7342342b60462510e19d83240dff5d58e762c093df326ea503fd347d2a92a5a4680d5e13b305671c729179fa21be83b0d83144e63",
        "signing_randomness": "2d34d02a0528a9fed0d2ae45188404317d4e5e5dbb22c710fb65897bbd3e582e",
        "sha3_256_hash_of_signature": "099f4752349f83ad6294948ddf4589755e71dd729703aeec28d4a2fcb03a1a32"
    },
    {
        "key_generation_seed": "049569cc5fb969c6eebb8aea1af1fcaf46f8a9e6cd6c796fc7193592bca9cf23",
        "sha3_256_hash_of_verification_key": "1c208cee5569588a73e487e8a771d5e99f3e6d8f78f41388f9e871a4db32dc86",
        "sha3_256_hash_of_signing_key": "e5aa36787afe336d8632610f9577041e384a44a6dbfc0726c16051f9e714067c",
        "message": "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",
        "signing_randomness": "4847d6414be08bc04dceab0860a93a697d941eaabbd52a6dff6fc4ea33d4b60d",
        "sha3_256_hash_of_signature": "84c2305eae800ae7d6b5a07fe1c7834fcffdc7a9e62967c15394ea3bae7c52b9"
    },
    {
        "key_generation_seed": "9d89b9a327df0d341cd2968ba9218bbc3e934502cd88919d8bb16dd3d39febf7",
        "sha3_256_hash_of_verification_key": "5c867dde54a486fbaf2a67676a56f33cac3e5ce03cfff06f1d1a5b6b2183dd6d",
        "sha3_256_hash_of_signing_key": "928692d2be885267fd9dfa171dd1ce1a3690361924730ed0abfad39319efba2e",
        "message": "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",
        "signing_randomness": "31b225a35a621b7cc7fb412b79f84624fb7278d5450074cb3e1cf467b589e64f",
        "sha3_256_hash_of_signature": "7f4657a13373e1d3ad2b3e869d07e12c8af2d61b5ff7b0dba01514b50b443368"
    },
    {
        "key_generation_seed": "4544c2f21054605b0eee46f62a87dfcbc3bfec473b9850886266f478bf9e33d7",
        "sha3_256_hash_of_verification_key": "4ce0b38e7c0cf1b6372e03c19284dbe05d794572f1cce13fc763db6e8836b240",
        "sha3_256_hash_of_signing_key": "b4c51c05eb8fb0514afae720c7cd1aa061fe6c54e300393dd861896464c6be60",
        "message": "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",
        "signing_randomness": "6df6d37e181d0f28606b9b1180547a805bdfe075eb51c4ad47de897b89a29a43",
        "sha3_256_hash_of_signature": "efa53f0f0e3c3c28e3e645d77a172bb47f19b41acabe68988c0567fea25aebcb"
    },
    {
        "key_generation_seed": "d9931e321732bd82ec9ca1df12ba48549bfc7d3e76a404b71892f4198777ffbb",
        "sha3_256_hash_of_verification_key": "a026a453b4ed99be7e694f374b69bd43f807ef62fe1981025dd64b3706406b7f",
        "sha3_256_hash_of_signing_key": "1cf8f76804efea5ecc10718334b2aedf9c766f95b4623f70f9c774fa65828954",
        "message": "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",
        "signing_randomness": "798a5665ddaf05bb01749ff874f94e9d7064911360c455e47054436ae1bba8a7",
        "sha3_256_hash_of_signature": "4b64a531cfad4d1530c5314dd4245d839563f66c9ad96f0bff776150ae88a8ab"
    },
    {
        "key_generation_seed": "f838451e4a5929b8bae9084b40b1dc0edfb76a9354bf27f981960c88b0ba3a11",
        "sha3_256_hash_of_verification_key": "a007f85e0cbd19dfd9bb6b30db3c781980fe2a93ba349afeb3a8311247f7130a",
        "sha3_256_hash_of_signing_key": "e6d5aa35a2b81735155719f5d3684918fcd3bd289d9a645197b6973e8da22f81",
        "message": "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",
        "signing_randomness": "dc1a7dcf4839e6c61d47317c03270ae81ce3f2bd63957688ff37326bb587f8ca",
        "sha3_256_hash_of_signature": "58392d277da131df7b74ab3f7168afb72a2f439923a3656816674b5644f7aca0"
    },
    {
        "key_generation_seed": "8e4334b2589d0caecf0fd9ba584ea26a4123d4543a8a0fe126d4a7e07f6067af",
        "sha3_256_hash_of_verification_key": "d1eadf01b6b36afc5979054617010e19e2294fee5e94adada2d0ebf9f90ace75",
        "sha3_256_hash_of_signing_key": "735cc24ea29af59db90039c2faf9a63268f2499a5b47a205eb293a6440a1b444",
        "message": "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",
        "signing_randomness": "6d3fd5876ed3c172ccb3c100d4b71d5a33bb4472e4cd328e7edebfb6dbb74d38",
        "sha3_256_hash_of_signature": "a2d353c60f0fe12509b8e5a6ba0d9518d51ee0c44b64404cbcfc75740644e6b1"
    },
    {
        "key_generation_seed": "37519a02e8021f2257259c0d2e499af3533c8ed8dd5bf7751cce920d79b518fa",
        "sha3_256_hash_of_verification_key": "22f94ec3c99465a8faed30dc8af53d05d11a2e459b2c224d9921365b4d09b8a9",
        "sha3_256_hash_of_signing_key": "eccde96310b87a59a9726facad7f1c593a3c9a25791cb6508a36eeee14eb8135",
        "message": "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",
        "signing_randomness": "5416d79e273c74904760e9c74983293e4075dcb9800e2fbcede78813c5c72c1a",
        "sha3_256_hash_of_signature": "65633a2adb47f2d87fb1b51bf1695da9043648cf22c60a14d0e445843524c9a1"
    },
    {
        "key_generation_seed": "690482bff6c1d0ba6c071dd395adf69e55e1bfc4e0992a8650ffb5e60a02b172",
        "sha3_256_hash_of_verification_key": "9335f522b809c922e5ef7e33999be5ea4ec39c6574fdccc40f23f6979bd94071",
        "sha3_256_hash_of_signing_key": "5258e931a334c4c302581f1ace510706fce9f3d0885e93a4b3ee282368fa864b",
        "message": "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",
        "signing_randomness": "544516c0b4d99ab3a7305c9c23bfe846782508ffb748e223fd93d7ca84e88507",
        "sha3_256_hash_of_signature": "e9ea8c37780d1cfd3d3d3367fcc38bab393b8954e40d83fde33e120881e795ff"
    }
]

================================================
FILE: test/libcrux-ml-dsa/tests/nistkats_pre_hashed-65.json
================================================
[
    {
        "key_generation_seed": "016b25101cf2704b9d218b7c8b4728d677359f73d69c08981dfa6a658776585e",
        "sha3_256_hash_of_verification_key": "a69cb92c75e86b541d942c46cebf7e02410e8e7f40128adadf98a4b074eb406a",
        "sha3_256_hash_of_signing_key": "44e0feaddb2b150bcf2796ad11005437d9d35d65dae71738ecc119c10ff50e9b",
        "message": "242f356ef93ac94b779c9074c344504ec3d155ed0b8cc81ce10a6d1b19f8308aa6",
        "signing_randomness": "0ddb7cf189e9d15ce326c6e1a38a9626f114d18808dd0068fe9b1c17ab04efc8",
        "sha3_256_hash_of_signature": "38d64700105681f106eb4c20c7731433dca1a48108ff99b727cd405e7e4034c7"
    },
    {
        "key_generation_seed": "259681afb9dc6d860388bee75d3de0f4bad8ff7611e1b3d7791fb881cf7872fa",
        "sha3_256_hash_of_verification_key": "7c2329e8d97e9f1c11c792dd1a4c8f1524f9e398070e7e5e0b8e43cc9f4b47a3",
        "sha3_256_hash_of_signing_key": "acd9a29ef00a03f0f14cd8a0899c835c0aadbd36ace976652ae24840a02b6400",
        "message": "e8a7ce4ad0ad6b74fa07eee69c2c3fbe6d9f0a01ccebb3ca4de11e5ef8577abed98d3796ea823c3397e3834d52bad40249679bc9161c0e9d0ce24f3882b1fef2649f",
        "signing_randomness": "59a3e11016e6fa52bcd665f33a3e1a61ae810223e2b83430598bcb4db7e75fa7",
        "sha3_256_hash_of_signature": "c91346b9e66751a9e93856a9592d63d94cf440ed487be6c0d4462cf9b7bd32c1"
    },
    {
        "key_generation_seed": "5500e1eacf83f35c256f2cdbcbac0cc6b2283bcc14d8a5880aa2b8d0415a496a",
        "sha3_256_hash_of_verification_key": "37ef010f9e7b1347cbe256271a8414efae4de3303fe3111d19c3b3dea88ee725",
        "sha3_256_hash_of_signing_key": "11e2856827734beb5dc18453883de7fe972dc2d089f9828c1f0500f96efe4cb1",
        "message": "70260820570b63a0f5dc29d45edec5ff0446b50fc5ef9a4cead786afaa15f77044a89364929be2841050538ddefeccf866ec5f9e02e48498d9b34e15f631eed62b83ea0399e2d17de750b3499885841ff8acb9f44a8fa6883e192cd92da4bb90560243",
        "signing_randomness": "c105af19c1948086bfbf0b16f050aefb14773c384121529c5dce31343188ca94",
        "sha3_256_hash_of_signature": "85bc7c5cc7cf754b164c91e58a2f9d39e3b8da83eee364c695983a42f97fb678"
    },
    {
        "key_generation_seed": "eba3bf4eac60f2ae3184b34893b1fadb92ae181fa0301876d531f3b6011e94e1",
        "sha3_256_hash_of_verification_key": "0def8f75cb0ab2f43c8508dd9c337017dd8b537760b1b26eac857fd218debb0f",
        "sha3_256_hash_of_signing_key": "7903e89bf25f85cf7cdf26a6d0eb494b199691329e4add48b5ac9c19d7acd44b",
        "message": "12a4bf194b9cf7393e2f0e63fa48094f748a4a9141850ca9bc39ace05e9b3cf90a2600446d7858a8354a77821fae68ea103b0528a24f83b3e2d344ae1cc9fef201795304e77ae12c48b8fe8acbd6cad2ec7fe2c87c376cec9da56b5c4801c5f8eb02fff4ffd10262b86a089a88522b874ca21706d9e1741d6d756ad2793fb4b03ef4fae1",
        "signing_randomness": "d63e991afa0a3a4ab28051a718cf412d162ca015c976c3a9297e57cefe978a4e",
        "sha3_256_hash_of_signature": "e610c1d1c3dd09fdd91e9478a83ece692460a5768750f4f11fb8efe8fe653527"
    },
    {
        "key_generation_seed": "9598882b78273803f5e0a353f7edaae1db16465dc3d6e939995fb894d33efe18",
        "sha3_256_hash_of_verification_key": "c8bc4fa54fad2d644f07787d91273bf47c7e6da0f080d216d092c664f8d5e36b",
        "sha3_256_hash_of_signing_key": "584eae76f3e81a5e003c5eed9681088a2e9ab3a6545a12235cfb5e771d651127",
        "message": "ce785c980c5d9c609c42290bc0f44f87e1fdf86c0d57ada2eb8e7be895ac9b6b0eb7d0e9e5710c59bb6da703b22d6de8b1b1deefa8a9dcf616b66ef14c4bf34fb3d3b76927a1f823dd72a519adade3902ae3ab34fac6b496461790afa13f873b146310a83c084deb4721350acbfcbc30996539c4b040e29ee0f575e046aa2fe8f8c9a6edd77951a0c4182565b24b2d3393905afa917814ee852854b1ce610ec56a852a9864",
        "signing_randomness": "474e57313eae2e87fd2b524d527c1b8b2aaab2258046fbdcee2908bb5d94fd9b",
        "sha3_256_hash_of_signature": "4be6d6c913a18b5ca2eea909afb6f70433e6d1c022f0f71ee9634168b83fef68"
    },
    {
        "key_generation_seed": "4845e8526317981481a68419a7389f8ded6094e49c11c44fe1e73676729a9cae",
        "sha3_256_hash_of_verification_key": "65ef848698a51fc448f40f0c6713713a933b3fc845a75bfed31a4f5344bcff8e",
        "sha3_256_hash_of_signing_key": "af68c5ba7e664d669ccabe809ac7c8ebde9da6b8559ba365784d65f126c49d0a",
        "message": "bbc03ae447a945ef029063d377fdafdc5aaed3c4ceb4cfb9e81465e32b3416dca1a37007d0346d866cb2d5cc45ec1ed5a9d9e2f978ba9b4f5c7f37f8c1733b8c2d83a2d00d4d9aaa1c610cccfb97523db8ae22c60029638d562245a67663a0bdcfdd154b5f40d70fbd46a5911e4a95a44bd60026865bed82a77c4338e31ccf0191918e33f27932093e9390ae02bb92de7896cece42f1c4179316a42cca8694d6860f7ed92bb776ba45dd194b19be748093aa14d93f42acc443112eb9c3e1ec1a980f1602d9c7",
        "signing_randomness": "4220a5c6459862d5f293eb1bea48852f75c8a59e1831d5c449e21b71e7d6e7e5",
        "sha3_256_hash_of_signature": "a7b3b022cf3e8df838a07fc4860ce69f8ed392fae75ea44a75a36add99cf9c0d"
    },
    {
        "key_generation_seed": "e7a108f63926bfd88cc202906683a4a6a67cd0da347ee48f67ee5e158419cdab",
        "sha3_256_hash_of_verification_key": "3a68af4e86f59dbd850c65e525d69dda7d8229cbdc388d5bb38f5f168427dfe8",
        "sha3_256_hash_of_signing_key": "3e5f76ebf5da5b61b059ec8f6274e8eeb0b284c56a0661074ce1eaadbec580e3",
        "message": "0ff0114c45cde8915d0a6e9a978e69e0f6a81bda695c9e402182ea8094aad5614b44941f8a1d6deb77637c2749ee3cf7bbe194de04c8bd3638fef5f9fdf2f49103fa47da46f27d29b8f8b1d7d5b5b8c998fb083845de7e4ab4944b82b959c8482eb2865125a33aedfed46d7cb4233c95c5852106a9cd5c9b41c6ff1c8065ca8998cdbfaf970d8b05b50dfc52ee02b853c0224b838c57ef4e679f1c744723ef7365f5a17add9650c0e4fb36ab86663b5adec833696d2eb9c7b7e3efc6f5629324b73239094be0a9030d2215d96233df5622e541fa628304426b2d8ed2bf0183bd005ecbc78d24cc",
        "signing_randomness": "c6e0778467d613acfbb1107b5c2187dab2a7ec31b21c0689bc35c5682480cc9b",
        "sha3_256_hash_of_signature": "f149bb8b930a1da73b17cc1cdd8e31a433999d671413a5c28d5fb2c23dcade27"
    },
    {
        "key_generation_seed": "909f1a8049b33d306c962d5e1adfe63a9cfe749e251deb47021364e05a6dae45",
        "sha3_256_hash_of_verification_key": "a0db2f12ad8b0ffaa794af7934d5d1e9a94d36e3fa20fd69062eb7a8ecf1e192",
        "sha3_256_hash_of_signing_key": "f34f7f559dfc51cb744e913e6deb3b585f83b9d761d55084aec392520e1666de",
        "message": "c47e571d827193631fa80d87926cc0a9ad03139d8e97f2cdf2094071a56f9d5230228193688e2f754353eff313b466a5f5c63b6ebdb5b180ce12cb356dabb98c24122ed6a0cc6829131de9f1f5686e3c4afb004fe69b1bc2799e090e9d057c815e0dd8fab388b91e021c2d581121bf6fa510c6d034d232fc740782fef0ee5a319117ca2bf6ea81a85f0b5f0c5b26b46c7e59656473d8bb7906f95afcd8b4521dc5bb85ca352aae486ac081a2d81ca100d243606a736b095a8ec7b290e2a9e9414aa98f2a6e6d40091b38868382f56fd6b323bc8614f551bc6b1df7830365b87dae4e1dc08b1a43ec82220d621ae73c28b3ac06ff2ce72b1ebdf9f45ff5e38e149c5bdf61cd08bc6c",
        "signing_randomness": "de54d0855ce631dfce3aa6d1606ab571b91ded15e7981edb45a239735ff12ecd",
        "sha3_256_hash_of_signature": "af0da09f1e954d4a9987b153cbeec5dc44c198cc0de74544845cb3445ef82069"
    },
    {
        "key_generation_seed": "cc272dbbca8cf0e6652fe271a35465dfa14f9b74c7313a2320d30b6a6b5effba",
        "sha3_256_hash_of_verification_key": "e00bea8db9083805629624900bb70c4897be8d30c96befc723a096058be68087",
        "sha3_256_hash_of_signing_key": "23014ab169a59a73a8ae6500bce06627d58500ae37b8ff556f8fd619a612b893",
        "message": "26e790e4c082930d30468a1568c550f89e60802122a12eacbcd02d128b9a5bd0894802072a93d373a7f81ecab83a659d0e51b5744ca58811db17932ade3783014280c5b3d29c3e79967ff2eec6395f1262c7ab958fa331737372029764fc486273aa308045a6dc37f707601c97cfa861d69344fd0fd6d9f6d154da4f522688d7db5f993d8c0006f8a5fbb086a70dce1827dc74a70577846f5421f0b61901b2242721b1850dfdaed6ebb0d5c90f0df5e2cc00dd7e7a62a9a18ef51f0137f93be1835b7cc56deb62636e5b64213674364f156db25cadfea39548e87d8b19f9c7c3d6d187098c0090504cf963494c1974020934915be605f4da2f397aa69201b6556bf7f5a392b6d0ab2de1447d47ec7c20dfe3a17c48dec3239704d6de0c8b49084ec717061e63cad82d",
        "signing_randomness": "4fd52c447d0e58aa332fa8e1c72e712961f41490ab1aae84a2f1826a7b0329a6",
        "sha3_256_hash_of_signature": "1537b1e217d23dc3e2268c9172e3c2857ff7f8a75f3a199c45dd89c64ec1b260"
    },
    {
        "key_generation_seed": "70d2b24bfb8b86d8816e0916582c3aac940a2c4cb4b37666f8fad29181cdfc9a",
        "sha3_256_hash_of_verification_key": "46a9925bbc5b1310b6ab4d8a4afc064c0376a65c58efacb0f79ba2ee586912cf",
        "sha3_256_hash_of_signing_key": "27d43e3cf253948e7a1d6ab69eff3a2b1d514721ccebf62a16192ae0c36347dd",
        "message": "cb9f5d669a0cf2da5d11bac230e7e1499994f2d649880a5b964a6e92f7be29d954669ca02ebe83e37d6bffe283138e5b085a0cff8f99d9f1505aa48fc74082722f3ea58799e984687ee1eb0fad9c35d34e326d247589e5b93145fe4325fa850b4cef5bfb7111165f6c4ebc4872f22e809e60678143a7773ca25d1c9b6539689ca4b64e9094bd3c6b1097f12cb23a2bd686b77cfb427381d8865eadd2b16917eac5a594186b355b972f7283daaf37e1f8475dc648ed081b6d57a56d9150b5b009d712d3029911df57b44352fec78084c1385ebc3bf6464253a47e3cc1bd0fefd0185e1bd945f1cf6683045155e03141022df51f8a0bb0156f7bdfd52c2305e4d27f903512eec8bc573b375d7adc109b476c698e2c64c20a787e13668d096e609ff12085d6a634cbd66f3b02d74eb5c8abbf117c7a0519fffabf8afe3bfd65a2893d302eeeced4cb94fff8",
        "signing_randomness": "0ccf82ac2e6ce4e571806d1402fc0aa8945897839607c3d797d927989ee57411",
        "sha3_256_hash_of_signature": "9e94deed5cc52aa334badd2c970553b0156216fdfc795f13e7326122556bcac2"
    },
    {
        "key_generation_seed": "b71fe7a6bad457497279a56bb2d87ed4d1304235e1e88ab86cf0522837e34b09",
        "sha3_256_hash_of_verification_key": "2815613799eb39ea645faf103ffa61eb7d96b16e62d63a8c398949115927ddd1",
        "sha3_256_hash_of_signing_key": "ba7eadc624d46e7be4142f4a0d35423d9dbfb765576bc6d09fc1fa278cd5aff2",
        "message": "4edaa2ab7e34b5e199fa1fb3c6b89015c851611ea636d46558e428388fd9e6392c3edebc422f5f96627628b44b088e919a132f9a42fe49251152fdfa71d8dda3e10e903ad70d9193388e6164a0ce3d2fe3fdcdf3c19af376d16250453b70318cab9e877f6c8c65be01bf2037ac56021a855f208abf4f01c6efba1d30ce980f7a8aa9b72bdc81abb08351f6c0e4d39c60abfbf2fc26739208eb7a6cdb2e8d139eaa0e23c0452b077ca78a41aa0b16d1ec7d44b452d8aa7fd783463222a8a2be2ab174b451e008ca438e4c2df19b5421b2bdcbb7fc22422fec6f6dca41228fe3daa3097c426935d2086e9a5fa137fdf07ce97edde5d4bec27c5018d0cf6bd0ee2e1a286a1f997b955ecbb084e02940834a531e5b243d4225ea61b500dfd56d8fec56fd5a88396d958f4f5352565bb644b46c63f1945d65a73e7e2840694af9f10672391d645d7358e095a938e84354b1679277afa5cb542123b7158af2825874f166907346931f5cbf8385b6",
        "signing_randomness": "cb1db24973aea3329a979851cdd3b60955f484bbdf5aa8016eb9c6f7803776c1",
        "sha3_256_hash_of_signature": "da4c47001ee35148f3a6c34a8230d05d660de43c8bf5865079b514766db56885"
    },
    {
        "key_generation_seed": "a52506ab8830b41cae8b6ce9660e65eff022a65d338b74ea585de2da2ac9ff02",
        "sha3_256_hash_of_verification_key": "6b0cb85b7993b53f857c4975db813efcc838dddfed31b6b7242fa701bcb882f8",
        "sha3_256_hash_of_signing_key": "a71888a520976add16e6a72a3da9f7d66bcca6044bedd1d3873fbda9a17cb5ad",
        "message": "2a5d309e9e976f9323e9dbf5c3c8a744d66dfef728897fd3b5c29cdb3c9d9b5ed5bdac811b00d8d405392ae7450206abe91c8811020a48335c938211621399150dd91f90276b2a5cda2646652bc3badac7d1fcbc7d9e2e8bbf0045ac22151db08824f10706e29664fe5cae8bdcc2d19891680985fe63bd8002e07d012464673a5f0d6c160ac9a6c752a3f515b8f6bbe909804bc5842d998b2bdbd6bf8acbafdaac6831405176030e8d158239be9b624e7fb2847b19afe49ce8b485ee4dc707caa616ed1d8d1f146cde864fa3e6773f12fdfa1473f09caedc9cacce4c76a119818d853acac404ca0c9032128a3793ef940c9d6ea2a99cbf8172dcef2e3b2b98858331ffd44fc8c832542f6a301712fe8e08819181eb2eb2c918f51ce1d33a3bacab32780bf5b76d760368ae598b07578ccc39c6783e08c56c96a9b0977bc1c345ed3389e6ce58316cdc8e18d0420685febd336446e10a59d841dba7984b558a30d4d471b62195a59533c7eff8e02a48a6d80d27c5bc36e1d0a469d1b6b96d3845fb7568efcfc263040a257ef2",
        "signing_randomness": "06d2be96f780ff6eda29c13b0403e19bd62042e379a193a530841454cfb2b3c5",
        "sha3_256_hash_of_signature": "de9bcbbb203d419d170aa8ccc1027c6adf2064ab6b342b9863579dd41fba0ea3"
    },
    {
        "key_generation_seed": "1aa4f8271b2f8cf386ab0ba23c81d8adf44949f17b5bab29acbec73c2b06061e",
        "sha3_256_hash_of_verification_key": "e212fe6ce45c174eca5334bbb912bf98e38b93b9fd4b1f749a16fa9fc8006401",
        "sha3_256_hash_of_signing_key": "c015a9d7ba9361786ab21b6254101241660993916b9c419f69b9c9f0765a98e6",
        "message": "51ce09f8e011a3ed251e9dcda439957147c074e04bbc65469bef8d033a89fef92a4cc0d2de6b4f7e7ebb24e3667a029cbf0790648475aba9b1f31e7318521ccf54c518b9cc228fb0912f018ccb1529b2afbd5d06d53faad2b2cae6f490111c17e6e77a01ce01016ef40e591329a3acbdacf55ef24dc8cf35715dec7cafe7ac93ef328def7554aa33407e775c70dfc0adb5de216b0c4916d3c8deb37e30e1310b55cfe111f5e88136e321c11bd9d7da6d98bcc3e76489a41d6a13b99b8eccebecf213ac79bf7a9c7f03847762a65cfc6bfa08cbf13f46476d045cf259acca50fb40b8ca2114d57b9675dd95dc59ca7d623b3abc512bf019c191dec5bff84b963822b1d86b40de9e51533257333e2669da41d0ed1a58589501e687b744d1b9e00959ea4f6a05cc1ceed97fb0b643e87b1735c359c20ccae2db9030e246895c5493355ce5a87fdada237450c2a595f65c7cf8a986af16805a3dd48fc97521a45b308c93e866d1b62919a7da5a4fe45140f90c9dad8c109610997dff1872de80ca298de4314129e51fb5b24c806067bebe0d25b01334f7e09aa21a234a8893a2f8c7c046a0c4f2d9eef87dfe13ea1a",
        "signing_randomness": "2d86f5555f2202963fa4aca97c2800658eb6af8d8e8f5146f738fecbacda33f5",
        "sha3_256_hash_of_signature": "75c4c237f1ba39fdf5ddb9ec80e7189579392a5e8d466ec10c11ef8ed2a67a4e"
    },
    {
        "key_generation_seed": "06982fada2bafaf75097d3f7158b67258f378476aa6094ed2aef7c1cc0f29036",
        "sha3_256_hash_of_verification_key": "b5f41d7eae1d3e3d4ac109c62086dd697b18efe36470c35418c725a3a6a0825f",
        "sha3_256_hash_of_signing_key": "f7f7ad27a10a10d860d65d81a50b48e98b03a276b226f80843f78f1757320ea4",
        "message": "89015fd95489b05391871e44f0d4949656b10c470efe5bb4c1df5a0249996b9f2870779e9f83d513fbd6021cb13cbd88db5d9e327d45cba00cda4ca46662b304f024ee1ac265b1dfb81a03b0fc6abd8a893e4f7dc02e4459cc0667cebb959752f6a4ba5c0e7f5138710ff1ad9e3e85c770088fa1aea127beacd5fe2393f7cfdf6c5b6650d49014484fb72abbe3029e41c9563166dd37b861299f72e1a070de659f18752ee285320242ddef92fa3fad6adf87deaca11ecc6229982cd001bfcd89f38fc405c20f186f3c0503606b55f02c9617da9ae82483fdc67c047cfd2521d5adc9e40ccfcb91667f4fb26a61cbe4de190bc4f8fdff3ba69c8442892507968e3367893143f9b8085f4ce03f8f61368011fe6eaec3d4431f9f61276de9d1a30e3c226dc1b9a5fa4bf35093333c43492b81ea60fcbeac219088e731969c4f9e9dca061c4e63ef62fd7aebe524cc83499fa77ed309bc15d1545d1f160add81d18b76a4e7a6f008adbd627babfe795975770f75856e1aade0f95e118a3e5e2a01eccd0b14304bce4e1455611d52e790c3aa2a39e9ce9d575899a7722cd80d9f4a2a5e25ca6c975caf00d157c2a7eaed4167747fc562b903f17bf0e71b12d8f3808813ae4510129b262a9b9613302d7f",
        "signing_randomness": "b108b672da6a93e1ca060e22f5acbe163591daa2332a1f610c7263b5c040ac5a",
        "sha3_256_hash_of_signature": "2be365d8c50bf7c1ef162c91a28d2664284d6294226acf19f6c08e81ec06feac"
    },
    {
        "key_generation_seed": "9665b78359edf118639d8d8579b81788ac2e6751f1a5eab7872d110b79598eea",
        "sha3_256_hash_of_verification_key": "884298a7c1fb0c16c9f21596cda56fcfcccf7975e1ccd1ce664577604a4bfbcf",
        "sha3_256_hash_of_signing_key": "70ef6a82ab3478c808a78607f9f1413fd4cee7de7cab7a2e19dbba287945d07f",
        "message": "fbdc61e0771fe03252039f86d318442a90fc8f60e7e324bfb72ee9f38fb063c3494daf0af6cb2d2edeb3a861c49d78be54de21ca0953c2cb8a99868475c2380fed1aba221f1dde407e49412de6c6c7f963467b7ea6161cdf96abb42dcc9d4a9d6a134841ab5f5568aae943852ea2bc8adacdcb4478ba0ae41ac74446cc421f0e6ee51a1133daefe0d1ec18e3c10097cf216caf111c185337d9ce5d572ceaa554ad9d6e8c6633b89001e8cb81a5b90645be13edc1aa406b1515cc45b1351c4038c3bce9194067ae1866016beb322f6389f49394b2124f505a3c8d39f7ecb98ac73c26012ebabddab209ef41c0287672ad80f3c21645431cb8375d8b86c4c8c64492d0ecb729a9b73712b93fec71e21b84333c8dacc46eb373ee081b3245d9c13d35769144e459c8349a37510b1447cc05d7ec17943c32e0a4e218f28d0f88d8150ac1248c7b11a719c777b72f6486be7fc525319c3d73908f08d6aa0d78f2cc3feb87fc2643e94daaf7633e46e223595bf2b37fa709c62eb1fcaa2c2539093e28ebc3e4c94c500d90d062c2de348e970dd9e7b10511ac5577ddefdd763ace5ae6aa9bfab460a6dc8e924db19c3b2d9dcad425b356d1202c446d5191c06334936e16789c6f62958acd1cd7df1250eeb53f9e8ca5180380c6780f63ccc8fd13c8362ea0aa93588c693dfc7e3fdfbb8546",
        "signing_randomness": "c78a4fc0fc37dd7be3fc37cf3b0d93b8faceffa053af5108e37a229bf3aabf47",
        "sha3_256_hash_of_signature": "c0e09133b245cb5478b2e81c03068afd3b17d907b5c718970da5c889a7e0a6c1"
    },
    {
        "key_generation_seed": "bc0d4f924e5d38d7bcef1f0cd486e5d6ed03f50686cb2561c34f11b5ab46ad75",
        "sha3_256_hash_of_verification_key": "3d617a6cc0fe1e3436a03cf71aba0ddde79c97df5a8cb75476bd7d3ff7989094",
        "sha3_256_hash_of_signing_key": "caca15ae5b1f814c5b91304504ec2909f669c7b797d44faa59180f1966e59cef",
        "message": "19686ff1e956d06e5856b6de399731ff5f6faa78181ab03b21c59226899e93530e81b3175ab76955d279f46dad47c7ecdd920785b04eab48e8d3bf7ee460b32a08802f91bec2abdc8d56ad0ae42450c60c014f2e5dc66ca8901a5cde1c5e928eafb66153e54d6e5926d12c2f93bb3659924b22d1dd0175c95ebbd7c2b136fdb4f9d674b1ea7fd9275d9c9c623ee8084ea19408c73171fecce966a7183dc19573a14e33132c41748fa6199c2254e27ac76049d375a4fbed8c1002fda1358d99ced106fd778566729fe346413abc44c0e73a912fb6dda62f25a5d979ee11f84a09c89ab7aba7a6cf247fb3af06c25dd1540fb211665126a38c260757016ac65f2c1482e30f3da312b8aad7e2a03366aeb122ecca83f316067a9a34be76924aa822839863e3652c11f328bcc52ac24c5126948fa775b39591f66d9bbea62d6f30c72be853a8861caa29b5c72e108da99aaa008dd7df2b1d0133fedef2f3dd0779bc8c480bfc79a97fb84f8411d996b7428316fa0dcf902fb14460eb2302433dd0c6f60acf33df0a25e17fd8cbf930973d9139d11856bd1776519c4e8cc4e8164d1ce0774e216b2238ad28caa314907518d6dd178bf8a667b4504228177ac05702960cab9a153388bd39c13ecbce074678da866ecb49aa9fe8620fde68ff100f26e99e8701720d3841ba8ba7715d430a2e91cfafaaee1967a8cf093b199a931655b1b6bd3b633284f2b1f25b1ee81905c424",
        "signing_randomness": "802889b2352c64d4da34a50794e07e6db041ece876d634a26f725b2a162f1e02",
        "sha3_256_hash_of_signature": "0d7b103f879715b3d08a20705ff0f3ad5c0054edefdc036ee37149dd92fc272d"
    },
    {
        "key_generation_seed": "97acc9feed76500bbf6a2abef6124735feb66b5992e02961c5865462da4a72ee",
        "sha3_256_hash_of_verification_key": "5350421f094c51fe92d45b0ab72c920ce55e41088dc4158c5a6bf282da926051",
        "sha3_256_hash_of_signing_key": "55550692ee1b071f8d43fbd935b5fe656afa61e8dd619195752aa7660c7f1bb5",
        "message": "d0156ee2c6dd2020b91d6824350e4fd838f6bca0f5995923ece37766399543b8d910467206c87e5f7264e31cc0d71d33f46f466e27defe12cfa9fe4b64d4002de68a34f382f214762aa069fa15ad345cf0e5b6cd76a738dee4152ff9ddbf54da746561a24c199430171b6d5c9230a734b0a5e456ab8c87d2fa62fd73e128e2d2d1ec908ea2a68544852d72bb942a8e4dafcd63c12c51f750698ee07cb75cd565e5b8e498756b5b0af92d7b87067d4f764c6ef47e3f629ae31864a9494cf693c6cf398663e64cd5bca2f066f0886150d71c689ddf842bb631ddba8da929ab8b096c125562014a88b979270f3426baa6e8b0d73cebfb136ab6a8161be5512a8b0e3358e060227669ae5c0780a67ebb11e5c672cb1dab4a94a58123dec93f6eeb7e28775cca9ebeef16caf3f9f9b5ba88f0e0ff9351d85da06d6bf2f9ae2d2c7def0a0f585cf93df64a2c4a916dcfd3cfc9d79a816e53d3106b6e08236624fc9a15861fb2b2e3eb7117d5675e00c784834a82072f713d929403d24478ba195af457164aa1a85c5a71c86537c04e2e0f1c5debf6f9a13d6947aef8290127341dd75b513ed8730d6acffe3eebd6a09626da29713d9b1f54199bfa4f2f0e790f2fdb6bd3948f86d039583ddc534146935f652a7a6484c9a6b8a8b0159e8443b98cfcd1e1ead9dbf7ab4d280fa6e32a3994648cfad300af8a71f270ed943e0ddcddd98878377ac625595ab59c8a65084d26815189e418cd11b2682c6f08f08bd0c849dced2b0979b2439ed02974d0daf531b2b2fe",
        "signing_randomness": "eaa50d5ef53750687f32460174474aa3c9aa6c6583ed7eb707f2573c5c5e046c",
        "sha3_256_hash_of_signature": "73666a0c063b72d9b5e3d36197d58ef1635c019f43dc8ff6913e9f6143787ee2"
    },
    {
        "key_generation_seed": "8105d3a3429522e277614c8cfd0f8f5496e35919878a0a04e2bfccfed9a2764d",
        "sha3_256_hash_of_verification_key": "31a9f167fd0391aac133156e270348810f4b3826d7bfbf4321bdf1167ec156ac",
        "sha3_256_hash_of_signing_key": "b2f97b37da8410939b80095f31872eb85de7e4e3a9bea7b13d9ecd685f9152ab",
        "message": "8053d47b46f2269fcf47943e3d925dc61885814b3d81907ffe45cb064464d6043eb83a3e49b2fcc6dbbaf19920eb8704034dbeafe33393d3b62a3e6735f7dce7aefa6e924ad1b0ad142d3391324231281340be0710a3d97ed9ab089925a3fc5a6760a0c964abdc3611d5cecafc3f14e95260be6d71250b0ecccaf7ffa69c8cca3e97f2914c3ddd88db656a438566204815510f209efbfb66fda5fad54e7c4f10f5c5b3743dd752937618f5fb9aac052fb6474708b582f75de08643a683d6975f3dba304f0db410b89fd8475ed80675c8252f40502c7144cbd129f57098ed49e643e8505f6615978f0a3c8a3b759f360afd0fdb9a19e46b661b8880ac58cb4d75fdce669f5958e03d850ca545519334ddd40799aa57f938bbed6334d613bfa53c7ff79ff196623c4a43fe4360ae8283f5d7f8dc0a06a230af6fc1a521775c751d84202942865e9c0cbc47f35f1ea588887c64e34f5a10b10b6db0e0e7829a6d37d14ab33557079ff9e22df504b7e264d4745be255d064ff912c18885f806b34c286bfe604b806ce667ee5e1e72b65b969cc5d7e8cb2a4a87ee6ca97286d07b82a391a24130913d2157f742fad63f6b65b165f3da0d6fe50a6b857d35c93652d26bfb757be1e35dabea7e5591531390006794807263855003a7bea15a1639b8c6b5d9295720cae3c1af7f1eab0a19f946b185587d5da8552c065b21514a52f2cec4fe5472d765ec3c7e7dc20eddaac1f193882ca97e04dd40b1c225a9c2c93b2b5277d21ce3f65602d32cf612d5b06aac438dea3ee178b7ef832bd233269709267484563e23ed01ed9fdfec4086b0f91dfb832",
        "signing_randomness": "9ae57dbf52b062d5d40abc46bb19fe10f310ffbf8f3a39771d9448fb5e186327",
        "sha3_256_hash_of_signature": "6b1153d4e72f14d85499dc85f61d2774cd25081d44876188c622c2a4ff2df975"
    },
    {
        "key_generation_seed": "0b8f62093d8f15375ed31950a316b47aaaacee999ea9a5127b900a0ba4dcba59",
        "sha3_256_hash_of_verification_key": "afbb5972978f51c4b9ad2fbf564ecedd6d715208277fa41d8d08d9e805db5232",
        "sha3_256_hash_of_signing_key": "9ebb95962586ba4afff9d7f81c0fb5de10668b35b599d41e39c3e8b1c5fcde17",
        "message": "9f4bfe39fb9c38706d6e4aaca790b97aaf2d28f1c528db5ab75dc3d66b869675b6453775925b4042fe51679b568b548051e1e561b165624aebc286ba6e3751596984f3440e3aee06eada12a482c81092bfd143ea18c7aea5ecfe713a1417eafb0ef04f0c52a3a5a160547cbc1cf6e69c72c7a45aa308c18f8bbd6192ebbaed022e8f8ae40299e3247a8c1549bacfebff22a911232e81c3a0d53efb7539fc363352578794c3fa85d8cc917332cc7bcea3293f4948a43635a9b065e589f93bc2523d7dea29905314c074460d37ceef7ab2a88a14cf643fa508d90b317257d574b56e53aeec652959530fc8853911b507d2df713c55a80fe484982f8c68c3b2d46a39e3438a0fb200549cd692ad108afef7cd6a32a9259e507cd481ade5bb80b876cf38cdada1584c82d073d577836c0f6535913abb2eca297118301e72da84bbc5e5b99513c3af7d3d07ab949281f2cbda274df07b80fbc87f0b04303f73fc671fb30a5f7cdbfde0d52ce65da7cfb6eb1e91c5e9b2e650eb6411d4eece1289b24baff6bedc3b52553c314016ae00d077ab82c07a5a518a8cdbfd5c7c748cf34e524e8d3133d140b64c6dc61eeb4e7c8415e80378f1571a9f69c25a59e7bc1ca9efaf9582bde85841b1d597d58ca7579903918e76352093a339eb7fbc5b423805c2aee3a1b205a3cfdff7ad12e286c394a10af0835cac34ce7725a12ff0940eb01c4827cf999122ff8e1e7cc01019be324199412360bd8e2d86b3ec3b92e8619ca3d9ca2cf40eea9cc76a70ff8126f202a1bccf5a10c82dd304acb603b24c155f1198debea34e9a03f5f5c73cb28b5ff34aec40ca1251620c129ca8f8ba392cb31b801c280950c235be8b14a11883fb2acaa8a6c4",
        "signing_randomness": "9e50938d7e0b916e85c5b3270c5484de4d0fd06a10134f2d8961cec25c2d4a92",
        "sha3_256_hash_of_signature": "6cc7736f2b1e1c4cbb3400006793c664a041926205000b698d35abb00489d6c5"
    },
    {
        "key_generation_seed": "b637cdff5d85e4b833cd6b73c0d679253700aa99b9b46fc8a36110a310adf6c0",
        "sha3_256_hash_of_verification_key": "697a10df27740e86133c3874d52b9e28b21bf6284bc60cef4c98805c4526e2bf",
        "sha3_256_hash_of_signing_key": "46dce592c3923c429ffc2d4af6851d4b89e686eb13abbb8a76090f54d59fbd21",
        "message": "96c6a06b7add03a302ddf91d5e3c8850ea36086005f85259104b482b8304ed96bc0cfc4dae833e5084c6a181c365e04da15ed0e8fdc911da2c7837398770a045c5473d06350251bab538e8f0f48eeace21e0e99c52db14f30b87bf9e75267ca90e40129e94b86f8696156e8a274e2f9c26dee58d352ab497601a2e37c23053032f9fa0d0a0b7d47a23cb4895909e95953312447a41d407b9ef46013834a1591b53b773c713ed71eb83d73a533dd2e333ff829c3ad64e9e86af12beeb0fd4157ff30593680542ce339a6639a2326ae1e84257ccb0986aab6b5951fc299da02b7cd8f60e25d2736c4b2806140c821856b1d48286300ef71fd05e7afa8162d84293de0fa9436a792cdd7ce0e628704c3bd6b253d4375595724880b7e3a64760c16d5c4d56b0f154f74de0ec6445e7a16b48eaf769bdcba5db3f95065c80bd99d998b4e10882c7937b22d225ace6f4eb2a9e2f65a14e548102a2d825a4c8c610b52a84ec90e4395b2ff75769a2e40ad36b21dab6a0adea0f84976a743ea0c940ffce90553ce65a782e4a2768c81cc5210e6c54305fd7f8900faa4cf9a41578de5f9b825df9960f62ceda07d54579894b8e445e52e3d21ba4421912732d4c5312c71433add363382fb5b18676d2f98984f39460c2d8709384c877a3f39db14226d20f0ca2f85d60771241946c609191aff095d10d1fccdbdc79b14f81b2fbad054cafc3c19f80be82a6db207768a694be09eb91a1dc6f705bcdb13e02f2bab1f735e95092f42230caae11b056f3a22eedf5e3d2e846d4b6b8c160b7d28c8553dd058c249fd420cf0d4ab3421794decabe70dce14fac7652ecca8b6a26a619be0165c4475ae176c5a988d025958937f1624fbfc8a6fbbc9e060f00444cb0fbc3d4366009ab9d327c07b7b1b14b68286e22bdbe1ffc431f",
        "signing_randomness": "a16b9c502cee2778ffaed5e9d677a96c264b66a3ec236b4191ec9ba26be90063",
        "sha3_256_hash_of_signature": "8bc9f2f6152d474e40a9f389c762bc537ff0f94ff1e4d045037c556bf0fb8c5c"
    },
    {
        "key_generation_seed": "ae01259b67969884030aa866bd637fd9b74c1e543c10802eb7dafed6ca7feea5",
        "sha3_256_hash_of_verification_key": "a2741a9d5e985082826f4e84d57459612add8992d105f74bcd908a962b9d3ce3",
        "sha3_256_hash_of_signing_key": "c0fb2c7c3d504a2f9c7639661a9c0f956923138b004d7e7ea854046f0775f6d7",
        "message": "7cdcb1988469ff9db96cd504cb79828fa51b93a1a6458a20b6c95edc3c0199dd6fc708c0e5c5d6727008357f5627627c9ceabc87c9a16b5c877bad9cdee1fd20e437d2a7a8c5865c76fe3590919f2d32ee3778a279fe1c2581d2bddbc3a5a57f14b9c85c716c0d09f4fd47b6a2d7d1895660ee7233dd5c0aa29b665a58389733fcc74fb6ccc4ec209504f012475b6e8f631a5f41e90b638b9b32cb3406f03780a4656f553baa6084b043b1c782b523089cf9f5987df0a05ef6a39ad1c1476a6a31188864e72801486f901a564bebfc13b44dbb6ab2d65c6043712a4757de2738c2503301e43626e23db9b8e443f9d616baf07a6e74418c0258e9f805afba3b7463933484d8c28b173cf4fe8a4922ed4f11522dd7a88963d869102a276f803607232074570045c29a2880bbdb286ebf55dc147e0e00472242a77aa0c06da9c2750ea5b2f247ed4f8bafdf3271b4e04b74533762f1340ab030f3388db4c5c2bb713877728d1244c190fbe078f24368ee53d2ee86b7d5ca98532f20ed552a2cc4a7affe4e7c691dfe9a28cefeef2aa090f5a5679e28052bafeccc2fbe6428833ba160cc67ac68f16de847fdd2cc551271ee12eb915d20a781e72bd0055a66595d3310f103a077c81e4eaa9051e98a3c5cde5deb2730d7e40539419f2102c42845410e4cc10c746192db72b2e81e27ebbe0f737333770077e9ae10593271da537a20dcf1bcf393b18cebba1738395f7fc61d9b4ea42f70e1db7b61c4c378c41199d4dc68690920321cc7ccd9d78a79cee5e735f19424948ff550b49eb778df06b3a51bb78b4c63a8e2523d76331ba93e3225c32ce305d3a2553295e7cd3117242fbcff275c8f102646e07d2d6c3e6ba65df2873339bf23e0b849503781ccf7dd0cd7afc116e23b7cb7787fd852cee0c71cbd4b87f2d3f41b84c7768776909942d449da6dd507a64a17c94339f78f8572853b2b71360541",
        "signing_randomness": "da07f8644e779802987142d99ae9d17a346c21591f821149c7b90f16e5f45826",
        "sha3_256_hash_of_signature": "975036af69a65aede1f31b9de32f379e82fbd2e32624d8b758d9be0b66864a33"
    },
    {
        "key_generation_seed": "9e2695b355db9c4ccaaa93e83fe73eac3816040495ff59e137389fc7733c2174",
        "sha3_256_hash_of_verification_key": "89811c7110fea8026578b21922f4287440c78686c6841473ac211c4519095a23",
        "sha3_256_hash_of_signing_key": "471b15f5dd68e526cc6d044039385618f4e43fd6d19de9a62b1f80c93df5a1d6",
        "message": "10d663a9d600ab43711e6212e958b70c2bdd810a5043ad53d27fdd3b9cf5aeda5fcbe32e5912dea51abe976c11104468f74b8ed6d57da419ef44670f286e9b39b92e04b8f023c6769d1f56569a27816a0297dffea66d28f02b5296f4f01c0eee796296495ebbb7128e6925f161d4b31e01b3f5477c5c30e0351d56a28ff820db95aed1a892537c26386633bb548a27290b3ab5f25a302ac8da62c3942f3fb1d80252e4fa55bded3e905f1a8236672225698ee543b84ba7cdbb4cb88ce206a224cb53532d27463e276cc66afd4077105809cd4faabfbf87d25b47df4f34e64ba3553d944d58702fdd99ac478458bcedf8870eb57dad725dca851febe33f78bfb0117fccf0038e4cd8f8d1692980bfccc1fd5d6f8175bf3e211a636c32e6b8a88ad294b7037e37a09a99056721851cad452a53b1063a6dd85601ca6537d36f7e06bdc3e706738a05c740c6cfd07034c693c05c352115132bc8a510b81365d224be760a703f59ab3b6361a877f9d46468ea4cd57ffb8e7a5f2b86d3f08510cd9945b80eeac03af66818fe027e7b1e49d0baf57421befdf2b802b29e3c96b2318ff11bb20163d0f9de65c25244a3cf36229224f23ae63afef8c5fc32fa18958334ae0a36eefeea78a241c32568604e4003cd7abe65ef05fc27503e82a3882824667262e8433685f49a524cbfa4970043ebaf46d2de88f719e274a0363ca2a7e96c2dee96a62efd69c16010c3ef9dccf8f0924487c45586ce04909dd6007a0874bd0ef5785dca4da901cc1f750fc1142ab45331aa3bd6da055a0cc8b24e7729025e52fcf65b8d5bb8ad273fca44df2d8aefcba3bf338dcf34e9f6f0d11108237c00ffed2de33feb352af301e15bc06335e7d0f83c19995d4c1a5eee929619e550193de57b70f6f8560ec5a6d241e939ab0b65e5ac159ab2a52e352089ba964f00c9b597dc830fb5ca2da59df616e197cccced744c3cf17bc2a68366df9668546808ebbedbfab6b65993d36d8becddc413479dac1426021f87",
        "signing_randomness": "b7971fb2a3f07538e428db74c124750deef766b5908e345e360ff56e904e9395",
        "sha3_256_hash_of_signature": "b7091b3b199327e48d7dbb1628ae4bc22eabc9ab701dea5cfb6c39a0c86d6517"
    },
    {
        "key_generation_seed": "f960a0e155ce348a51efb0b9c314320310fb19fddaef4d8f6779098ac2733dde",
        "sha3_256_hash_of_verification_key": "176926846994dfb69b70e7249ecff5c18a084a5872f2b44914f5f042b35739b1",
        "sha3_256_hash_of_signing_key": "71c9f3876baa68df05042299362623c295e49b5578801365a3b3421fd3b73c8e",
        "message": "f64cd441c3ba9aa063f2f9159009054adc3ce0860e1b811c34e78ed5d22c48114a2d576056d514d46b5a4180597c52c2f268302356566d33db09c4bfae5497aa1fc6256f09fd6c2ea0487f326a879a2751398a656355b9e01f0687d12efbe370eec8c0c5afa499366d1c2f4820403becd1e6b8eddddc8bc1196f07800da34b2b74268f961459178812ee37f28e2b871b293f4f86f6c8782c6c838411431e6fbaeac6e0ffbfc3fd4a8b1102aaa5dd3d804c7f27f297b50c7d0b6e476dfc8f4f2aec11b9af399fe8b59dcbe6db34ca3a34033dce02b9853f13b01875e12d8207519f2368876fd120651fa79a11e11c16435105f47b88fcba756bc16bd0f1bc32b03bfd968e973b774ce1c6dd847be0027c88efc85d1992413f3b28558a73d832e60fed21190c758f62f8c5e1f0c3c0ef4319c30caf309678c335bafafc568045d59907f4d0b4b9a6c417b6d0a4188f61e7cf664d634083f87043e425bc65d5403467411e8ea70037fddbd55857b1a3a95088a575cf76e39e602f751a1081f8cb9800a5e3493f6e5305cec06ce6361ba437d1075ee614860847327a16c6fdcf34f5ac4f55c7501ac8e566fc3d58b1313513793d659b64d7e350579f000c8389f9ccabedb5859c3b8012b8a3d99c554bb2085e9c147f38ceb83099df4ba12d349fc7de8d58744c64219a9bc4fb79de45902d74c893f8656c4a4ea592a16ec25fbdbe290fc94f7098d3318f1e7122be03bd0784461b38b3de400e6b0dd5d430b5b3aca5bdb109825205aeb9f311ae5db9b65d7902f40422f46d992d4b1849f6559f3c3b54f9c9ee6b8243015e95ec5e5c0e7b45dc71473f8e86caa0a46e34962bfc2474bdf3a65ff2ad0217a81baac70bb387fb946cd37fa264e5b029b708a4dd373e6177e199027e5a685dd0033fe80a7d8a7cb605fc05a0cce2973cdf0b1d4e8e861ee4cd9da69a4a5ed0158b9f6a8dbf37353f446eabe107810ac5ab2ba3b4776e7db327c69cc01fd20a7c305269038e7b4caff72cb2efe9bb35daa0442f95a1cfa55879085e077ad7a227e36e3169094ec41d27a0594c70",
        "signing_randomness": "af8657c9a424b3ae1b297ae40bbd351d6343ec7675f082d2bd396d3359d9e193",
        "sha3_256_hash_of_signature": "9fd963b9829455902c4617ddf766b974e48b5cacf6b78b3da7f17fba002b14e5"
    },
    {
        "key_generation_seed": "151cf455fdb5ae8d67ed8da09dc6aed58e4103d72a61c31efde4c9712a455fa0",
        "sha3_256_hash_of_verification_key": "0fb0fc8c7cf95d6d21ffd7b0074718881856a49f64bc3a8b1989318ec12f7a4d",
        "sha3_256_hash_of_signing_key": "c0c7c07d2510d7b96896388f4f3b0e05ffd26a92ab2519d496d34e57164c4f68",
        "message": "a215801dc102ef6284b395f7d3b83857a776272032135a3f6be98497ac41e3e1d0e1c54927ddd28b79267aa465bdf8a4ab251b44fd0d09972ee396c2366bc1c5412be95874fc59fd0e2ac517c96515709f76940d2a7180ba2e87a0e4b3cda35e35fe32ea88f29fa6bf5a63cbf2fa796c5ea0b5274ac49710c849dabe82b9f20caf7f1afc6549c98e0cc733aa9c3220157790d8eaf1571cf30895b6dff73249f594c27a78a9058a2f3918194130b7a0bd7b042f760eec0e6f67658e1019ab230965907b3d28898e88cb44ba8eac166de6af7e34ba0b91bc770faca6c7a1e90b6267d74dbabcd883ba5484c8c429a90da31720117ce632dfdf97b988b5861bc512f74ce3f532f3c5e21ce91d733b5e93312aa98cec4c13a701cfffe91ded3a330b101267912f4dd8f940cea9f1e1d1ca8dc6481e13a5255307f5ee67e2b2f06d718d182e93da3c9051b515efeddb70d0a066324eea1c6890aa34730aea5523f3c718700c34ed5a136f3c8691db15d845df47c2993eee485f057fbed72a605f0583d29201337143e035962fd214b26326d2ff2ede0ca9c7f91121442d259a9188aacbf7efd05a02868ee236851b1063f1795ee110ffaa0f61b6104a4483292b0b538b1cbc279c502effb84c3dd6085a0c98c1f4ecd57732b58719b4295576bed4a0856443bcab5a4d4c91819d0e2e00d581f1966e2f41120026559527103a948daf6145745740d43b50d41d81888ea67f8db5fe72232ce6c9e5761b34e6eba4ed1deae88224f05c6b395cd899ea4b7b1d9095ad22b916af60d539d74624bb7e3151a35e441d588b76792bcffe142400b3ca3163c41b08e5098e77cea3cbca37b4006eb17d467fd511f5e42bbef292c203c61918f50cd4ff571012081efd42a2d9a4c7a19962c92b5a32a3854bcac440a175deccb29758397a1adc32b8db5ef6d32fc329e660592de57610efee0a1eb7759e31cbfef105b7c342c6cd8d9e13944b70ea18ef71fe55a85aac232bce0561616a3e53c7e51e435ba73f6dc4770ca005a388ec5f84df5e6eccfbb1f38ae85a3230c955fe26398cea47e2bde0fcc41b3cda32fdbd437f4840a76faafa649156fdc0fca4b646cfefeddf",
        "signing_randomness": "117728577ea48b12074d0e8afb58fde449353c5f3fae18ad4c2f87e248b87ae8",
        "sha3_256_hash_of_signature": "254e2594d2164061c608978a6308cb781669c72b73bfac352f1402a3bb66510d"
    },
    {
        "key_generation_seed": "e3143f07ae323e544c4ce90c50f1bed30ae22ba1859732364a992c49df6b1195",
        "sha3_256_hash_of_verification_key": "8d8eae127c61e61184f1378a1ce3979df5e2e1446c4085102a27f150673080fe",
        "sha3_256_hash_of_signing_key": "e048313f002736d105d5db74d49e509935410fde0574571ee7944cacd19efbc0",
        "message": "ea44a8cbaeaf875a28251b727a1b5acdf6ca900af5b467fb0818db49fb95cfba8f2d4aa172d7c4adb153a8ce8e7960d1ef170f33802df3f66d4a89bfd8d743bb5dd063ff16204a24aa63b9e73fe2be5f9fe6645831956862b8b77b9f52376753bf7daef1902a8fa3a52316b5e5c2b60cf0282e808c42896ccc3bb94de8c085a3b036bcf53f3261853613c1cbc8b57e6ce7332c5b5bb366372f59c206e5d8b36e9f44fa404033ffac8bf25534cf59018027a4595f615f40bdcd89da6c091579f65e80eb01b18b1b7ee3a5b9cd170f0e0afbabf3e850e577c0656860de28b145df1937d720f857582ae81b576611f77699de17e2e8f20667ffd7eeec80984e7e8d694459b2085b557d1a4e56e681388c56c27a64e1d5043ee5eb705c3418d956718aac9b02b14c274e11353b5f485c10de1e99e52bc0a0052c7dd84c28ae7b314c08da9e149177f1d4df283e0d10f7b5bb59c111f3737f9ef6436675d52bf2e4e6208d6767b75e1a6cfbf8b6539740c534a82fde72511c99adf9f06428e11edf2636d1512ecd65f9668600130d3dbaa496f05aaa5e44f0d50b043a4a42086ba9602313f29f54d804bd2a0c1c81150d00a120db8fdd0e939643ca1142a4059a6461fbafcf0fbac3d6c515deb0a5b5a5da0bbc3331af0bc7a6fc204e51151717e7fe5491cc84f9ec76dde1109b21c81399bf9d9557de379092a5dc378cea81a97d07017d68962d54e75d7ba1c3832dd7e3d4926a5f8922ae3dbf06af4f531acae9f8ea37b9cffec421d0855f88be19b3417a27e8eeadd104a142ac3381b40c11880397787e3ca0595806a42af6b2f14385c9e4b3233332eee23e09be4557fd42d519554694a8ffdfe1045461e82e07689dc3fb868ca5eafd603df7d4079dc62dbd22ee9982cbb95b9ffc1ecc43adcf1675a3903098a8a2fc52a55b9741ad2694853f92869c37e6dbf6bda03ca24704accc0bcb5a50b83f04e7df376262abd6777686a2358d6b02978cbce4fe6d5331d9bea02ad7ee49ce5166984dcdaa9556485b601686ab53a4e75034e5d27b88406852d622255ac9207331dcfb2eda68c9d259df0a0ff14df9e6d2d99aec86de2de40f436f65e7d6e8a7484e79ba95d48c7ebcdc4abfa5246c55e7978474af60c5fa28de5445a6d951612d90d5",
        "signing_randomness": "182325c546153bd6ee6766a3334fc9b669b69735807caf68cb26f3b9241566f5",
        "sha3_256_hash_of_signature": "a10ba059af931702dc67b4cacf875b921b7658590c2152775f0ea667a4ac7558"
    },
    {
        "key_generation_seed": "f7a37b846380b2c975853da0da4f136cd73f48dbb3b922f90fd0c5a074a5a265",
        "sha3_256_hash_of_verification_key": "6a6903a17d16396030a4c93dee45d637cdc82ced469619e8f1d1939451968942",
        "sha3_256_hash_of_signing_key": "d2e5c079f283aaf7cd2795b642b4a6f2ef8f27fe444f06e04a78625ed7eb96f3",
        "message": "1a2a36ef1a06da8f19008796c7e367cf9f460e365047ee4796c9903202da22b4e5cb1cd8cfadca5bb67f343095b13e22f1dbc223a9e6625c5e9b8cc9ac53073cd9c6d62db2c5b921df3cc7675502ef132a73b27495a7deb266e139c7d2dc7ca6de6e1738a99eb9e0d0a06caca005476499631054237da18fb057ecb8dcf2a0d58aa7b3cd2405a5ca83e6d2f752d3e8b5cdc4aa3eff5a1e5a279f77a8ea5e81672bf763acf22ab62efea5eb158cf562b221d76b60c14978503382493643cf1a3f6fdaefeccd68a489280e9f2d128ca5e59ad080f72677b6863e06909046f11d6a480470281ca2a04cb5fbe49364cc3511a5cbc6ea95e9b8d64986d41b0fc49a0fc6c2ca39844afeb1f5a7bc4beff49e8252858c3ddd1553ed1bb3f15c514306edb55021941cf0423285d5d1f6a6584c97b7ad7dd29f485460198c642180a4fd1bedc1504c80b92d5bcf16ffa20ca186f857862ad14aae2d07135f124daa90cc16fd45baacd3bf3e7c0e36b70eb06aaac0deb5e53ced7b71dbb3a51edb1cf5789b232fa930ffc9aa64a436af278fb8c089a41253e2ca0df3c366955e2d5bedcb3d1282733673929a351554c7358bafaaa1ab6b3b398bf96e9e70ebb3bcb8be681221fb0d53d364339da7318e648c159ce4a406b5543218d669313aadb522ccedc041443f1bcb0c9c831c1e5dc64f7bbe244903a5fae3203f28e034ac8ef6b479dcf7aac9c4b7103704e6d0fd6ba352e76b3f4e61513be2ef83f645c1aea54ecf174e20dba1ab00dcfbfac2c324418864f02331dc7d4f3acdaf9bb707f4d08fdb60a0d2444f0b8c8976ba9006ba1fc7150bfded71b95f20ada0b1a3959af769af3dc55f53bb0a2bc0bbbb812aae2d9e3dc5f3ae15ef62d584f4fb4d6c6bc2924e88e2350975e15b6aeac4e534f845a300399355d3147fe49fb1fdaac7503f60c405f16ecc518124a508dc0729a1d21c5dcb17b683a5d818df3cd3ba3120e63273d271c0b2f72ba9eb0828c820fcd77974ac35623952ca3e9268b1b62427e91e0791436aa6a9d81805c0bacd0afda5fd4d55f1ae0d3ccd8ae6728777ab35b2efc0dd3ea2ca489dffe9d42eea32ab51b995d615661b6ee90a3987709f187a6f68fd28752f7060e453f669b75ef9b30247413a0020b12540521504dde6038103faafc9701a327df9599003b5f46446b81df10f9b54cbf6d2628a79c0e1",
        "signing_randomness": "649fde433f806b409f8f4b8c5569bc4dc11abf2a08c5d267561aead172e8a7d9",
        "sha3_256_hash_of_signature": "2efe28ddf8c0c78d114f010598cb4a83ec92a1409a654b13f17556b847f6c423"
    },
    {
        "key_generation_seed": "8ea1ac92ddb7a818e08eaa2b4f56adb157c1cc4acae9ebbd3d0c3a39c1a84186",
        "sha3_256_hash_of_verification_key": "b3918fcb29d134f3b51e06fa7dd42c74b2a8ee916fd36d926afd2e576e6ebd33",
        "sha3_256_hash_of_signing_key": "35084b313a3eeec945337cc7b085c8f64a507513748cb2a09a3e23936d7cc48d",
        "message": "b7dfbd4acf4908a7be207da7da7bd7ab0a731db9c48849fc5e5ca600eff17d171d0e8b465f8465436e37b67236a5050eea516f135d0f27737db8cdbe3bfb6eaf9d75d16fc66189b04b6e547cc3cfc2df754e53fecb39e0b8357bd07e2175542e27420e41f6768980920976ef1b6f4f8bbd20cb5224f4edb06fb489eb501f426f758dc921fb8efda44dbe6f7e9c6d34af0064cb7ca3291b34877aec1ab0999700893ac6d8cc63edab1b6aa5f68316cb1713f229f89e64da6aa70e2c9be76c6c7f8169ca2f142dcd4858b695b6e5d8671c8b5c734d75d8264ef9e772eef8e21c3add91318e6fefbff293685cf400a6f6043ac2559bfd23b31e4f22947e29b2cebf07e135b16ab934efc401f9a11f2e9d15c7e111efcc565e18a42f51222aab097ffdbbc02b1e5ee91f5e178d62e5fee1c9e84fe13dd77932904d8cb1f15e58d1da8f4a4168bdcc90ee02471884f9b4775c38da4158c36aee263e4abc495ebf15164f0a53d608ac6d1a10a697d57c485fd201a26f0fdc0398295f9c546c7496f6ff7a1136b41f3f22a9d32b68779abfe01a750ec3bb1bf539943f69aeef3e55a727209b5f04bcdcc83f722260e2649f8f88594e03e9797a2614377a3113f23779ec0f6c98aa6e36b1160b23150c38047c09fc0103ef87eb986df855d0bbf17cbe114b5f77d9a01f3761f234b76519a48c4e8e24c3a191c0134e9b35bf56c35246ad86ff0bf8def8c21a42170b0a0af65a25dd6694cc1f8b98a90d2b35b2fb746efc6b7575a895d44fb8204c6c23bfb50148ddba7b189122b8e7c982adc3d3d11c7f023f6f6c0deb54c2f0e7cd6179bc71d12c9c34765f85b55f26d2adfa2837078593621067dc8949e2a6194ece084c7e9a2cf57327f695a58bdf6e9ba9c507b785a2e7c5f51276512cc6c8a3ae2dc5ea3457e6c589c1a939272f535ab1c98e8caa70c0080c136fd3e78c736e65eca831856bd8cf26f20a2c02b4a911fe129d8bc4f3f32771301d53549091c1d525cda3e7d90422d353f5bdfe345a152272de8c999c8d920fa1ac17c05fad3eae02049a4cae0295ac46bae8160b6d08fe8a7dce778442f73300aae376e75b7a972588183381cf1b1edb0fea044c7554b4390ccc302f32e549eb18d3ef98545e2320bfd9ddcf77cfd23ba2fbc69fd39d5888ec580f88e8d022a9d5af66381f51d33361847977d8d375269bda97cb596fabe42e89f8a98293fa483f1d50d7280de1907b81d7e9df5bc53e2bed1c6986f8",
        "signing_randomness": "7e88d1657a5b59f96fd4393d23922abee93808b32fc218b08d36ad25dcbe5621",
        "sha3_256_hash_of_signature": "6a4fc0d11ac6488e49dbf34dd35238850c954c32e4fdaeb4c05529335811fdce"
    },
    {
        "key_generation_seed": "595245604cb45a94b7a4231626b6d9a53d4de851b122557ace8cba6c32f6bf7b",
        "sha3_256_hash_of_verification_key": "5445dcc84f1719d66fec93a7eec43c8cbd3d717cd7a48f82c491bc03b6920960",
        "sha3_256_hash_of_signing_key": "7c93d12b784f4befde48314239469ad46a7fd0dae2064f5d7747d9e5e5b0347a",
        "message": "d6c1b44070c6a76a451696b19d23fcb1e0ef45dfac111c621ce26b39504ae804a886c3ca264f460d8134ef04c21587be06a0d1c51543f946a9597b155942a6e746675ebcb0c0236589ddfa1d6e614dbb12355a94374beeaf3d6c9de898471be4d70f9c5baf1da3a58643f5f7e2d5299dd49862f9ac6c5df0a54a49c3419a1234d6a5e7b4936c72e53a8a655a26194404ad316f873670571be3e58f328fbbf04848e1289bd76095cb5dfdebe05938651356bc6f030326677fd6b9cdc8e9dd78f7b88b3a15373aa2b3ce10e0c47a8ed0587dccf26d231d154d7a630d914789df820bfe2cc9f1f3b35b923f500fa0331179150095975a0cf82758ca0325d2152cb31a2065b6129fdb4c3db744c53d278fbd3f9e0c7d886eadcc21ff5ef13f0873de0ea2fade8ad5a83a36d61010cd8e6047d7f26164a53de25544e7f07f77a76e0e3ff61a10c90341e7562b14645dfd8841c7f1347e85d2c9d9b3eb366a2ebfd79d0534fc3c43a3f57e5f771bf6b10be30f2f0ea2c06ed146f9a53114dcb52bf061f6e80184df8e6cf1ddec35de90ae8826f98ae37bab28387907c0ca6c38c0f0df155dae78b21d77d2e8a4544403b862d1f94a9d4c8cdbd34375483596ff7aaabc1239f53f00a98a076dd83c58930fa148d98666540601a4b48d20a42273511f427e6c9aeaafe6b3fa3db921180eb25eac1754f864da4a0e4f58f6adc5674dbfece189c47bf135aa066813a1dd129debc3a763949f75d5e7bf1e2556f888d7aebbd52401097434d67598226c2da666010976e60526ee1feef9cafef4ff4186d9d5ba732146882b95118a1a5cf04e7129ff5fe2e28bc10071a1d25c283a3eb959ae0ea518efbc62fa898cb3b6b57d14a6dff5cc9bc6205f65fc96215f9417b77e9626bf4f0e911e9bd1e1a8a51852de13fe5ee828c349ac52491e33c7ac59057c009fcebdbea9396de5a7bf5627830fdc4b7f4bd197311749c53cafc46e919f0aa7f5c99ba5c9aa9048515b364a9cf339e001d1d01c96e47e63cac841aa37e884cca392cd8e64ef66b6603f5158b9b1fba92b67dddf355d74ec30209e074e4b6161ec2343f4417bf56e8ee770105d564f9dd026648e8e4af04a0cccb94a8cdff7b7d9354aa9f4cb8d98715a5b11d30b5478a4f5f7efcb9012cb654af494e673aec0dc666d915ca90a61434ff571b55bb8295bf2780297f5799a93876df1d8c68e4fb829d225ebb9fde10eb411692930bb12807a98b5d40bb6bd448dea15245e3d60c59435dbc9062e0bc0fdfb6b0f0739af7030f4d9cdf76c6f020b538b",
        "signing_randomness": "a1c78550be5c7c9495f8f46cb009df8370156728363612c2135b8fa7efccffcc",
        "sha3_256_hash_of_signature": "07a07236481037455f119ffe16046d30daa0c4a0b07d938ec55362547b1d0de1"
    },
    {
        "key_generation_seed": "2d45afce87a35935d2898622ceb93f5f0ea2e45e59defde4fa202df4bea8563e",
        "sha3_256_hash_of_verification_key": "21cbc57a856ccef2f7dff6e0bba92b794019396bdd629682ff6826a1c56ec787",
        "sha3_256_hash_of_signing_key": "4586148da73af229ff5817882abbe8e94f08f90c17e2b9e329ae5cfe258e322e",
        "message": "edb390083f5f62aa4c1890f92ff012569569641ef723318da65d1ab510a1dd74b54d0206889a36a94ad44c0988134af94ebafc36b911fdc1c042d018c0af37c598218911aa4a1091d320fbcdc8daf56470103efdd87ab4e669ffadd779e6edb2a326078e24ca6127155ab793c37b564ea674c661838154ea2562142ebd0f1e5a96168f44fc3d79187c1ffe673e96862da313e9587ae008032c8aef077741428b615f3dc2b5b97a69794f9d580ce7ba3d02a5ec35a673efab5f48983a510a63baf2cbd5d46127ad7d2572303dded20c116a8f67f41a9d20525b827742cd8397e254c5cf4ac1c8a0ae07e599595c80c6dd68182112425cda572b2b8f1789c022ee883b01bdc17743e0ba4e73b5649b03db290c34ceb8abb455f1ed0974e4d940c2e2a58f7600913c81e47346e733ad66fa9ead4164f064106d5576370568c79c2d02b30051e2b1f7e13f082ec04de11ed873af9b259497c68e2c36d43de94e7f1a7a5c10dd5a392617f6926d6e618ae30e3a52e4ef9260b9f8bf0cd7cc24e01f1afdcd9a1ca034ffc74f04c71762a9bad87aab598e2cfbcc7e404997641b57beb80532217c97b6c22be9889658c9c42ddec329f0e6ed208652272592df2a7682facec5e507fbcfe7631c4783867cc89401049d0404f2071e0ba4c353baa8755ffd3c21c89a5a9561f25dc9a4d14d2c5708d225ebecfa40b1e2484c81e8f041e2356e1962cd0363f4c1410444152273ee8cd87146330df8395dfe4c8b0313f345dc9aa7e277d28440f8dab7254ebe4528d114045cf6f9d7b78ad5eb4c8379a09cc5d7377996a2e5bdbde0b55961fe0d3279e1217ad9a8672e17c213ca3745f768aa9c1fc635adbbd2f6e7d1829d8915bf4d8ad3c42ba96d3d3e27f2bf5c476e3dd43b21d3c7aae584dd80c6a45f1ec7d2d52628d8a8aafdf9b5dfdf35415868d95692baaae03ba3361d1aae4efc5f3144af011c5da71392e7ebfe795017a67e6ca3eaa6ebba2fc36358078e0d9ec58deff9c5ddb3476b6468248e632be4159e8f63c82c310001e71760ddd84fcfdbfda28c702d08f9c38cdbcb806866fc3ed58e5d9b24be94463337f684b64403d068e3f0a7da4c9d22f4af8bb4f74e72158f14f33d9cb3f8a90b2bd1fd3ad281256ffaaaac3b90d305f482716379c0ab2366d3f50a4ffde05ee9599de60352955ab8905073a3d5fdab768ab86d5953b0893c5e5e015c0eec9f4babe214e4a68e778cc038907c5a6fc46125c83612ba3dfaf7c442d329638a213148029fbfb3ae16e5565830120724a1b4f2e8c32f7d9a5154ef0677b956138e327fd54d61c8fd344d4a05c5da0e41c9c1127c5ab34b0034",
        "signing_randomness": "e5421e4a47360d2b7c402dccf38fb36081aaccaf1035e61c710f6d19b4168043",
        "sha3_256_hash_of_signature": "5cbbd06354f9d57d926571788a4b38db5bdf23cf952cfa155b507f8db3567d33"
    },
    {
        "key_generation_seed": "ce456be86536c1b9e27a2220290e12e7faeb4c4c88f99bafdb68f6934c7d3193",
        "sha3_256_hash_of_verification_key": "f7574027d464faaed2662f2e0e8d04db0d74529d610c28e813d9b6fe5b03eb16",
        "sha3_256_hash_of_signing_key": "c32814591263340903b0b9e5d4e0e48a9c4e51bc25f2015c14111f9fc687002c",
        "message": "52b7f634b197e47c00cf1769e6d634265b4535e3b2878d4bec419466cf29fa0f76e0462f12620d21f956d58b2de98032465d191324fa0990747c0ae813a2e1ef4d0f2bfe509b81da2bd103d7be6909f72d392ac1f483dd6c467841cd02c8b7591e296927916c59dde00c04e0950da6c6494041e186efcbd0972283911878451e71fd9a40d0666a591882603f029e03cb6f6f4c03a0303bf9ef5515155f82d79ff3ccc95e4c91e1164ee4099a5f2e339c988a018a35c285e6a83bf132469616f0f58997e3c11231870c5500628153efc6ce47f5328df63dfef16d26c7d047a01f889dadb62d67ada831b33c673501a11e75d6ed3516c81e1fe74168eecb85411bc5358b31e30ec6301a3dfc995267667bb9ff218369636f790d36769d552a6a5384600704effdfc22da15f0878244d45b44dd1651d95bf562a7f8cf28e8b7adf02a1f4bc102ac5f09a726fb990278f3d6ca654ad0a1499c9c9aa5e265b427a6ee97f8879594be992f5c8fe62fd9a31c2da867021c10fa6a11792780b3f1a29b1dbd13b080e6107b71ea1f7cb3e0ea2e1a9fc1127c89b3c50c81eeff863dd813eac2b52486e257b45f80bab91984888f284f076b2fefc90c497c6995e890f93364cb5bd6cc892539d5e45eca5e93246f1d9a93c61875b1332cd3aac825ea1d5123ccd86cf513b3067cf01ba259337890d452d8b92436a311dbc143cb0f804ee8fd27f7050a0d99988cc8e33ae2d9c7655d20863fa223e9a7a102c9f4e422a66d908b9f26918b707b6746c56ef29744b0e7b1b17470db2c629fe087437ea2cbf2700f4fa66bc25925ba61fef4b20befcf70630b8361df63011a2f29eff24560a77b14b3ff55f4e7a643591cf48fc5f65838c713438aef2fc01264c83998600bf0b88aa4c0bfa4de242bf0c339b38d4288a55bb1ca818a313cc31282580b62d930958142f1e09880019f79d09d103d2471894622b78b73950010ecf609e0d559446ce43abb16d95287cc888861648ed902b5d9d8bc181716d05509b52b3ad08dc3f78599611ef53981885656d1360d0516bbd451b28b2785fb2d6d9d37de8b76427e5e73c4abfc99146dd2d717c18a93a31abb45d4e4031c586e0851ec27d5ca2ab3908b80d2aa5ebc1ac3da7036ebe6f4e3551ac4a48354410014115ecbbaa1b5019faa2f26f6a75ff5fb945d39a4f0359f9048e2dda41eca3ec7ed33a7a471f63a7eadd754a0b59d5c9e6964c4c2724f0e28d427a86e1e7fea842a2183b9525e7df25a3b210d7bb4ae13ae9139ec6fedec759032a0d56cf19d0fe01c0e4f9d4dcf36f1a31b1be2bd432f25fdf3cc5ed92adc7147e1e5d979f0f14ee15bbfd549688f458059fd5b0a7f503382913722f0030f7ae5f849919159681dccdd5e27",
        "signing_randomness": "1f6df8ad6527dc2ae361bfb40145251b321edc715ffe1af51de1836fbc6e2770",
        "sha3_256_hash_of_signature": "9291540d57e38bbfbb336d9b277457527de8fcb74245ddf6eb83fd9b739c36f7"
    },
    {
        "key_generation_seed": "56aac31e173d6ba5fb02b15068ccf73565abe55548f15f3c79e60dbb30eba062",
        "sha3_256_hash_of_verification_key": "75eab31ad17da7d19f0ba8ddf688609212cd85be7dd6d3fc080b71b0b0e3b43b",
        "sha3_256_hash_of_signing_key": "4b5319c86ec40fce9f65c4ce14bb9f42c5450fbdaa3f4177040e70f7fac93358",
        "message": "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",
        "signing_randomness": "0d9375a6323a0689aba6193bc04b4de406086d2bf5ce263d15dfa4f16dfc20ff",
        "sha3_256_hash_of_signature": "cc12babed76f6cd861fb1ccde47e8f84494c10e82eacb4a9960f92127b104827"
    },
    {
        "key_generation_seed": "faa51c91d937dd53aeeb6c1354e802acd9125c4683bd978e8a6d257e083d23c8",
        "sha3_256_hash_of_verification_key": "9532a08013c97879b1731a003ad23aec324faab86fb066eaeeeca2f03c7a607f",
        "sha3_256_hash_of_signing_key": "1e73c1c0e9e321d36cdd89ac01475ada72094998f6c14ee542913dbc10430333",
        "message": "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",
        "signing_randomness": "4de7b49bccaac18ecf7746824162b1184cc687ca6342747b42e732beec5b9bc1",
        "sha3_256_hash_of_signature": "7247463ef7ead7d284c2f12ac07342239f3229e41d29f20443a7b2483b7a84ad"
    },
    {
        "key_generation_seed": "c9e7b84385dc45b0fd5dc538b2f8fba2beeca17b262bf0b84aed36d81f80bc42",
        "sha3_256_hash_of_verification_key": "206d1d2bf26a027ac30d32152ef7d5e89bb655236c0bd52eff9b0fc3f077d7fc",
        "sha3_256_hash_of_signing_key": "774cdd57e1d686ecb36b4a8879ac8a181eb41cc5af3df4d53a48c97934c9a494",
        "message": "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",
        "signing_randomness": "22710666dbca2b7b2bc0adc40ab62ea39aa309ed884006ac13280294a576ea66",
        "sha3_256_hash_of_signature": "c9cebf774936cf6978b482401d2f17d32c329b1d5a35a1a0487bb286b34e98fe"
    },
    {
        "key_generation_seed": "30d2124c4d58313b3bba2ed5cd643b9fc41a40cf67edc5ef2a962fc71e5da320",
        "sha3_256_hash_of_verification_key": "942b631a53a442edb79e0a970a02f98902fbd4eac3e0eadc57eac483ae83bcc2",
        "sha3_256_hash_of_signing_key": "09e6121a05e31210211edccca85022fa3b1f310b28ab3db13af3b2eb38dd3f4e",
        "message": "39a3dff394b992374e02b6be191f3198002ed81f8bf6d1f49504b343472f1e86406235d017b8c8db429149d4b020a65a6e4000e22d4e3dacdb453af8bcfd213831b4b481f8e48a454162480d8372c85bf9f19eb0fdb8e25e146ca6438f391818422b69eff846cc972d896ccac67fb98c49932cbc22e6e0c6f9ed220bf388a2f87a1614fcf65ff2b37fe7d25f36b98eb5ee555198216b1745f008ae04430f4f512b229f91f996d138e03d888433727bd890f8194bc26232cb99330c6399f63fa6a61f56f298a1dad75166de851ce638524c3146c9cf4f25c2d48f839767733e610c04f9ead9b8fcf63f55acbaeebc9bf1ff9210de18e3cebf61cd23f3e749b575fdd9a14aa45c3db0fa2abe250a4a4c4a1a94736c13d366ee8758c2715d72dec19034e7c0a21db8007b74b3d8fd722c4c12b50a0566e679d9b66ef709334f357ee46825dc068584ae8cfa0a6af55b8f91dded8fa8d9953a8c88817b796946f39a50c550cc5922e25ecd3b507debfc19259c970a2c32ce1127eed4b29ae33616b67718fffe57baadc854562dfd04f9373e75404d276281836a02b89f26f00f4b819562a14f9064b6bb6c62bad18b77bada86f41d816c709d55755f306824a751711ab1bd1225249818118170cdfae1aa413712033e411d0d604ddb7307ff26069e6ef8ab329bfa543d66dcda427dd9138c42deacfb9d3ac4d519cf81d890a3b8332f30f6ea7bce9e8d8bac186456fab28013a7e0d398489566e17922b78cf76160a4faa601784b82b591d4a9232c5906b4582ae043c5be8c9285ffcd92299c7531aa153d83bacc0f5ea8ab08d0d5c12aa79723aca905d39a9ed5da2ef9ba77e64155fd3a756a7b9f17d0a0bc1dc12354bdeb659154bd17aef7aa3b078fb291a0868151c0572a7b6cfc759ddc0f1a29f279c491d4e7c66bd712bc2215254cc52bdc810f13ae46ea4507903bf0ee42996a91fca7486f7fbe6004529ca0522a83d893f2417789b9a520b9962e1c48b0ab609c2d41bd53b7ac2828a35332307ed84f388e6219492fb4e41450f0f3cd0d6700658ed71a87dab89f33781d460f4d74cc2166591f750a0604ff0c84218636810fcfc36e715e5ea969f2310e853efdefacf91c49a3cca1b92c260c41530d8c321df158bbc24e1691274dc68274b17f780ac7b0f6602286dc553a94629f23900fa510b9b78fa62436832c623c3719ed5954a018d7350bbf489e849d36413833343abff077281f28ec9f8592ebe38e1d9b7ed6d7d082f8190e3734ffa53b14737764a5c9c2828c18c439cf974dd52c24a6adce5362e59dbd114a08402ea9d80106731220ae7160db4fa0d919233e8e3c3efcd5f812973be4d28a11a7e737637fc90eef9d468b0f33f59cc47a531ca246b8746ae9e3059a8d7fb60b6bfab36a0709cf0732b5f81cdec729f25e42be046d3296f8f8eebef258d710faf42d9e07f59e95aa2fda3e49e58828a8c6839998d17e22d014232adc3b71a98fff005636347eed45cdb1915a7f214070a56fc8dfa1b4a306836f0c44f51e108a92e17e1357f4cfd0fccee1ebb611cd343b8a6836472fbb80b470",
        "signing_randomness": "8497593706dda52cb9eda9dee199da7fb68c5556dd735fb0bc641808a99b2c13",
        "sha3_256_hash_of_signature": "16d779cff1683b616331107f5a712afd8e1028d006dcf5eee96bc60b43f0d8da"
    },
    {
        "key_generation_seed": "d812f87594f5ec12bb656ddddb3f8463b6fe15fcd698375bde914922b20a3902",
        "sha3_256_hash_of_verification_key": "9e6a417641e36d70261aa3919282057e9e366b16133d8961f52a6f5734b68cfb",
        "sha3_256_hash_of_signing_key": "f702a1c5615ddd2117c1799f5a7425aa845737a3c6ffa90fbe3a6e048643f003",
        "message": "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",
        "signing_randomness": "ebd393268d4efbb445895a57964e9cba7db2ad6046a003e706f68b88b5ba7635",
        "sha3_256_hash_of_signature": "07dd4a54ffb251272f7199ab522b8dd45aa6f4c2dc35a4bdce13aa9c2547790a"
    },
    {
        "key_generation_seed": "7efa3116fb77a3c2ebe9d82db95b311ccadaf93efea6809d6c8c2cac112e56f7",
        "sha3_256_hash_of_verification_key": "03217225ab3f3af2ba8489a6aa635c37a44098581ec9015b072cdc8a5a90de9d",
        "sha3_256_hash_of_signing_key": "4a8fffb4721c238529db5fa6ca2eef1db9d07a62f8f6b87877459e55d7df245a",
        "message": "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",
        "signing_randomness": "b7a3dcb7a71a53a71727b720561a60ea580daf7d2574564a163313562881e555",
        "sha3_256_hash_of_signature": "f2e0f06f18cdf65c811ac5905e759808a11856e85bd1b23a96ad234d54e11224"
    },
    {
        "key_generation_seed": "926b719ccc0f0064716a91a8fb89aed08b1d825b1170ca01c5e0b7d3e13e533b",
        "sha3_256_hash_of_verification_key": "9e63c4008a256b578891fc9b8210f1ebace8e2908fce0a77c4bd7f73b3e1c922",
        "sha3_256_hash_of_signing_key": "79de5eec7840ec28beec1cedb1b6bc8c2eb15eda9eac4cb6081b6946a9eb1af7",
        "message": "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",
        "signing_randomness": "7cf8980058d668e9102f2fbd85bf9beff1b1f211df056eed95e4d3e7d33ea431",
        "sha3_256_hash_of_signature": "57f3ace8f33b88cab89f3cb69926d81c8fb2c317b8ed5d7f610fa63443a25e48"
    },
    {
        "key_generation_seed": "f974984f1ba6ed68664ebfa03c1ee530b32597480db512d5c8008939bc1454a6",
        "sha3_256_hash_of_verification_key": "7c5d532776c1809f5ba52064a77d4c03c95f0d75955a7f47f2bab6a87858ba01",
        "sha3_256_hash_of_signing_key": "7dfe60874309fe0fb27213dc10d8f0b685752bb6a13c6c4ebd2df2433f93f7d7",
        "message": "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",
        "signing_randomness": "2b942cab0125439642df01ffa1b8f45bdb8f5adafc2b67eb65b804e1e26d761a",
        "sha3_256_hash_of_signature": "8d537fecb31ce429f36d3a1852bb403dd2e308ce7900c3ec0349f7d99c2955c2"
    },
    {
        "key_generation_seed": "86e1d6e47eec4454d08f56472b22e4b38b26583e2a758abbb8708f6029e0b8ac",
        "sha3_256_hash_of_verification_key": "342fee17f84ece691f1956c73ff93a2f2d9c3834434c7388493f5cc0a5b4e2bd",
        "sha3_256_hash_of_signing_key": "976894b9a01dccfb48d3fc61f20a6f8e81d40f934d47307823186f3ed89c347a",
        "message": "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",
        "signing_randomness": "9279fe8efb68fa05418330f7ba60995539717a2e0a6ac728e3bcda464bee9f0c",
        "sha3_256_hash_of_signature": "31960c570aaf5d11313adb6a18a8fc8cb775261de3ccb03aa6858b71d205aaaa"
    },
    {
        "key_generation_seed": "85d1cbcf839acaae2af13f938f75d49acbefafbd32d2f060e310f5cbdc035762",
        "sha3_256_hash_of_verification_key": "257e19d50d33e43acab569436ab52fc69b96b3f57c3181cea24a5d142236eb0f",
        "sha3_256_hash_of_signing_key": "4de00ea9981353acaf77f818f74d9bc6168f9d693b9cc6a8cc512cd1afdcd277",
        "message": "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",
        "signing_randomness": "94e76e08754c0c9bcfa8726dbc240176486e82eae8d5c5fa6f30adb3730be416",
        "sha3_256_hash_of_signature": "9ac1cd66b12cff024b52379f5dfeb858d1c4691ad05b99dd6864abb9dd9ecfe4"
    },
    {
        "key_generation_seed": "f6c206bd5414448cbb277a55b9d717f6bc575560d6b106c0b5f1ccc59da8f8c2",
        "sha3_256_hash_of_verification_key": "3c7100f29e6dd5ba17885af4d45a01bc29de4daab3713a9aa158ec8062734e5b",
        "sha3_256_hash_of_signing_key": "090e3bb313e0285685eeb4a5edfda3e294b83ac31bfcfd660f380b9b0ef8f76f",
        "message": "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",
        "signing_randomness": "1a2e714a2def9cad076bbea080f23d62552a0c63817c00d3436c853607d5ed5c",
        "sha3_256_hash_of_signature": "902795d2feab594d6e89e9416630f2bd90c6068e6dd04b54373f6466cf4bfaea"
    },
    {
        "key_generation_seed": "150855039c2f613506775a18046e8df32329b2d6d3ef1745662345fd914737b4",
        "sha3_256_hash_of_verification_key": "1652d2da616693e06d40bafd377efe9dfab088d55fa2e95447a5dc8eca662266",
        "sha3_256_hash_of_signing_key": "950fc7706391a0666237013191c94ad663f3880d0fcdcd0175c1a6717ea16cb8",
        "message": "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",
        "signing_randomness": "68122165ec1670505abefff79f9814ffc2b3fda910014c74a98d13226fdfdce1",
        "sha3_256_hash_of_signature": "e6d710bc8441da995f340497deee44c94db4a9d8a3b6c596acd1159f48fcaa72"
    },
    {
        "key_generation_seed": "297958b0a7e6086fca2792324418e4e6c04d3bbd6dc2f9b5f076b1010d9b8da2",
        "sha3_256_hash_of_verification_key": "67831cb9ab9a469ac93ea7353b37fbe866ebc2c1ffb0f311d8bad51ed0071bae",
        "sha3_256_hash_of_signing_key": "df3e5517b2faa89cacc65c03b8414c49af872d4c3a4d6231cb9596c558e667c6",
        "message": "c2c97d523f891ed50c45ec06df80d7ba0ecce255fc26e7572ccffb75582b3cff91a6539f28a18b652081a8b1b60598496e759df76af223b757539487a62c573074a9632069f031c9f3308c79998a26f274e120be0a7209454bbe0121a0a00be997db7f7ba1b47f16081cf20becbaf1752e4d61d6d28b01988db0ee8421e1a7a869f8ae7aa55f0c2007fb68099fb7eda545fbe078fc11dd485debbd761c449cfe06091b58774f82974b79961981fb54cfc7964784336a435f6bd9e840d4563ebe45a757f75e573e37f1c868781ccf856d0eafc22c0fc1bacf42b2d25157b4139fddc9586335a0fb6a7f3ceacdbb66cb209baaa6b55fee6421d3a9318597d310b91cd4acf690b23d28a1a359f6e076cd8508f3431ff4e7580a667c382a9f25ce60ccc7d2cae7849eebfab4a32758e00df68d0e778cd4606a75ec34bf8d9871547929d2d68aae655fdb24894d6b30986a03a3e2f3e7dff6ed3abd1415885291180b34f923bf0022e449eee89e5f0f652c57d61deae804ab839bd6dce84b6a16eef158ce0f27d56dbac6cdadc242185deab477d52f745963ebd71f7fdb86cb3fe4b6b3592937f9329f73c5bbec41bb1ba82d7691687339d49001c75940268ac3cd9c02c5d039f128b5e5ed0f8674697fa968414ddda5583592520f8c0b69da36a4329e142afba9cd2f486a9e07eb6d4aec8886e440f98a2cea76200f9a05dddbf56a0c4947179423a08427e1f165629fa7ef887a4d57026135ddf45b03ce6cec31dbbcdfc09c2bd62a96fad391fae8417ecd7feba89f8b6ae25679d85817901dbd670303684808bbc13df6d5daf69f5ab070ec62eb79b800cae699b853c0b047bbb0f9a7fd9e22868e85fcd9eaa4b5dc59e7bc6ffa6e37bf19de9fc67dbc8896b3c2f2fabd4d25e21e100534252659310f72593f80c5ea537f8deb8e1971278d5a0d2f81ced5c3f69fed26f89f3a7ca60109a4e22af392d71fcdf9cf79239a23f1f83ef8ab7f8802c3cfffe753a20d33942819ab5c81db1763df9b8f4a477b135aec9e4bc6e868167cb2c50dd3fc5c880f33ca8e73d8e3963d409f7ef01ca4f63194220e587460c1c4f689c87a41a2b51dba385e6e44a08530522b78a156beb13b76bfcdadaf353e6f40e3fa6e154a0bce1ef71d722e2171fa523ee17e0c2d1b9c8d6023cf24ab5661731b2dea451a5865c0e085c8031d3618e0379aee26febf0fb23070594fd32ca3a5ef38330c250f16b0cec94d8222e3468464318b2b886d855d87bab46685fc73fa3ac7cac7e214270a72c618d40109664a05d6bef76e9187af8765feb3eb6c5fab633909f174d8217cbc778c1adfac0dbbec1003ca08c0aec0199e71108e0c7dbaea98b5c43aa582551e194048a2dbf737cd463c3fedcc77474532987fee7c4e4037319b7944d63f710c418ca5017a52008345e6485116bd244d07590c1180a343f0aa2a4a061c7f62f6eef32355ac34117ac0132d21e1cc6f225ee3c65169127efdaa343da0f5fbfdb52d9767c1cece64702313cc072c12a9216511216fda0a172b82c689a492aac2e5f8eafb1be32148dc602da2843566f07657198abb1c66a01d18efc6417cd936d84ebdd2ebf70c41e2938f94268d0d576718f4ddcc835acebaaf95d967c4bf77afbae8f1a22287c6ef46f66909217d0e4946c1086de382af80ce5c146617a9f6185e495ba53b240ef5462efacac045331a34da80c41f1a5972d1d3392329681c0062540868ab0d61edee824f4fb51b46e932c36c2f8e289e101e76a6c4a38433884c27dd03cafe552425c9c711a5590d2bd46cec2f5d6cd3b45b0472a743969934ce5d98d00712259dd3a628f15c40663cfa76dab8380431532cd4a9e9d3f0bee2c3f58bb92bf25b64dae027ed81e557832a943667ac6471c1146575707a3a3dad9c1e8255250c03db0fa932188f0acd2cd55c102fcd291a1e3efb0fb9ba5a1c7f53f229b0644161a0d5c1ca89629c8eade714ca70bfd687220656",
        "signing_randomness": "87125c4b2fdf6a331c69ae2a8d3629b5a063d03b5f3f2aa19e93983c5251627d",
        "sha3_256_hash_of_signature": "9a1e80263edd684e03823e5d17a7a00e4ba4636089249542683cdbc5636dbd99"
    },
    {
        "key_generation_seed": "f615b0066782625b1b77e393c8da43717ee497893e8b67bd653bf59a72989d18",
        "sha3_256_hash_of_verification_key": "a1dc8e8c804ef605090cbee7731ccb362e322e520feb06e82efcbf930007ea84",
        "sha3_256_hash_of_signing_key": "9d93951201f378e94a796c7f336c08c4bc16e534a2a5fb326afead0ed0bc04fb",
        "message": "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",
        "signing_randomness": "ab83d8cb742b1821006352b3ccb08ad6077c25b6c16c099e2128629f89f36336",
        "sha3_256_hash_of_signature": "46d5aee81f05f4d1148077785441451e7314a0fb5394332cf35b8e48333499ca"
    },
    {
        "key_generation_seed": "c63bbd7f702fe3d08f483f6d441319ad34a6e2e2fc0ed7c79b1a4c77c45cdd12",
        "sha3_256_hash_of_verification_key": "903bb6f4b97ce2a028f9983186be15ce62f67748aea48c5e13939711f377fafc",
        "sha3_256_hash_of_signing_key": "74b0d0777fc8b91a3473632c7f4a3c9acc58fc33fdf266b9537ab206f36ea251",
        "message": "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",
        "signing_randomness": "75952fc4ef96f39d24467bcf96afe6c79b73e4aaf83d5065586bd3b2f41eb34f",
        "sha3_256_hash_of_signature": "6bdd269304dfaac71e546e912bf8ee9a078c62f316e8169d972fbba671ca9f4f"
    },
    {
        "key_generation_seed": "d36c8a63c673a9ddf970868ee64ce879ae51053ac54e4ec22cda4de6d0b49fc6",
        "sha3_256_hash_of_verification_key": "e41b5d79d67db5d7e51c56fd86ebe874f5a906c19b1f512df82f98253143af9a",
        "sha3_256_hash_of_signing_key": "7826f22ed4279b2acd4c082c105611c7658d27db6457ad57be6f597e2f83a5c7",
        "message": "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",
        "signing_randomness": "0d35a93138e5f35fa46550a9a455f90b0f8edb5d6e05d91e1a55404403de0c95",
        "sha3_256_hash_of_signature": "e6359fd734faf3c9d4e12f42a1b8de7dda8ccb07298060b3a9fec702d2abf932"
    },
    {
        "key_generation_seed": "55de571ad7ca2dcecde67d05cba02da990c33e428154de3000dad93dbd1c992a",
        "sha3_256_hash_of_verification_key": "3224927a0bf6dca481813d4bdb335c6735a93f7d66bc45a7b7afc8c83f3bf00c",
        "sha3_256_hash_of_signing_key": "c78b28dba727ae0fa5d1b65437ef08832a8213a17aaa16945ee728812a16ea90",
        "message": "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",
        "signing_randomness": "ba9d1dd031fbe7813fb79c392db200cd65d500201e06901de740c013e98c40c3",
        "sha3_256_hash_of_signature": "1c1ea24fe0554e454da761dd14f82a03e821184ac569fe6705fbd529413c0d03"
    },
    {
        "key_generation_seed": "0121cb502510c2d23e8e2f922e725d00f7b71f8c49073047c3d627fa4105a2da",
        "sha3_256_hash_of_verification_key": "e4170220460ad97cf7f240197a3d8e435ec8bf416b5a5d83eaec4a48e518cb73",
        "sha3_256_hash_of_signing_key": "645c0ee80b0f4952b0aa38ae340c2de0f995d9313b5c737d67ce841d361dffe1",
        "message": "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",
        "signing_randomness": "e809869c188034887dbe1615110f5403175b2f597adac25e69b78dd06e88ad9f",
        "sha3_256_hash_of_signature": "8cb70d35e78972db8d74852e3f11db0f071686f5d0be65468817ec2ad9e2d4d9"
    },
    {
        "key_generation_seed": "40e650fae6859c741ba07e5ce0af95b3271ef851d01bbe968b6f6339e61f731d",
        "sha3_256_hash_of_verification_key": "397ad1699303356fce14acb5088e8f220920a43d35e1d3f5012fff3a47a65f68",
        "sha3_256_hash_of_signing_key": "f1aea5e7d5b0483745bc33e334e626afa4f0ab3cc68abf96c9515c3a88353bc2",
        "message": "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",
        "signing_randomness": "8cd8e6532c0ad6fed0b04317593798a0d89b0234e9ce0ffd5fe30657ecc8391a",
        "sha3_256_hash_of_signature": "01d545079c19066332098f5b32146077919686ee1059d20737910d997d30d51e"
    },
    {
        "key_generation_seed": "83566f999f49ec3b01ddfee80b72c5349b521e9a0f2489906eb12ab909ee69d3",
        "sha3_256_hash_of_verification_key": "a49404741fc49a16a0870fa189845077e55a86ded31cbb227e29c80e75611082",
        "sha3_256_hash_of_signing_key": "32f6ae7b51c629c24dece308a85e3370dae9fb1caf9be4cf15cbc521535b011b",
        "message": "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",
        "signing_randomness": "87e7eb83d143825a33b1d67523a9c3419587e75b2e4073d8d08305229a72ab2e",
        "sha3_256_hash_of_signature": "f7f9f0c9d58c2c971e90da0240f2ba6c704a803ad8412cf766be677058cb6c69"
    },
    {
        "key_generation_seed": "13786edf7c8910f82ffc8a4f53b17a1b4c51396e60f0f0900ace8168cbd52d25",
        "sha3_256_hash_of_verification_key": "9b6e05ce2652b833049858ee6720ac6f8378cf4449785f815d06abec806f2356",
        "sha3_256_hash_of_signing_key": "6ea21b223cc6e30924457d61b21ce02323b250f2fa0566fc5f2331089fb9dbc5",
        "message": "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",
        "signing_randomness": "20706bad6985abf12dad0c1f1d3ea195823cf13c60856a468878e739f9a08e8e",
        "sha3_256_hash_of_signature": "0160e43913caaf4436b34333b75b353d98a1d2ac30820798bb99c05f4a36fa15"
    },
    {
        "key_generation_seed": "d98a515d4989ac31071b91361510b609010a0adda486ead9462c8bb5cd9be43d",
        "sha3_256_hash_of_verification_key": "48706d4333486c9fda534244ec7e4eb6f7c89e2d76efa8fd9a59a4048e39e658",
        "sha3_256_hash_of_signing_key": "53b913d89aea5e428d66ca2d55d45a8648250faec1ebf1648f3993463e1ca742",
        "message": "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",
        "signing_randomness": "1b6c9a94884a5f8b3a0f80f7cf0dd5b2e87419d36e23b6b7469f06a00d15d1e2",
        "sha3_256_hash_of_signature": "d3689ae305ffe7c46f3419bf3d80ab2b5be6bf78aae22323116fd2f0e9ed7486"
    },
    {
        "key_generation_seed": "f1046bb07b139779113a952b97c75be064ae231e5f2b0f77df864cf56a54e942",
        "sha3_256_hash_of_verification_key": "53e5e7edc94f86605af6ee7f59f63316ed84d621505dbfae87341b319f048379",
        "sha3_256_hash_of_signing_key": "e6621a87839b655b6dd7f3767f5769d29df71aaf5d9316895b3449535b66ce8d",
        "message": "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",
        "signing_randomness": "a4cc6b8c154f268edd6f800e85a3e5f4dd877379f1dd9c6c6f2983d3459f1584",
        "sha3_256_hash_of_signature": "630888b618d0633aa91b4680165004061fd8b38a25e8b504d95b988b7664be6d"
    },
    {
        "key_generation_seed": "78b40fe522ee9e20e1d52f56109adf31581ce92fb87473ab1bf7d976c2e4bb13",
        "sha3_256_hash_of_verification_key": "b04758b35aa1590c089c421ca1f91577a359952edecd4beb329956858bdc3c29",
        "sha3_256_hash_of_signing_key": "f380037fac442cf5bd9ccc17c37c372319b1fad216ef5d7217dd8ad9e1a12ac8",
        "message": "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",
        "signing_randomness": "f7127897a49d033ff9278ec350ebc1089a95a84ee6c417461d2ce68c216856b7",
        "sha3_256_hash_of_signature": "c645ae21c5b1c84760d6ae13a2d75d8c3da3d68514658aac098de82affd42a6f"
    },
    {
        "key_generation_seed": "65f17293c523b41e31bd8a6f053f43582ebb48bab890cbb5faa471f30f7e526e",
        "sha3_256_hash_of_verification_key": "282eecd8782c35fdc170294a74d31db68d05dd6c090b0b5615e1c09ff8401a7b",
        "sha3_256_hash_of_signing_key": "394271ed552636f4859c1cffd06a3c5d6d965165cd1a70528f6c8d8ea1cc555d",
        "message": "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",
        "signing_randomness": "385666058bd22a969a1072ac49722020f00a2142da276772ffd1d0635d5aeb48",
        "sha3_256_hash_of_signature": "e493d7a22419d01833a9608e7279d87ac06dc58e3611e42bf317f3b2aa343fa4"
    },
    {
        "key_generation_seed": "cd72fd2d1e09413cf91a686fd95e16ccb44748364fbfe066bdc2ef3b36e6dab3",
        "sha3_256_hash_of_verification_key": "1dd82066c046f53bd8b9f785af14f1ab7c27da0bc298023903b83f817e59425b",
        "sha3_256_hash_of_signing_key": "09aac1ca038d9a2bf241cd53a7fdbb6ca4c92462c3fffaf9be67ed0e8abfdca8",
        "message": "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",
        "signing_randomness": "c2e390f052290f047dfa9ddb28d1287b74605ce14bef80dce81c609c5d5c4536",
        "sha3_256_hash_of_signature": "857e152b8f64979e9c37b8320a377287713511811111caf659fb21acf4ee0fea"
    },
    {
        "key_generation_seed": "b491aa0d591caedfdbc0c1bd8d7ae2caea316d45277c80bb7246149d72a6de36",
        "sha3_256_hash_of_verification_key": "17bc10be1a0419120ddbb4cdc56025360325d1dd591609a5107281036f657ffe",
        "sha3_256_hash_of_signing_key": "3d78c0b18332c7b8c349ae3cd91a989ae9291404e555060ecba0e16f3e2becab",
        "message": "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",
        "signing_randomness": "377d6dcb36fdbadfb5bdac159a8c8a5251c0bb0b341f6c5aea870aff35a33df1",
        "sha3_256_hash_of_signature": "52f8c6726b4824e6be165cc91fe32a2eeb7f7045bfdabf6152503bc16d605a17"
    },
    {
        "key_generation_seed": "c06b106089261f6e5892caa8ccff7dc74b654722a753079624c3e8c25ab52d00",
        "sha3_256_hash_of_verification_key": "afca10da3cc6faa0189b82b4b5db43f41baafd8ddcc035695d1c451da6fc29dc",
        "sha3_256_hash_of_signing_key": "9e4c2995847b419da6a2c463d3a572312d8efd608b25e722ef1a61ad7ea87285",
        "message": "d9d39e3c882212f629597dbfd1764ca92b1183dfb69c7a0e7ee59dc2fb5da7dac6512d10706fb394262c5d500b83d2416f2d807931e7976a9e8946d5d265ed198f33eb5587a3da539724979f228aa71978766889f77454fca8b9ec66d8a60e749a7d664b8650df4d479dc426e4d8589e2bf6363f8c4c61fe9422d13a7b94e6a2c094ab4fb41ee9dc35c3a4ae0d6a979db10d9f56352f55037622b320b4e10a326e4ab3e5cde9353c4cb1b59b42e65505bf61ef2bcaa356e7f5b399b05893d8a77e32ce09f9ab85b7b19b7060f812194b031af237f1d88d21a62a468e5ffc8eb86d2932a39f969dad200fb9100f43164152487e85982e3b3479bd33e02764da381bde501228e0018aeb10071f7fd13b70fcc6208e81f0550978c8164869d00904ea2de80735cdaea4577bbdb8ae9a9c03f6c91415ec985b37a8fe11ce69a761e8beb460644c3a91b2038ae55056dcd4b4a5d58403a469c7d61c3a5da3574a3a664e6f3a48560c08aac36472d3acb1d08b9790b145963008e0f8feb03360fa6386cff252b098ef36e1e686751ecbfb7ebb0c2fd5c26ae75113a8c6939915837ff32f41c1615bafb61dffbbadc5ce4dbce666c929dfc0168ec8c7c932b1e359ccfb05d94d69a6ccccc837104121985634dfa4d4d481188bf02cd03e6ddc93856be66422f7d808a0df9cfd62bb108e06d22b3e3af2b12aeb5bc1bb45cffcc0fd1a5d33415c9857a02fe0a6c499bcbf5cd50acc3de11db89db8892656fc6b3bdc7490d7329b6cc58f929d375e4b757dbd51c971ae81be1bfc8d4a4919244def0267354c30dc685552df0189b8da9dcd4c64579135c60ae3359ea003ff05ff7ce22a32c692f1024a9ff88dfc7f4e74f355e79e7de5f59333d367c4644e9d55948582570b0c6f751410dc27c003aa3418afbf01a29cdf9b10cf1783e91e76b451deb85f7b006c712fc20049c778a0155460ec44a5e36ff04b8d3d3035337e7c00508338648aec2a214987b2bfb2d4c0b654697cf592355a7cd5b4a121adf04d6c5461f73a46fd4f0824546de0978f7a4c4207a24a849cd0be256b15f16511d523e45611db5466b09e63ceb13a7a0b87dcbec2ca765a44b3d85b2b3a61bd0d1b23f8194ac7050cf4b5eb843046f2d606425556407168fe9e383515f142a6f77916b3daba96ae39e186bf60804a709f63669ae3930c50e1a734808cd561c06cfe0b308fcab744a9582422930c96ed4b721d9f10105300e60aaf75ac8d5084ccfd0fd13a11f3bd0941526f56a98f1dd233a54b51dc447fea687a5b01fbda826fd3e0c9f04dbb2d3d35c0365b85fb98e03dda2326261d547425a4efb59f9a7acb58197368a4b0b94aeeb32dbdec25821cb193508568e348f5e28603390bdf42a7a743c5d7aa6a13df97ce93eb69eb66474e2b0fee9177819c96b17890e030ec2a3dc3c26641120393bf05045fdf20a70259ae8cc81fdabefbf32eac669d23157fbc7ae60bd06230857225c02f0110b77d78dac0f8fd6c599725919f2d70107d0c212a4b7b1f7747fc4cdbdba214d47b5ebfc5a30420a11ed8d92c6c9aceabdda44a305d692e9f02cdb85069a4d53d99de2e7197f2b0bc09c6455a215488aaa4330f9a8e0af7f661ae2df9278f7465e8d56345094a864aefd0ee56094219d8c896fe43786e36783842c9eaf8f004cfbf7a404e0eede5acd80c4486b2d0245966bba97b7ca9cd0870fe929ab35e5201aaa04e40552ec92a7fe5fd68980807abf15f37e671b61c3971195bce24aae15a1655e1caae6d818cafa0785268576f13bd673cd30cedf9fb4304c8d724a3efc201f17775b8c8b7c04c53e4b33e18fbbe574e0668cf15673b6c874500251c8439ab13bfb49d1870bd81d346f6b4ab00a56fe809ede4c9b8ad828c704fd831aac27e7e74e44b92a7ecd40f6b79ea379e56c8852dd0f3dc80e9477a5cec91d4616ac384451c1e3f1b458dda93fe8d6941164d82ca76739870bb029f929d6b9fab4d63a0ace8d128fd4fff6901ae90e3d1a0911af3a0089f01f8fd27e842c6f579a9092b61653c2b572803e07fc6b68a298fb8108b36e463df9a404e3c3f9648c108660b964ca9e2ec3eb42f56514757cc056ff64ed906a627f1ce4edd5be1f596c911c7120cd467db5aecaea4a0c0e9ca428698f8f55de14ffffe7cbd6456d9fd072a2cab023062e83f08135d420466fdc2624495ff3d117233e15460c62d0a097f24c589f9e686a28309ef440b73bae6a1580cea96eb808e039fb1da85105585e4bb6dc6370ca5b9f678ed8f6135fd00b29bb9687149b35b855fc21f60227e2b8b9eb31cecba551d134345db9b65254ebf5e33a37407c3f39a06c104aff85e84148a17b09c8f8ba975f21953683d8a4f93f2a4c2febb29daa1d50ed67cc8c3967e978f3e2ad14f0f07dac872ad520aabd89502a3302bab1c61d4e0523f52b74f6ca72c1c7c19fc4ba6259e197b7a4e47538699fba25285d323d3800e66366edacc57ae3c0a9adb84f5ea9b4b583baf875221fa184b6422c73705bf6ac0c98822959a3d3e813515407d0520f8ac83c2709ad9a9ffd9f692e1e21153f3af1bcf224d46f9f403bf1c112f734b7c1f9f4119577df4bf22ad450cbad05467e5ace90c9dab3797047212f100f5a513bcc40a5847ca1b4473d43849fb6b9db1bacd7e9c0f4331816d3eda9540b9696f0e1c5386b04a",
        "signing_randomness": "18ed39ce4686b4f6c9eb2472d2b08a4f79f5b2b939e31e1d3c8adf674fe32cbc",
        "sha3_256_hash_of_signature": "ce689ea9c687d72d26ed8e2025f3952df8b981a4e58126df5a7757324b9cf7e4"
    },
    {
        "key_generation_seed": "a831e2e650fda885d816bee52b008630edff29ba11d219598d492bfce232f112",
        "sha3_256_hash_of_verification_key": "7cb9258c072afe4c001a6b96d65c2990a87bfe0d97493359100105e081c66eae",
        "sha3_256_hash_of_signing_key": "c8e741cf3c331d34917f0edc90339c05244e08b5bbad3f53f5d460376041da9e",
        "message": "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",
        "signing_randomness": "b3d457e5788014f33ef114e51df35734ec6293813284c05478c891587b5f4d90",
        "sha3_256_hash_of_signature": "8b3da907d300673c01db2529f3714693088c90c50d86c1177b1298bbcbb06784"
    },
    {
        "key_generation_seed": "475ff8bb8d6e1f2e0ea29f87c7267a0fec7272352e6f666c995118f1ed11bb33",
        "sha3_256_hash_of_verification_key": "34cc01ae654e8c1576e257ea362cf69013a29271b388d3dba6023594aa1c09e9",
        "sha3_256_hash_of_signing_key": "bfae909a87d7d6ab81636607533221104d4711f2d6c2cd312207b28b9feecf35",
        "message": "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",
        "signing_randomness": "216e1bbbe8a1ed813605fbf1c5cab733589563bcbcb9f6d96491ed47c75fb142",
        "sha3_256_hash_of_signature": "ff383dd02b67540a349f6fe739de666b201163e20be1ef62d94a2036d710a463"
    },
    {
        "key_generation_seed": "4c8030efdb74ec4ce3425ea4bc11581e0d4a3e3ed5f651b6271b1243b19f0d09",
        "sha3_256_hash_of_verification_key": "bc006d666af04ab31adf44c42c0ca246bc34ff4bdf21f8baab7f0444d999da78",
        "sha3_256_hash_of_signing_key": "06f2dd409d0fb7ce1c0aa68f606a37786f6720c17430f48f2d4a66d591466dc0",
        "message": "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",
        "signing_randomness": "b3282bfaf3a5a7c2cc1bcebad81f6438bea692a2a7881561834ea6e1063fb119",
        "sha3_256_hash_of_signature": "0235bbc77e60c2e3b0c27c72e3de71dca54db799c29d30419b742c3f95861416"
    },
    {
        "key_generation_seed": "6169f833ec1bd619d833f3a317610574e0e4aa852e891a6581cc90d58cedf2ce",
        "sha3_256_hash_of_verification_key": "cf76901aad5d0016efbfc20b1fa04127c6f826089fd56e14db3a182ecb310510",
        "sha3_256_hash_of_signing_key": "cb7420179f9a1d87aa101c3caf11b668fad3476cb93d90921cb99aba297ee26e",
        "message": "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",
        "signing_randomness": "4b2536f147d24463d945115894fc53ea1651173c5611229f0e782f4fa4088591",
        "sha3_256_hash_of_signature": "08d5793218091d437e5dcf7b3d8f8ba1ca1f945ee29302b85a237e0836d489d6"
    },
    {
        "key_generation_seed": "105018d6d7582797650f3d0d9911ec4d562a7f61b2039ac0e21d1d0ba021e483",
        "sha3_256_hash_of_verification_key": "74291c7724da9aa33e02d4788c72ded574f23b731bf2b57b67b790504204cf40",
        "sha3_256_hash_of_signing_key": "63ba04c77c1a573d34b34d567f6e78b58a3ba301a13960bdd80f0fc473cd5476",
        "message": "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",
        "signing_randomness": "c690f61416bbbc1c53c1395c9eeecb2c78ce162b6f3c7a14ea7250103bac433c",
        "sha3_256_hash_of_signature": "cff8b73eb0dfd1797b872945fa5564f12735c60fc7eef84514c6adfebbb1ab18"
    },
    {
        "key_generation_seed": "cc500183056c89f775fb02709d12987379d27daf9af5e23948f54a665d8d71a4",
        "sha3_256_hash_of_verification_key": "659de235082d3147e2a1a33dcb96cce08f5db220826ab2f723be878ff81ac7be",
        "sha3_256_hash_of_signing_key": "aba7a838cb3ac2302f97f89fa04a2e580bd4382d5797061e5a9382f2eb6a963d",
        "message": "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",
        "signing_randomness": "5824111d3e42c01c3d2631c29d90430c899ec553e29c032e2bc41268bf62d600",
        "sha3_256_hash_of_signature": "49faaaebf70f932b5054ee45d42c7365662ac975a27a64592beed2f39d562797"
    },
    {
        "key_generation_seed": "4f932b685d2fa44b0864cc94605e1b51dff510ab8e424945d89e03937ede70e4",
        "sha3_256_hash_of_verification_key": "e675b031eda90491ebb30c1cbb5abd92e684d0b0573b53aa29b46b12a3204f89",
        "sha3_256_hash_of_signing_key": "cf4c1d304098d50e2b544400f8aa7b0d9071b89354d3a987c9bf097bdaa82982",
        "message": "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",
        "signing_randomness": "da456bd161b209e73c80aea198dae91f0261a76101b07a97b032b6bf9042ead0",
        "sha3_256_hash_of_signature": "3fc68b08f8e1f33ae6ac4fdf6dd4990694746691c4b1b8a195bb618e0cb6ca0f"
    },
    {
        "key_generation_seed": "59bfff2f319d9eb2a5fbc4375681cc7c63932037bf34a150bc8262c7e2cfd752",
        "sha3_256_hash_of_verification_key": "aa429086b7f02e56c7652b57ef90154efa80856aadea3f8b662ef0db6ced37d2",
        "sha3_256_hash_of_signing_key": "e549b18471c5c87a9c8964bf7ce5660a86d079d7e83c5b478895ac62884d5d8d",
        "message": "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",
        "signing_randomness": "36549cdf9a7962befe3b25626c3c863e19266a86a808af8169bb45648362bb7a",
        "sha3_256_hash_of_signature": "77b0890219a4281d5ccb39523db4dfaee4ccc12df4530944d96d26ac761fc3b0"
    },
    {
        "key_generation_seed": "7aa85b04ef52a24d71ac238bbaaf2cb5c3a1e30e63da72d6457edb88ed798993",
        "sha3_256_hash_of_verification_key": "cb190499efdbcdd25e05d0761ac8c71b29da2fd070f4f6235ba203702e43b9d0",
        "sha3_256_hash_of_signing_key": "3c06e41c96b1cb20a6a79603e06c30faa0d619d7d88d2083e99de472edf68aee",
        "message": "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",
        "signing_randomness": "dd19a7178e10aae315a835feb77d4c5720aaae8cdad01a5dc163e893c132bef6",
        "sha3_256_hash_of_signature": "fb6a845b21507701c7abbd175811b1d32133575f029725ccc532fa986b08d08f"
    },
    {
        "key_generation_seed": "5eb37aac625a26b562b007905c12a73680622f7fc63f44d028fdaa3853d13b25",
        "sha3_256_hash_of_verification_key": "f2097d0bf0908e5974d87347a9d97294ed7e95f65345a14b3cb09e39da219eb1",
        "sha3_256_hash_of_signing_key": "860c46b4a53b3d40e810b3b3cb2b913c7e5a6ee903725d38317cea79c9e4bd22",
        "message": "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",
        "signing_randomness": "36bbca07b1e607f1175c8251dfa3768817dcf6dcadf0742e0bb770d167037855",
        "sha3_256_hash_of_signature": "3d39fffced50a66ac72a29e51ec4f716f5f7a301f53043c8ff37da2a5793336b"
    },
    {
        "key_generation_seed": "bd5234051a9dc47c21fdc6ae50e9c9851274e0bdfbf6139518439c983a7c2ca7",
        "sha3_256_hash_of_verification_key": "ff9edc855694f8f7abdcce1b5ff68303132cd0b2186a702dc424dba4731ca3d3",
        "sha3_256_hash_of_signing_key": "f1984577cee151286c0e9da9efcfeb41d2a6a60c0a08c9a005d5172b42f7a0a5",
        "message": "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",
        "signing_randomness": "10be13745da424010a4f901414c6f585562b5aa748ebfc2151868aa90e48051f",
        "sha3_256_hash_of_signature": "c38dc733c3284bd304a4fc01cdc614132b4f7f6807c6facb83820821e6a831b1"
    },
    {
        "key_generation_seed": "fe9712be4c4b2729f37d1d25da1dd312b085e9fc0b2d8c3190bf3eff3af7f26a",
        "sha3_256_hash_of_verification_key": "eca97e12fdeaf803505e5c559b786deabf0eef20817e376b5b6f67b6e1375a91",
        "sha3_256_hash_of_signing_key": "2f7aa250045f2d26da4e57b96cc0fd6401477cdb59e433bd1d5501413534f1a0",
        "message": "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",
        "signing_randomness": "041a79840e95fccdf0bbe26286182953b5ce90dcc87ed8f5222b3185cbc630d3",
        "sha3_256_hash_of_signature": "7614cb9e5e3b265ed77c650d18826ca2cff05cb0896d92cd906a19f576627459"
    },
    {
        "key_generation_seed": "a17c85ab7f3bd1dc8a093e5613d46489364dd10a34efc50f6b77b4baf3784c33",
        "sha3_256_hash_of_verification_key": "8eda53ac9900eac9fa2bf4774a78478fab275c5f874085877b9b5d9991db0a2a",
        "sha3_256_hash_of_signing_key": "7ceae48a4f350e9b3cd255bcf59f15b7809e4858191ae2fc053c10d8843d1964",
        "message": "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",
        "signing_randomness": "2c5f98c1d26fd7bf95d0484ba2e1826b2d239a62254bf5ff810cbcb16aa265b4",
        "sha3_256_hash_of_signature": "5d697bf80707cf773d11a57022a3bf07f0405e3bbeb4fc53b2ff175f2a84604b"
    },
    {
        "key_generation_seed": "b29d1f35b1b45f73b03bfe87c29511e8939b79e9ef63aeeb55a3df2f0a4c104e",
        "sha3_256_hash_of_verification_key": "dc5ffd6a8e42ff5eb008e2d5517edffe33bc83307fd2de08be4154ed167088c5",
        "sha3_256_hash_of_signing_key": "40ee2a9c1da6fe561d78d7ff21baa4d23c14ddaf3e5e225605e10a6786954118",
        "message": "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",
        "signing_randomness": "441e05790666636dafb42dc4d2d3e2183a415d2931599b2a23032a5535e5a7d9",
        "sha3_256_hash_of_signature": "85516aee3c4bff439ff804c4d09ab1cb91260226bb536d4eaecb0b90d1b1d530"
    },
    {
        "key_generation_seed": "d85f9623d2aa808addbe23a3d5194581e2adf57e938582a1f2e5f1b92f5c6d20",
        "sha3_256_hash_of_verification_key": "64e7734fd112f0bea1cec0eeeabbbda48752f2c75b6a79d82f1bda959dd98613",
        "sha3_256_hash_of_signing_key": "04a9601b83ad43bafedbedef4743636554f3a99cde80421015aabe5de7c78a66",
        "message": "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",
        "signing_randomness": "78956817be49e15a10b170caf1b48a8e76daa70423e509963dee560185ee47b6",
        "sha3_256_hash_of_signature": "e9681f8495e8835ea280360e3ac524766e082a8bc94d3af78802b1a621078d58"
    },
    {
        "key_generation_seed": "475206e93e77ae0ef7816e7d85ac28e0e429cab0fa189936e2a3f366565ba4bb",
        "sha3_256_hash_of_verification_key": "b2ff8a1dbc30dc88ab66a46a80abfa33cf7a9b9d9526ce579aaa94e8fcebdf77",
        "sha3_256_hash_of_signing_key": "03a65cd32437de7ed097c07b2e0c170bf76574b51938660999aba7d8715b45d0",
        "message": "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",
        "signing_randomness": "93548541bd44df1cdd3aa05815d7b60046eb877a7e6e665b2bd2bdd5445caa57",
        "sha3_256_hash_of_signature": "0b38ff985817c5e9011216c0c17e60e05a541d934076e63732bac095b5c34ec7"
    },
    {
        "key_generation_seed": "edb27f103f12e5deba85fa9447afa1144c95eaba03f793930be423863198e64f",
        "sha3_256_hash_of_verification_key": "ec191e14e48c5df01692c2ae9e5eef2ee1f04801cf07ebb511fdb3806d1482ed",
        "sha3_256_hash_of_signing_key": "35278222fb8d9d38d9ab1aac086e9078b500961ec92d5ea74ad3bc41511b4c34",
        "message": "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",
        "signing_randomness": "70cc4ecd8562d593a19a9af8199da0c30a7c395d025376f8af726574c5bda314",
        "sha3_256_hash_of_signature": "3279394dc058ca0ca760f4f001af8b065d126ce8c05b26d79fbb72a0db31b923"
    },
    {
        "key_generation_seed": "820e9d484b9395611b6a68a424a26e20780c66b220d95c28e8abdd91f0173593",
        "sha3_256_hash_of_verification_key": "fb343440abc57424d4884275612cea202eeeb1a02f2b951cae86b8ff96170946",
        "sha3_256_hash_of_signing_key": "6a14b5ec11da4a3abadb30567428d0183227e5d367e2654b7febbc8d6c6ed611",
        "message": "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",
        "signing_randomness": "d7b07000bf8f8c8130fe7d17180a3e30f015b1fc8fe5692def4dd5ddbb332fba",
        "sha3_256_hash_of_signature": "03bffacec1b421d4137b1858d6ea25f0d1687611e048596beb21d5de0f17cf08"
    },
    {
        "key_generation_seed": "e318912089bf95f1d8b36a189d494731d5c24f1690f775391ae74f663fdb4e0d",
        "sha3_256_hash_of_verification_key": "95bc4f56f85769cd1962b00c81289b8b345cc0f83f62028d782aca6bab76f107",
        "sha3_256_hash_of_signing_key": "52c46b4fe6981245dfdf0cea12a6356520c93f819286cf32d603b981b7f86a97",
        "message": "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",
        "signing_randomness": "45d1e114209123b169f798bc1a9dbf31f6e413a6ed7a031425184c3317996be2",
        "sha3_256_hash_of_signature": "c244f82b29198d3794c0bd20a175284eb3ef33eb1175545f5f3f4202da8c4a65"
    },
    {
        "key_generation_seed": "42d884593dbeceb5d5e175905eb3c2095eeb366a8b28fa0a7132600171d74f6a",
        "sha3_256_hash_of_verification_key": "942972f4e37b4542617b0e08862086ba4f6622d7865ef40b6b678515238ed643",
        "sha3_256_hash_of_signing_key": "0a002adb0fd7dfeb8a5624417d7dd968f8a606f88678c45078bd8ef552642782",
        "message": "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",
        "signing_randomness": "07b62fc7f6759a882265b7d762ab8c001c76f2297bf5274ed16961b9977b6f92",
        "sha3_256_hash_of_signature": "95ba23aad49de2a08032642e5359503c6d422fa458a516c406d385a4282dc66e"
    },
    {
        "key_generation_seed": "4fd265388b4a9ad8aa29f5524342424005078a37f339e9f978b7f6d33a2b2777",
        "sha3_256_hash_of_verification_key": "1619c74b43e989120ac4745916aec259f5ac3bf1ce67d91f0a66e1adf866c0ff",
        "sha3_256_hash_of_signing_key": "37a21aaf792ed6d377851c68f9144107caa16132991d548b545e9831a5ba9e73",
        "message": "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",
        "signing_randomness": "b108f674acb65988cf8ebe593ef0149a3c194ca21ef363ceda20ba049428cdf4",
        "sha3_256_hash_of_signature": "079acc221a6a2e412302f13aa07a5b47c1f278a299431a56e624154cf1420ce1"
    },
    {
        "key_generation_seed": "a163a1ebe1d8792a02887f9636f59e4ace55b8f7d123920e3739fe1c03e1ec72",
        "sha3_256_hash_of_verification_key": "05608ff7896b81585ec9cf5ea49bc37eb0d1d67048c2e42545040202d216c09e",
        "sha3_256_hash_of_signing_key": "7a0183285dff0b1eabdb4fb2f94a34a344eeb8ef329a55aba0ac49b3ed5c0108",
        "message": "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",
        "signing_randomness": "dc8b90d4b1290c7c99acba5c7923aae863d34e05c4e540cb031fb0f2d957f13f",
        "sha3_256_hash_of_signature": "aa28cc5bae1921e77cb64bf5cfe90fcff846ad47177474dcfd1d2e5afc803e8b"
    },
    {
        "key_generation_seed": "411b2a57b081380fd308112e14c1e8ed3b5b65c2da304e832d209f72a21323a0",
        "sha3_256_hash_of_verification_key": "7a82e7b129630baaeac26a2ecc91f04b544c30d09700ece1654932b91a8500ea",
        "sha3_256_hash_of_signing_key": "747f4162d4ffdb5d6e380b53b0665a839d07981765de6ad47cd7b146e95d10ad",
        "message": "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",
        "signing_randomness": "aefa8f4a8810645b73c88d5df6cc877fb23de6f944d3ea343261471bbd1ffb9a",
        "sha3_256_hash_of_signature": "2709722a4cb8143b7b6df67513f94d8825c88cfc96bd44e1d1f348be4da86f7a"
    },
    {
        "key_generation_seed": "a423d5f54971c222b125ed7978ff8c29269cac3f16d34efdacd6f638f21ae3ea",
        "sha3_256_hash_of_verification_key": "60701b2cf70c3c726fc5ef2f1610fe2031f52c85c5828013d1356a4cd053bc72",
        "sha3_256_hash_of_signing_key": "e4746f84a1d68cbe1331dab6ab843b652ee236826b644bfb10fe680e2efe678a",
        "message": "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",
        "signing_randomness": "ea066917e7edc4f53359d31be0ce310320ab265ff265817df21372dfa33fd25a",
        "sha3_256_hash_of_signature": "3e5578896feebc9489a4e7f423c4616b4bcfe01b836d228a2c06db56ad207077"
    },
    {
        "key_generation_seed": "6b686de28c871179188cf7678aa68a40a4042416c1dfecbf0c2c08cf90534ec4",
        "sha3_256_hash_of_verification_key": "fb16895b668b2a2f73edf3ff67641d929d3f104801f13f2a1596b0340279899b",
        "sha3_256_hash_of_signing_key": "a7be0af29df843ca6bbc0a5fb33e7a562bddd54ae069a94ee29b19dff9f7030e",
        "message": "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",
        "signing_randomness": "1cff5a708e97affbeb6506800252ac89cfa626bc3c8159fddc0eb892e25a620a",
        "sha3_256_hash_of_signature": "c716a9a34a8b54cde25635aeebae6e21d095a560102f4be90f9e1d58f5e12fb0"
    },
    {
        "key_generation_seed": "a613c30b3a41102b3246ad87cf478d3af710659c536ea2d99f9d592b219ca17c",
        "sha3_256_hash_of_verification_key": "2126466c3fecc818336003659085ee79c1bc1038ed880ea66d1c35aef928d20d",
        "sha3_256_hash_of_signing_key": "77b8141c5263e81c62fb14bce0b9f9f5489ccae7ca78c1bcc354ec8b5fd12d67",
        "message": "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",
        "signing_randomness": "a31f1a7b588b7f70ee6c4c712fbca528136093df96d81711ffed47a4738b2f8b",
        "sha3_256_hash_of_signature": "2dd68ee817d16fd233eb5b06be12e52a21cc1e2e64a0dafa4283d3f0c5de5123"
    },
    {
        "key_generation_seed": "b1c811f7652b3d7002926155bd3d449e4836c7598828ee83c836aca00621ad7b",
        "sha3_256_hash_of_verification_key": "68afa2ccd896c7745fb4dcccae3eebc1b90f51ab035af490bb979e381bd47c87",
        "sha3_256_hash_of_signing_key": "89d24e689376352a2a35af7a6e7b9dc5b4bf9c102aaf7f6d78fe7a0ef7106c46",
        "message": "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",
        "signing_randomness": "fac1a82c6b2937972894513c47758619816243350f7f37bb970308bc9880ad0d",
        "sha3_256_hash_of_signature": "bcffe3809793b3fe40a42220d08c947d420eed20702a957035d9677deb1d4028"
    },
    {
        "key_generation_seed": "5a4c139f3e3e16dd77e9f620049ce6c1f1a34347a340cf51335b855af42c9bc4",
        "sha3_256_hash_of_verification_key": "7ee26f82b4914dab641c5c0516bc00241e71ad1ef8e03070d1527dde94faec7d",
        "sha3_256_hash_of_signing_key": "1e97259c3e165cfc94b7e2b689e2852e2cf1c7cb333a6882b950065d8516af69",
        "message": "50543b93744bf83fa12e19bbd57281a1233b686e1131118b2915e20fbf3e0748df59aa50c3081080837de5bf750f886f2c96cd81fc30c5a997dd91882dfedce136ab73213558b9f96f009b139090b38d2ff70eafb0f362dc32c3b40a54d5a02d8bdbfd47171fbd4912f33db3f66be6feba9aa468313302bae94a8a54fbd773dc13035b30018a2dffa2f4e80c496e3c9ec743e62130f6f30bef85c8d8ae5e7cce7989574fac9b5b3fdbe937c726fa989f750f5d3b0f6e92d56e2b972ce51f5fed21cf59db6bb35ed94c11436175be9249d2b94cc3a19fe2e2103c8dcbc0f955283ece644aeea88e4c5995a375d16ae1eb04b84e7ca4b20f53d7b7651fd6bd0b915c38f50a2907f4f2aaeb2ba3aaf0ced218e1b24fd33a4f4b39397c6ece6bc22badf8bb1df4abeb437c4c28a27c87c6f7172888ea322d04ee0f3deccce97d638a5ca3696f50f314e786ebd5ed10163ebabc5ad37d63d1b08e55e1e741d46fb817abd7be366f4d9acd48c5896bc6c7256ea96b4cbbd698e706535a0cf5620dc0bb05de1a8079cf6733719f1e46d5909e09d837e0f52116cc044caf20296170dcff83c9f9ef48d8414182af31ca39efb8ab65fd440b2108ac658c1a55d40f2a41b59a1b5a21b36d46f6cb5a85b6a71f54ea0b6ef16ad374ce91a4b922f9969bcb2b2b563d44704815bdb5f80e042a5f39749e095eadaefeca8f332bd46a8e579b79abf62db5555c48b088ea2ded72343ee6b966a309e24586701f8de76c34d04128a23f9b7f07a468d881eee092ee2682d6fc57d2fcfe1b9b717439a47a478e09ee80c78bb7ebbfa83bb39ac080b49b5b6380f90170457d904ec511cc530d8a3b6f4b879ef486f7fbafc1e7ca2f0f0ae6feef28caf04cc6b32b0b47d109a84809226f401b14cc64c682ac5bb2b0529d2c738eb07350548885e24eac3acabb69eb5c9ff30ebd4bb3a3e2f3e647c3d870393b69a37ab31170260aecdfb7585826de16176e9ef6687b7f73ca795fa0e921765b13970220ccc81d3ad4b1efcdbe30cf364ca073c64f22f1f510a3ba9b80316947d77634f4c61872b8369f8854b06a586361cf62884ca4d7b2c14d104d40ad2278dc2bcab7fe03c990cf69a4bf127e6f501c13e07e23b5b4466e2f0972cbac3b77ff74ed8d4bc411c68c3fe3c0cea0c7d83cc7afae42948f3169a9aa2db8e483760660e55b44c401d67c7b528a22a7c816d18d8cc5625e296bf6d90ec6c57da81383dabafa921d5e33193b9635a802d403b088fa6c27d1c2199c32e26429a646426c55c30770e50cfdcf3d85b66ca26a5b6ac209a3cf0737e05ca8bda95d11a4dd01734d08529445a91124fc25dbc43b261570734e2e30d8514956d76e93afa45e37508d59e36d341b421d2b951e04db303604a6a62e5df2f9c84270084c6426374541c74cd696eefda7d924769c71b48630508e4f384bf3bd41d75b38b96e566296c4c283ccdf81f724b9ff18f21b9b9cbbb87ad4d2019e55f8f6e2060c3c911a1bc22e721f077e56336e0ad0549a9b3a50125e5a90a787a97c2129d254a2090e6dacc0b2948293568ba65ec1316993364d07b1495fb9a2900f77c58f82d078fc90db7e45e8539a54aeddd4c6e688c5ec70cae94373a1ccd1a7e0aec367018f02474cf7dc2b9935cc6a53d36375fa4c64072a85bbab5b8821544786a579618c675bc4ec3a73cf30828ffd10b40587d3d522ab7df83f19cd05bec87b70c8cc014be00650fe02951ce65e468f8ea2409332a9f488e6f8afbb191a17baae8e8695982d6bc67c6df6513f068a01211cb5a408fd9a58dd62d62c5aa698327266957579d8c773c4d86d25a4f23451fa99112132c0912822891940ab340765bd1bdf048c8f1ee301b25ff14f17710e046e0a5f55c3caaade773e5c1075de36e815e4fbabece52af887461e88bc1749a036a035adf32c91537dc90d6809b047afaffb0f4be2eaae0bf17f18defeb3e54f7109a66674d11b185053563801862e5a8d39aa72bc8882252ffb24be0b42adb43b6457ca1b34cbf82fb2b0f80d2fd6464dafe61fde21cdfdc75d5084c2fe38041c000871f29ac8b5290954a12c60931ebc2bdd3be9d8f938af73abb5871b7cef526f12db673a2ecf7e307fbc3764256c4913eb05a8e321d5c94632e0f9b75dc3e7c6e7bff3acff361382a1f5df6fdc3a2a411e23eb20c813ab9050db38007e0b6489a05a891695da75a493f553916e3d863daf89f98a4a47aa186a193048b1bbde4dce4b515ca15cfc953b92665f1114aee4255805af851bfff0a9d73f7bdc70c4c4c3c2c20676401a84986faef0614a1b2b2c6a58be453587d255880a8112292953883b07a9b154e0556289211da547138b49ff22955cad28f8e4b9732796cdb27523e93b621ec99a78effc6c9a91d3293dda72d2682b607e8fa4016570a201942c40437e97e7852c4b3dc658b63a34e540e346babdd96c43ff068a48bc5a384c111237a89b65b2a722267dc6e330e8bf1817a7028fc686cf2cc0ed9090fa3890fb9e6a6be1ca39cd1e0b06dd028e9ecdcb4a73fdf920744d2c8a18da91f178ac5fb928a612f65a1122195bc18cfa00801cc9adde03493929b9223813813034bd0c85a57cab8a30ba085fd875980e8fc79b9ee068701218c5c08b3fc7eb31f316406a4dea95e9d75dea91c79a937d5c6ab66bb162fef86911b608ff2e965e784fe43502629b8a2ba4601e9f6d28ddc97b9d8a0339f20fcad4d362c7eba0ce91e0174752a75bd46c2126930e6fa8d354992f7428ac3f4dc5e441412d0321f70346c5a1ebd9fdfd91b9835de2794aa8ff87bda70fd9cd7068d79e3586738ef58473022c133012f82307266fdb45480a6c5436febe78b87276161139fc2f11701b671fafee370f839cae57c31d21619640d95f7a0260ecc96cc34b87b5b889ec7e2dacaa985750947b8ae3d96790adabd876a2d4b10ad9a7e1a150d7046c205362ccedae1640bc3c6f61f6a62a5cf148789bb96f3f884a06e7e6a4ebd0ea29ffd105afc315e3f85ec1e3336432c5690da87cf381f0593dce6f4b8d8f3b1f2a72f76b58f05ae42e182004ef02c7b7afc965d2ecb242d0af88e6743bf1cdc59eebd648ea7b8505b55006a0f2979e5b5935c41904e7c317d20d6ca12bcca31d72d4138c234fa0429b8d5e8f306b131cd1c6ea2958f91abc3c2428a0dc20df3b9f45ae307280c2b0dac0c45e4152b048604ab20a5e11ce6382f266a093b582f26ade1df7aa670266a2369dae118b42856aa875023e2500fc380328d612a13f1761cda17de1c31e0b8838a2ec4435931bc0328bf42e2356bb891795c78c4ee763ceead561757cb2335b1a764dbe95b52f11b00ac363daed872c84ccbb3a0efe3b5268c1fee64752ecbea05d32ec7524e5e84b2ff278c8669dbd6b7bfd2a4918e1a6b1a83fdef9e0e25e09713a2aa958db0560a3c6ecb9c3ce136059dbc2ee94002446080d28b3c68e58ba7e3d942bc516c2e6cb2d47622fb8d02c3d781aea5d356dc3bf8ac5a77702c8dfec6e0192183952aa3d6bd01f9d23f0062a084fe0c1283f5b0b5f1835d98d78101d37b10edb753c5966595bf305c61d6cc38ab23229b074d0e165df1094b3dfdbb703d0fbcb0983d63770c0bc545e457a0dd571c51e81426dd024c66482734c1c16d2fa6e1156645a2a070fd13c0c24eb1563cc9088413386a0f0d4efa7bc7db6c435ca276e90e14343e10eb660cd5d711d4e006995cda36e3249548fb67b31a8c8ca236d59e1b422cd86f884edfe4195a9e3ff5d1919983cdf70d676d06c705859944627436d7abaeeba38f5517ec65a720095d71f3f61dcdd719d61648ce93d89fd111b4dcbd5bf992dc2c7bb1f3ed7b3f7fc7337eec3a5aca240825391acefc9ea86184bbef4fa0893b93d91d1d1c931b2836028b02107f4791e7f40dae1d7d75d823fbcc5e9d5459e189736542cba6fe00ee9b3eb7658b364f092004562021017561e8b95febe2176a132630d101e722c8a",
        "signing_randomness": "f813e4a3ac0c066335b62788d3c49a5d02fcf3275ccedf56d7b474b2addc68ab",
        "sha3_256_hash_of_signature": "e3b1aa6c20630d653f152d5cfd97e23fb04460a2af0bdbe2fb5ca664b601d883"
    },
    {
        "key_generation_seed": "f69f3c8296b4217769d3d8137647182ce3cb1e65e9126a69b4df3de71ddac54e",
        "sha3_256_hash_of_verification_key": "831ab391b4d574add279028b1164636aec4756fe029779f454396f4cb0034cf4",
        "sha3_256_hash_of_signing_key": "80aef09f0a13960d6347a5cf533d0150d6a59dde1ad2ff66953b484a931df027",
        "message": "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",
        "signing_randomness": "78421d0941a3bc18449195bc8926069c8e5c1342d600c5e0722d370517cc95fb",
        "sha3_256_hash_of_signature": "118274cfe780200429054ffb62789fef7dd2853f03865ae2d4e3fbd33b605200"
    },
    {
        "key_generation_seed": "da8984e77fecdbc75b7d40b32b48364b5394ddedf767856de5f4ca827f5538d7",
        "sha3_256_hash_of_verification_key": "63a3b2f572cdf2454765a212b4f16d1715d23335ce6f1c2e7f428e8bab619c62",
        "sha3_256_hash_of_signing_key": "73633257338dc58638cefa279d82ecd8ff423366db021549d75f8aa32cd742ea",
        "message": "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",
        "signing_randomness": "cbcf5a32bd05717a88fcae9c64c739095245d6645b379dfacd43415f0c4e187a",
        "sha3_256_hash_of_signature": "86f2f19da7bab3ca1c2e3d6aee5cfecd01a1ffc7290d391f911334e266236575"
    },
    {
        "key_generation_seed": "e768572903c969637bc242e616153e2c23eb730c14421ea4be00a1ea8fedf771",
        "sha3_256_hash_of_verification_key": "69904ce2a579c7f081761d71e92112383bdf3f280b51443da24f444f7c67d6fc",
        "sha3_256_hash_of_signing_key": "d0e8103c1efbbed355042cd3518ad54f2d89a4fffc054a9e8a55e9e99ea43ecc",
        "message": "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",
        "signing_randomness": "33bcaf57a36d94d05a49cf86c426340400f15203c1bf613d0e0c1736f7734aba",
        "sha3_256_hash_of_signature": "fd2b4f5037679e56eeed09c4372589402d9cb26c88a035c4cbb162e4b1e463ae"
    },
    {
        "key_generation_seed": "390305aadea048ff53e89f19e61c9740f1c781fd5fabc7e3b2824002d8f9479a",
        "sha3_256_hash_of_verification_key": "30844cd38b0191e6cf6fc8f72315e3d142ef14553aa1dc6f20cdb92071821019",
        "sha3_256_hash_of_signing_key": "4faf403ace0f23f2fc30d037a8a148484b30f0f4a0e5728c1f81d85dcc9fc02d",
        "message": "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",
        "signing_randomness": "7886b84ede9e5c2b7f6906f55b8dc34f4fed64a3b6512a0f0e8896ab1fba2ff8",
        "sha3_256_hash_of_signature": "818f341ce68be57ec8baec0890fde14f12d3b1b4ac2fe19469584c3d5e64b368"
    },
    {
        "key_generation_seed": "3ff621f45774459a0116cbd926d41e126d981c9ffb22b1275a42949d51b0cb2d",
        "sha3_256_hash_of_verification_key": "1ab1909c978860916bcf843580a6608cc5cd257433414df36095e17f4357cc0b",
        "sha3_256_hash_of_signing_key": "d329362a31be0529c3b5607d65ebce154b2fc503d6e1f80e9d599855e17ba06d",
        "message": "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",
        "signing_randomness": "2d135691f5de0545e2c09a90b11b0083d457f7bf54d17650adbfaadccda862ac",
        "sha3_256_hash_of_signature": "3d1de81638594733ac9bb59d5ac44f0acc2ebb10604a4780acc0e65f902c9515"
    },
    {
        "key_generation_seed": "49af7244bb5bdc0902dea853cd9a780997eb339140276a4008193b993e441e7d",
        "sha3_256_hash_of_verification_key": "bd01156360857aa5b03d962d29971eb4bf3c648c39ba57703bffcda0bc19dddb",
        "sha3_256_hash_of_signing_key": "81ece868a69c3756f3cb63876ddd335ecb679d7871b122a8a6a627779decd71f",
        "message": "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",
        "signing_randomness": "e1ea785bcf0ac245a53beab9a745ec76bdcbda5370d30824defce168bcb86db3",
        "sha3_256_hash_of_signature": "01697a014bf60f583b53ce93a976be3e6578161952427ad7aa054f9839afcf10"
    },
    {
        "key_generation_seed": "6775fbc61982f6198a058df42c1a4954a3dc7c596e6c293a8f3058a7d3ed820d",
        "sha3_256_hash_of_verification_key": "52344a124532086b0744ca129fd917c5623291ca651ab7d93c55786c376e06f6",
        "sha3_256_hash_of_signing_key": "cc6e65bfc1648f3bcf88b75b5512aa673524a4f802a569b99b2591869a58c3fa",
        "message": "a6e3a848c47075ea79fc153c0d65a79424c4366516cbb5ecd2e3efac16862bce0e8a89a0d4fb65468ca9f164525dcf3ad7f79843e59212c92288c260ef1ca6e7f67decaae7a516b5357fc38131eac8195ab851324181384c81bc05ea445b867d65f0b727b0a78b885636bcc342a4f1b6323a13660ea2d282b27fecf2ebadbea688e2b657d328d9245b1d8db89a27c69db53a4dcc501e852386ddc93a98fa8f1353cf52d07a6622810ea50df30d2cc4e708da7f0a51d5fc5e270803650da10d25e3c21d29c3b0ac3f9fbbf17d10b7a96db1594e415490d4b39bc14d637de4e98b609f1a8b01607b0fc145e4238389e0d42911b7a5fc3c6de7b04e4cd44fc882fa04e227b629538a4ab7f8b12f050d2041f9e991983b747f97f23ce2b72480fd6ab2e67818ddb231b734178dd8ba12afca32cba7f653febf4f14837e530f852413b50749a729003cb0931e2f064f0aa6de5da01d371d4f935136cca2e1b454522700c2df53d91f688375916d0afe7c1f5234d4f3c21cd9c8093acfd490a11f2a510139bf60c506f97f0e392d1c3aef050ecae8f13b8a44e9f82964cbb6a738dc47757a32c0d4cdec2e26cfe501ab480955351020cf0441c2ba355c8e6d4c8973fd372b11a050350a88ce0bdce31b41819eb303d94df48ca3b930636678342e4323424db05409f8426c58e4f27ff79546d0c59fbd64bc22a2ade50ebe4758484539026f5895cda295dd24f0ae25392e2598742afbba051868cf828885281136b1acd748bd9f37e18fa1bab5e54788aaf84ac07c73fe6d2db2ef387e11f688ef0bf81d2ea34f3d0096536d3c7a1e8d5f310b40f69896369eb73e8009590bec934e6c9f0d136280864f63ca3cb6b2fc4dbfb7f80c627cf4f3d13bb6a3a783b0fb30a05ae3d749c6fe8c1fc456ed89c54395ffc06b1dabfff6c3c711c1da89b282f8fe59f79139054979da194d9738dbfc0db1cb4f78dbcc55d4e4b1df47339927e675271274952193c11fbf4b768a92227fd47edc11d1f60ba546e0f312db5e4f25cfed1a96978ef7c53632e6eb36f6d28982e49af0fdc8b6930b51c43233418c5a77a175e02e5e950165d265ab7960f58eb11c3edcd246fea7a07ffbf96e5725de2bdb4f369565883f27c5eb8c197334ac7a8e552e120f6f4505e046e41a5357622a0fea80d2a00e7172e862cf67c6358a69c993c007c7b259881453ddf4b3059f7311b126a032775fa91773f63572d1d81fcef137e1fe68b00f9ce27e8c43e501898edb75dfafe010c0843faa5d5d319fbd4c8f7b06dd836e21584644f66ba2d3a50fe94660ea0d9c3f4aaf40d9454b1b4bb739948a2355edfab3ca216408c42e470c41b93454aa3c4f08596dcfc5a38972f5ad61aeee7a2c0978ce0c322d31c77d86991b5373ddde9861175d576969925e0f4ac1d5e970fa4d0b7de206ec3522bbcb2db12e2cac614d7f9110a32d4f7894185675e54fe9688cd4cb51519c1c4ca2679ef4af43114062541867c03867417764bb441b1238cbed0846135159cf68bb0013bdd69695e0b8eb3b119b91f515b6d79968f56682ba476f4f85968a81735930e5fc23ab475c505c3213dda81a2b5be20b6afc635870173c29700e4683c4f9a09c250dcd33817fbca26202b0c9e5c3681f4572f9fdac72ad3aab1b18e53d76e56d0dba5347e0c59e8c5c07ebea60b62199c6b1465484016df2d6a9cb3ac975f07b879b22185451e6b9e7e3a1a097bdffa7c733874f52f875bae098af05b4e8cee47b174b23e11d9e99a1a769cdcf37cff9296b32172ab4de2bbfb8fd942384f6bcc9641edd9eb0e55d4ca95307ef97752a127287b00f919b598994812ce94e871417629e66882700b36bef1da3a721b3564d39767c37ca400d6ebadcd7e63a30990d009c176190f8589eb5e2e7aeeca59ae9c7945949a9457254e4fb0861cbd5e896d755d1469cded95639255adf9e49d1c65fe6a6a32af5b16a947f95f2b128177ab7811d50b219c5ce809eb8db6ebb6ca49e05924a7978774e91ed264239efa127f6d016568ae3ca6a1aee16d1b6e1d913e74dd323ee80d43c44d2074e2e64671cb7812351c39a72eadb096bd52ae25dca9c242e0e9af340d201f781c666fff1a8ddd889d8ab17e982bb633a4bfa2d785300ee9310957fa9c8e26d4316fc3a431efbb8433a40f69c3d113b75b9c3a2b69ee76ec63fee7cbaedd44cbb08d9dc4533bcaf0d4909b52fb51d3372f215fb92551fc71cc846e246675f0d661c578789056b6713ae24184e40ef894fb5547caccb10c26fe52b7b0b8a363e9a6ac934ec55818a00b32362f5175814c4e5fe51d63836fe4a3fdd19e3314f606832fec3f02ca4109bc34e4d8f4e7959245327ea531be9ce77d89d0f2bb4b07ff52b37efc4bb76dabe4135c33379a6f46debbe92c8cd69561b7e28c02790e9364c33e3af52330e1521fbe3342a1443308124ef4b0c1e41258c7000a6079fd520112d8fd20ff3b368025cb28452fd293b927a6d123c797c228aa428b9f118dc2a17b2b60f8ca926bcac8ef42c33495ac1ffb46da8fb0c1a04d481ac29ba9fc9dc4e7548f6bfb861692ce7d839f08a25b48735629883ac8ded8679731fe4c9af371aea1a0efd4818c0f433b9346b04832a359ac733001ad1e73a7916fdb7a699fbffccc46586f392a225948daf7aac832d4ee851122cc37a3f241d38abf45adf7af3793e004a0578a7c72d294e2a7d73129ef0e6f0625c30be5be678f410cbec867e2e10456241a25c27b9946e1a0ef63e3f89954ab76f91fc3a9c89362feb2d6c04dc995b32dfcb18e91b60dfb9f6ea493a6487fbab659b0467fdb8960e78d3277a5434e6641008f43768266e5f7f18fde4ca8c4854e112d745a0d8a09739ee1acaf5697ddafd325e3c4da4dff7d5f89ea80601413601dfd0894789a198dae7fd5fba20e8780db0142defdd6bb3346b56df9de8476bad1ef52b6fa0ee966969735efe6eaa5a9b7ce4b20fc22d95ed798c386f37017e879cbeaa28178c5a084cfa8f85310f666e58c17686c66fd71d2dd80d7bb760ab0f6ae32f71c2412f90a22828343ab4aaff6ffd186d6f7cf0ca35a8f9b78577b7a12eb9076a4cbb12100258d3dd67b7ba451f6d5ee0479f85c8563639edd20eccb9cdd3fa5ba8abe8829c90fd27ee9ddcc8685a2746cff79bfb0a1b66424fdc44cc88a3de540b042cf538ad60b42695566fe0f8afd7e13cafa99412d50a97579f6e3480d9c2357df330ff612e80549cc71b737747e672a2d33079396b1d59239d26b3eb12f75c1799857ff419a706be5f109869166f8d24b999b8eea2b27ac76002e892d71702c5870c0e4979a5d9ba3fa77f73e6171aa4631940004b2864dd544bf36bb0e565898570e337e471994c9cda5970bc18c400f7740751778800c8e5753e201296072f732e86c26b61cdfc434a67582d48c249063ea1aa79f66056ef90c81a822db8d7c7db396058e37d2c5edb23da6ac5dfac9069dfd7832e39228bda9bc9821da8c161823ded051e0a82bcdad26db37d97228062aee903f499c98841663d4d65a045bbe64bd9addca0a6c882497519eaabd0236813c78be648db9dab4d9979846a6fbef4f1dc009dd03e6a287fb594f6cae369005ff0878612594d469d2eb77df48ec934478f36a4509f546ceb27b43624c90b27e9195c97ebcaa03d90deabba286c87a073d7d833f741ea4e2f6e5c302742d58c123bebba563b5ae93e5add02a3a584b51d3a5926437d65bd8ff4a5e0cb6a0e61547be2b3d3d9bf24377c8d1ac6c98970ee4c4d6567d2d74373891df8209880a96e598f4705d276660225ace19325cc820e14308ea178c41ff1adc2f8f0307a6b3f5608fe3b0c93d5605320ea1fb98d65eaaf23e741a27df7dd50035466e3a72dfbd543fd44d5d45625b590f437e0d5ce22cef89a6b949a5f9e0292edd09df22aae7a2a7037c3b2f631ef685baa22fa98565ae28892aee1e97e3f5f448368e6d3268219d5b49f2f5d69ffc1ca6397baed8f788b028d7b15385da50883f8f1fd53a78c9665f766226e4410fcd28d976a142bf9df3335ec45ed0b28344afabba7c7bc0403d26820c1e4d65173d8d1428d0f3d796a51b7a100e117f41059e20c1af5b61775ce27a9d3091f90d759696f90f59298f66def6188e6d58afe8f9a960966110482d8b507389edc3880a3c647628801e35995f3067617e5532cbdf87789413fdfb69b8c5631418f5a4d61ab70c13a16ea05479bc83f51e3756fe914b783f215299b79437f31fb2efc330b4264c5248b15652cfc7cb10a655ae95c9876a0c4426f1829297ad6e6ed74041296de0d16070c",
        "signing_randomness": "8b8e936bd2e13cd2bb6c762e6458f394470fbfefa77f5dba5b17e7d21de1070c",
        "sha3_256_hash_of_signature": "9a5c62aa2297f56a0ec67b54bcb3079b5eb68196cffb12be9e1ccd4eb2f945a5"
    },
    {
        "key_generation_seed": "40c737d9b4a7ec0964a19b7221f606db1a0547382bbfd7e2595014cafb60c045",
        "sha3_256_hash_of_verification_key": "44748232c933140d09e903153c1121560d40be672278731abb5bdfce63c91750",
        "sha3_256_hash_of_signing_key": "12faebb0014e7b63c50e23997a4d1482be0dec6222e635ea58109a84714cb9db",
        "message": "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",
        "signing_randomness": "e8ab7a7126d60eb2084271e47df7d0fd89862d7ab7c5e2d1cc15d2ebc5c36f3d",
        "sha3_256_hash_of_signature": "a611f9d848236df9363310b51f4e3180a9acb3251aad7ef71b15f5d9de9cf0ac"
    },
    {
        "key_generation_seed": "cec6a01fadc9fefefe40dd0995ca8341bab5f4f5bc0a271ced786a2dc224d9f5",
        "sha3_256_hash_of_verification_key": "12487d51ab0a61bc0da7fca650d213ccb947147749c738696e45c8707bf3df35",
        "sha3_256_hash_of_signing_key": "cbdaea2916b6410dcf1b316a3944c39c6fbd666ee0047f6166b0ef58e77bf92e",
        "message": "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",
        "signing_randomness": "462b16bc86adeb9fca4d688d3298bdb6c23308deda13db56ef4752cd2774b067",
        "sha3_256_hash_of_signature": "1794c7cb70571c3c09314226b2e95903ccea275a576e4a3d13a2dd17e1dd19fd"
    },
    {
        "key_generation_seed": "c80a982462aba0725bc5378eb795d16d43451aba9949fc14a48c74374c3d110c",
        "sha3_256_hash_of_verification_key": "a7c1646f5960af731908416292190dc962291ffedd3961fe01e30c0cf21b0cd6",
        "sha3_256_hash_of_signing_key": "400dd7b466f6f65c890cbf962c65a7b700c0705f5e4a7186a24ab31895c1bac4",
        "message": "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",
        "signing_randomness": "5d05c00ab3c11f77990d49166b98b7080537d87c040c4ed8985749627959335e",
        "sha3_256_hash_of_signature": "175c7d89e35391a6f07adb6a317caab572a17824515191ad53e8f953dcf27c78"
    },
    {
        "key_generation_seed": "01105f9386bf55a9197b20fc3fe263422602ac6aa1e1de49c25f42a25614cded",
        "sha3_256_hash_of_verification_key": "92511fe6354fdacfc2c2bad1b32245116b58b27b9f4519247fb71aec0d6b7ee0",
        "sha3_256_hash_of_signing_key": "31d762aa9ab2fa7a82f787809e86f46fea34539735924ef21a71165e00c26e83",
        "message": "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",
        "signing_randomness": "2f28d120444fb1efbde01b8863ad51a2bc093e83d06af3853dff79cc150df697",
        "sha3_256_hash_of_signature": "4c0385fd161c83d3c35c44f1a0b313e66cb0dd7c7440f1b6bf4541cc14502ee0"
    },
    {
        "key_generation_seed": "5a1ca9183e5825f80a6a55cc4590feb7cd7ba2cd698a03a784419ab8173ecc98",
        "sha3_256_hash_of_verification_key": "8ec8f6fbe48759fb03beab4149fe8b3de3af5f13503e0f0f05a16b2519344550",
        "sha3_256_hash_of_signing_key": "1d6a79d8e9dcef8c31a5425e0797fb5603699144eee7df550d4f9b15757347f8",
        "message": "11a1fa5b0bba9b3d4e062f3f2c81e49aae93b0513553520e56b80996ca11665e06b1c2be887274c8404bff439afb0404b7e1c4b2cdd813cec83a73b93eec91e67f37d30cfa24adb7a7d2b595522114e26e31de732a12edd5f869b4dc7d8d77978ca1240d498b9cb9fb13898b89341dcdd6b082b5d02508a091db03c7f77d5ee3b53353dfaa1cf08610ef5bc0a31f9b25ab9092aa1da58be8e57c55796f1ca26df893016f601228413022540e394eaf1f893c4190c5b44a0d36062e95d1fc7f3bbf2a03b0fc302cc85dc8588d382d8abbe1c0112130e7792af66a65d6f68b7d08f269892b53227394f4cc8bacb3a63eba1b6514802c767607f6d4c67b27bf9431a4af42528276e90c5361c3160623fdadb2b020082b2d89f043d528c4fc0c92c32d18186b7a1b71b0a62cf649cd4e3b30c4487b4186a08854aa8593db6e627e6d0b89f79a275f7b10c97fc57213cd27eb6a3f22f40ccb0fb09dea423d33d19de9ac87705030952245fb1222f5999ec570dc326c232b446933cbce8029ddd2fa52aa049cd8817e430438eeb14c3acc06d2175ea303159cfc95a6aadce4c0af4c378ef2242cbfaa2e7bfc7c6e5409a20e277e0e7e8de06e1f976d43fdf5a34df33819ce1cdec602806c585a718fe8688f93aba2065336daa2251dfd7ce476b58afaa1e2f659040fda9914c3cc70c6ec0f58d0de476fa85bdf16e2e6e09b91ad6daced6f5020d44185c82619caf3dcfbb617eac933b8bcb1ddb5ac53a0d4fbbefaee5170486f9e8a8c144760a4480982528c8b35418ea227985df764b0ca7c2090e974e27bfb84fec2b334602b94fa1293ed82ed99ac2a6b61129d37a80965c49c0d5d4e4594002afa2ac4452e95a7eb367560110465356199f13582e30bdaaa92e3163ef030fdfe26e370ae5249ee5ca362640d86f592f9b5be7b4f6005e43fd497e5d652dcd0c61e255608fb4ccf59e72ba823cbb3339eb29aa28d52b5ad9f271ab3aa794a475c513a8742c34700a3ae1d7658678fc0d1eb57acb699c0b8ec37d8fd9aab3c0ac1485ebb1243566e5fa20c92c55a339a2bce1332841d694104fa4385158270af0faf38bac13d92b4b6f3e39aeb2700a331fed7cf22390f5d00932254a4a17346c5f95b8f1085d712b1660dd587641b3b1c06ba71ba60518edf1281937cea1452d54c582a2e216c4b166a9f10d44f16820a243c120730063c45b1286f47168f48863c8daf82d2a97a16ef56e25066727968ff7c5df93e6576c874f156958aa156d0f3110c0e57c3b02d4c276e0347cf43b1e9213d16c944560c1d0241240d2a730b5ac939ad940733d38ff11ea9fe5b28468543e0838802c4a03d6c5bb4e0bb252e86e799516b18e27735e7f6c18b6c54eb0ff9e00a511a689c4b1a74546d3410b354bb6987e2356634b14a9ee3432ccee8ade67f15075e65ecbdb8f56e985287106542398f4f6cfa2cd0ee577aea6493264e3e1779b78884cf2195a686fae6fd67fd3df75504367f6032a68c454b428a7c4292bb070f298b373bfcfbea9305e101a85dc8c5892f8d9b81564a023d06e4edcae2f1a8ee455b9b89057bded440ba78a9b3a396213d1e34a2c8d8be8dde44efe5419911c8724661b1ef79537ec2e22cdc1a3b13e8cba7266d02271143a2a98b1c2a88408f962de76195b2cda33b44ee84ce30f882c0b857a44d7bfc715f7ab147a3fd34a5d0c641e3a811ffbb8773123e2db76204b57b7a74f9fcf34cf8cd79ac3d63b6a02919f756d9c1a0b57360108880c2c81319552e5bb3115f35fa91f068c369c0536f3f9d187e77e87d8aeb87b75f3f9a27af9844929f990498959672f0598bc738ccf933aeb039d4e79597fca386652c9299de15cb77964674fa5d7bba1c7548d62ce43c9eedcecaa68fad7b7d7fd2d3dddf080525d069ca543495b565394849f6434ac0e07c8c4b7ec6523f78d27d3bc42c9d19afd276ef68654a24ba51fa576448757e647156e673ea1e119f1fa4622e762f8ec7f5542ca67c800079194a9a2510ccabd8738e63aad802fa4ba9e270989f1e61954eaf50ca9669906b815c46e5c7a5ea9e318cfc56e616ae2b75dd8494e49c3c25b876ad5eff97093f8522db88b6a14d2d363d5fccb6fd27608ff70e4b08a770d0f9d086b651b304011c256cb18cd8e25450dd438a050246b5c2d1529701933a8a49f70e67b2e2129360e308f9a7ebf02079f0905c0b38a1df75b119c81f4cda57902a723966709cb3cefe0d4a2fa8ffd9fb6d53d7041c4b651cbd3fe2d85768064ff2ec020ee425209802ab05f64d7438f6916872d9a5e15568e0a266a1ed98d9ae573ac50a119da2eabad39ad2c2de5b5b2853021816bcbf0063beed0fbf813548091a68e8abb3edb0680a4c7b9d904ead1694f3cdf7ff0eb1d13a78feee1efaf67a80b2bd8dd2e7bad465344ceb646c89012d954f93fca164ef24ce0e26c837e7222f29a06e962e43bfcf85e090f85626dc5741916a93b6b82adbe137acd4b6e4c9016c3baeca07bcc3980786c4b295ff2788769d942a459b9be6864314a526bde3b14a0d73189ad66eed0d771b33f632c06c90ee2b45ee2842ae18b40ac81471c1d719430eaf1528128b264c67f52d776d9519d755979b9fa5936e8a830f9e8816e434eed3392ffa247f87bca7b5656a784121f8729c9057abf68f4bb78301e209929de74698684d4c2b0fe71e3ce383cbe334b4c4bc0bd8a99e92594c5d25a132fc898a5b6acc8294dd0a43767513e11f44ab439277a448d34c1a883d867597332cbc4084891275020a9adee5c613210a81c41d36d33551d1f7db9004f8d66230f2d6d77f64f7eb3357231958da074c1e4be6e7d8af5911181aef740b7892bcd134706e57336ab119a0d76d9f6fb733d4bb61892f8a9c36c8d46b48fee7c5f453e356c679b998a417e66f748996b2680ddb3b9e4c1538841459a85b339cd59b6e5c92dabc272c742ae8872a0ea86fea272739b8f45e42c50a3bf6a896743948c4d224387a8e2366ce5887d978a4a2ac40f34ff7dc8ff4cc7e41d6bf9281dfab2df31039aee188e8d8f110f9a7462d07fe363f0228f22cfceaaa7bd83deb8abeccfb963d63517edaa3cee701364bd8b7c2c4613b723bb772a2d801fccffe6afd95acd1ab9c522b8dec8efa11378aeb72a081cdbe2eb1aea1f225f54e37b52c2eea71b939e0299a8ac48d094727fab440306dad089729d354187dc76e9d00db402803b73e1652730d55f24d1ccfa7458afa8482e0e5e6f4423aba6bbcedb1294cd30c30df72a4038c5bdc52bc7d40b9319f492a4d4032dde1130a24cdc60bb6c0790e961bcbc68f536cb35994ca668fe8fa368e9dca43904edd304752c62b4aca17798439a124708dcba52eaa2b869fe27e160a6068586cffdaea9df0d6f309b84a90d53b6b7ae7aab7e64d96d8ffe67d2e54a1386be75b2dbda6b7cb84ac67a2dc9f70df1f913ee71ca15b58240f887f49a02ee6f5e11e33ebf55b0ad62a3bca3b69756a6786159b128f510fe9a882171d5236b4534118feedc6d083c59959273bf8d6e34f928e0935c3094122a60b852594d7e587fdaa781715d4f691d3651634f060c5a1a52df515d38a5cbeb66ee17630fa82e50b4e9bffcd795f18cc9d30371ed16d6fe5aa109bf2faecd13b4d1ff99c42567d3bfc1c3f4fc88b51d38b271444202ed05e55a7fc952fd8d1884943ad0af311d0912e735854f877ca658d2907ae5e9852cefd009421a225862cbdbe7e98e4207820615e5232ac82f2a09d54ecd18c9eed17dfb443f5e58a9afca3bc11f3ab613175e8f464e6226d3baa1a122cb0cd15d731689e01b83651ff1477b8537e85d580f312e17e6cf18cf23b7ce4ae08c0995dcb60ea156503f57090cd17ded38a1440acd47c3bfc933102285fb3495d1c2a733b8c4858956a51e52483d04fbaafc45b50b7cffbe6a636c7915e33ea7d2cdf3106504202f28acf277c39c4f5afdaa8651b90474b59927ebcc23a75c0c5549f86012f02bcb439adcfeb17729b481cd4110c233d1bb632709f806d57a4213b86cc95e621d28bff0cafaed629e1dbf4796c1138b5484fecc498191a46feda2d8e70b75191d669faa4974179f5def7e096ec26e324d83267b5040d1cdd2707e5b2918ee04cfd367f5620062cd5c7d8509ddbe26aa8c2abfa74a858084ca7a4286d0904be21e2c930b762ab39566e823d7089dd42b09402d39cf4507bff1d2f3294ea4a43082678e7acb7c74a456ae536fee9f455312d0c4bbc82f170f61bfa4aa7c2353640428c0bb275993f0e3265555bbfa8110c93c22328ec9244f04a23912dc9cf4fdbcd2614ce38aa98930788d271aaa3b46f0e7725b040b09bddfc9b84d5add5c20795af1e526cceba763e02a992b3a1049865762664972882839470a0d7ab462e6639d440bdc9b4ae75c654a3735008ce4328964256ef420881ce804c7323d1e1677e24444cdc852bec87c905b239825de3aac2611fda2d3da473cd857e6dfb65d02b643a9400d1aabbba3edd0f59b0ab6ba97a88ec93b9eaba86c97886f681de7b51c1e3504adcaba12dc9",
        "signing_randomness": "f6a555d41f8761a99820a45fe871d44a4ef5a754d0ca6404c0911dcec4bc696a",
        "sha3_256_hash_of_signature": "7bd833a554fb7e2787d3de6a8b409ed24f387633699d938d30212d482cf32e34"
    },
    {
        "key_generation_seed": "505b966c2c6e99e1c67609aa33f4bc810f1aefe787f97a31c6ccb12766c2d8a5",
        "sha3_256_hash_of_verification_key": "a0160dd9b1b8c37dbb1cc06967726911412b85691aeaa8de773647cfce2622e1",
        "sha3_256_hash_of_signing_key": "ca6e8e614423dc0d3e9229d8709a6e2a4efaab314ac502c3f8b45dfa29c8a481",
        "message": "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",
        "signing_randomness": "056c36ca36eebd38b163722118ca2898e8851540af8a3b8a488734850a998da0",
        "sha3_256_hash_of_signature": "1bedc4c5f68e6899438c3b7918ec7dbe939ede5f961336ed65aae4e3b4fed2b6"
    },
    {
        "key_generation_seed": "29d61476dc801e4ced3df52e62334d6f1757f86666612ebec27f16aef185f47d",
        "sha3_256_hash_of_verification_key": "b693214ba4833e6663b37158d0007048cb475b26761b2f12ee703428ae3dbb28",
        "sha3_256_hash_of_signing_key": "e8dabca00a15d5103293325ef19465b8ace5a78e38c17dad78b44fa90876da1d",
        "message": "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",
        "signing_randomness": "31399b0e5640f0e42d5689f41ee99007e2bb2c5efeabea7df83b65319b5ec13b",
        "sha3_256_hash_of_signature": "fef7971339606fbd58bf65fefdc58a7d9f9e4f3afd784cda166c21171e28e381"
    }
]

================================================
FILE: test/libcrux-ml-kem/CMakeLists.txt
================================================
# cmake -B build -G "Ninja Multi-Config"
# cmake --build build
# # For release (benchmarks)
# cmake --build build --config Release

cmake_minimum_required(VERSION 3.10..4.0)

project(libcrux-ml-kem
    VERSION 0.1.0
    LANGUAGES C CXX
)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_OSX_ARCHITECTURES "x86_64")

if(NOT MSVC)
    # TODO: Clean up
    add_compile_options(
        -Wall

        # -Wextra
        # -pedantic
        # -Wconversion
        # -Wsign-conversion
        $<$<CONFIG:DEBUG>:-g>
        $<$<CONFIG:DEBUG>:-Og>
        $<$<CONFIG:RELEASE>:-g>
        $<$<CONFIG:RELEASE>:-O3>
    )
endif(NOT MSVC)

set(CMAKE_COLOR_DIAGNOSTICS "ON")

set(EURYDICE_ROOT "../..")
set(OUT_DIR "../../out/test-libcrux-ml-kem")

# For LSP-based editors
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
include_directories(
    ${PROJECT_SOURCE_DIR}
    ${PROJECT_SOURCE_DIR}/intrinsics
    ${OUT_DIR}
    ${OUT_DIR}/internal
    ${EURYDICE_ROOT}/include
    ${EURYDICE_ROOT}/karamel/include
)
file(GLOB SOURCES
    ${OUT_DIR}/libcrux_core.c
    ${OUT_DIR}/libcrux_platform.c
    ${OUT_DIR}/libcrux_sha3_portable.c
    ${OUT_DIR}/libcrux_mlkem512.c
    ${OUT_DIR}/libcrux_mlkem768.c
    ${OUT_DIR}/libcrux_mlkem1024.c
    ${OUT_DIR}/libcrux_mlkem_portable.c
    ${OUT_DIR}/libcrux_mlkem512_portable.c
    ${OUT_DIR}/libcrux_mlkem768_portable.c
    ${OUT_DIR}/libcrux_mlkem1024_portable.c
)
file(GLOB SOURCES_vec128
    ${OUT_DIR}/libcrux_mlkem_neon.c
    ${OUT_DIR}/libcrux_mlkem512_neon.c
    ${OUT_DIR}/libcrux_mlkem768_neon.c
    ${OUT_DIR}/libcrux_mlkem1024_neon.c
    ${OUT_DIR}/libcrux_sha3_neon.c
)
file(GLOB SOURCES_vec256
    ${OUT_DIR}/libcrux_mlkem_avx2.c
    ${OUT_DIR}/libcrux_mlkem512_avx2.c
    ${OUT_DIR}/libcrux_mlkem768_avx2.c
    ${OUT_DIR}/libcrux_mlkem1024_avx2.c
    ${OUT_DIR}/libcrux_sha3_avx2.c
)

if(${CMAKE_SYSTEM_NAME} MATCHES Linux)
    add_compile_options(
        -fPIC
    )
endif(${CMAKE_SYSTEM_NAME} MATCHES Linux)

# if(${CMAKE_SYSTEM_NAME} MATCHES Linux AND CMAKE_BUILD_TYPE MATCHES "Release")
#     add_compile_options(
#         -flto
#     )
#     add_link_options(-flto)
# endif(${CMAKE_SYSTEM_NAME} MATCHES Linux AND CMAKE_BUILD_TYPE MATCHES "Release")

add_library(ml_kem SHARED ${SOURCES})
add_library(ml_kem_static STATIC ${SOURCES})

# This is only for local testing and we assume avx2 on x64.
if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|amd64|AMD64")
    message(STATUS "Detected an x64 architecture")
    add_compile_definitions(LIBCRUX_X64)

    add_library(ml_kem_vec256 OBJECT ${SOURCES_vec256})
    target_sources(ml_kem_static PRIVATE $<TARGET_OBJECTS:ml_kem_vec256>)
    target_sources(ml_kem PRIVATE $<TARGET_OBJECTS:ml_kem_vec256>)

    if(NOT MSVC)
        target_compile_options(ml_kem_vec256 PRIVATE
            -mavx
            -mavx2
        )
    endif(NOT MSVC)
endif()

# This is only for local testing and we assume neon on arm64.
if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64|arm64|arm64v8" AND DEFINED ENV{LIBCRUX_NEON})
    message(STATUS "Detected an arm64 architecture")
    add_compile_definitions(LIBCRUX_AARCH64)

    add_library(ml_kem_vec128 OBJECT ${SOURCES_vec128})
    target_sources(ml_kem_static PRIVATE $<TARGET_OBJECTS:ml_kem_vec128>)
    target_sources(ml_kem PRIVATE $<TARGET_OBJECTS:ml_kem_vec128>)
endif()

# --- Tests
if(DEFINED ENV{LIBCRUX_UNPACKED})
    add_compile_definitions(LIBCRUX_UNPACKED)
endif(DEFINED ENV{LIBCRUX_UNPACKED})

# Get gtests
include(FetchContent)
FetchContent_Declare(googletest
    GIT_REPOSITORY https://github.com/google/googletest.git
    GIT_TAG v1.17.0
)

# For Windows: Prevent overriding the parent project's compiler/linker settings
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)

# Get nlohmann json
FetchContent_Declare(json
    GIT_REPOSITORY https://github.com/nlohmann/json.git
    GIT_TAG v3.11.3
)
FetchContent_MakeAvailable(json)

add_executable(ml_kem_test
    ${PROJECT_SOURCE_DIR}/tests/mlkem768.cc
)
target_link_libraries(ml_kem_test PRIVATE
    ml_kem_static
    gtest_main
    nlohmann_json::nlohmann_json
)

add_executable(sha3_test
    ${PROJECT_SOURCE_DIR}/tests/sha3.cc
)
target_link_libraries(sha3_test PRIVATE
    ml_kem_static
    gtest_main
    nlohmann_json::nlohmann_json
)

# --- Benchmarks
if(DEFINED ENV{LIBCRUX_BENCHMARKS})
    FetchContent_Declare(benchmark
        GIT_REPOSITORY https://github.com/google/benchmark.git
        GIT_TAG v1.9.2
    )
    FetchContent_MakeAvailable(benchmark)

    add_executable(ml_kem_bench
        ${PROJECT_SOURCE_DIR}/benches/mlkem768.cc
    )
    target_link_libraries(ml_kem_bench PRIVATE
        ml_kem_static
        benchmark::benchmark
    )

    if(DEFINED ENV{SYMCRYPT_PATH})
        message("Symcrypt path: $ENV{SYMCRYPT_PATH}")
        add_compile_definitions(LIBCRUX_SYMCRYPT)
        target_include_directories(ml_kem_bench PRIVATE $ENV{SYMCRYPT_PATH})
        target_link_directories(ml_kem_bench PRIVATE $ENV{SYMCRYPT_PATH}/bin/lib)
        target_link_libraries(ml_kem_bench PRIVATE symcrypt)
    endif(DEFINED ENV{SYMCRYPT_PATH})

    add_executable(ml_kem_keygen
        ${PROJECT_SOURCE_DIR}/benches/mlkem768_keygen.cc
    )
    target_link_libraries(ml_kem_keygen PRIVATE
        ml_kem_static
        benchmark::benchmark
    )

    add_executable(ml_kem_encaps
        ${PROJECT_SOURCE_DIR}/benches/mlkem768_encaps.cc
    )
    target_link_libraries(ml_kem_encaps PRIVATE
        ml_kem_static
        benchmark::benchmark
    )

    if(NOT MSVC)
        # We benchmark internal functions here that are inlined and thus not available
        # in MSVC.
        add_executable(sha3_bench
            ${PROJECT_SOURCE_DIR}/benches/sha3.cc
        )
        target_link_libraries(sha3_bench PRIVATE
            ml_kem_static
            benchmark::benchmark
        )
    endif(NOT MSVC)
endif(DEFINED ENV{LIBCRUX_BENCHMARKS})


================================================
FILE: test/libcrux-ml-kem/c.yaml
================================================
files:
  # INTRINSICS

  - name: libcrux_intrinsics_neon
    library: true
    inline_static: true
    api:
      - [libcrux_intrinsics, arm64]

  - name: libcrux_intrinsics_avx2
    library: true
    inline_static: true
    api:
      - [libcrux_intrinsics, avx2]

  # SHA3 (no mention of libcrux_mlkem in this section, please)

  # Keep the per-target seperation idea: each SHA3 variant in its own file
  - name: libcrux_sha3_neon
    api:
      - [libcrux_sha3, neon, "*"]
    private:
      # When patterns is the only key of private, it is optional, and one may
      # just specify a list of patterns that are understood to match patterns
      # (not monomorphizations)
      patterns:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
        - [libcrux_sha3, generic_keccak, simd128, "*"]
      monomorphizations_of:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
        - [libcrux_sha3, generic_keccak, simd128, "*"]
      monomorphizations_using:
        - [libcrux_sha3, neon, "*"]
        - [libcrux_sha3, simd, arm64, "*"]
        - [libcrux_sha3, generic_keccak, simd128, "*"]
      monomorphizations_exact:
        - [libcrux_sha3, generic_keccak, "KeccakState_fc"]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_arm64.h"'

  - name: libcrux_sha3_avx2
    api:
      - [libcrux_sha3, avx2, "*"]
    private:
      patterns:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
      monomorphizations_of:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
      monomorphizations_using:
        - [libcrux_sha3, avx2, "*"]
        - [libcrux_sha3, simd, avx2, "*"]
        - [libcrux_sha3, generic_keccak, simd256, "*"]
      monomorphizations_exact:
        - [libcrux_sha3, generic_keccak, KeccakState_7d]
        - [Eurydice, arr_c40]
        - [Eurydice, arr_50]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'

  # Portable SHA3
  - name: libcrux_sha3_portable
    api:
      patterns:
        - [libcrux_sha3, "*"]
        - [libcrux_sha3, simd, portable, "*"]
        - [libcrux_sha3, generic_keccak, portable, "*"]
        - [libcrux_sha3, portable, "*"]
        - [libcrux_sha3, generic_keccak, "*"]
        - [libcrux_sha3, traits, "*"]
        - [libcrux_sha3, generic_keccak, xof, "*"] # xof is only portable for now
      monomorphizations_of:
        - [libcrux_sha3, simd, portable, "*"]
        - [libcrux_sha3, generic_keccak, portable, "*"]
        - [libcrux_sha3, generic_keccak, "*"]
        - [libcrux_sha3, traits, "*"]
        - [libcrux_sha3, portable, "*"]
        - [libcrux_sha3, generic_keccak, xof, "*"]
      monomorphizations_using:
        - [libcrux_sha3, simd, portable, "*"]
        - [libcrux_sha3, generic_keccak, portable, "*"]
        - [libcrux_sha3, generic_keccak, "*"]
        - [libcrux_sha3, traits, "*"]
        - [libcrux_sha3, portable, "*"]
        - [libcrux_sha3, generic_keccak, xof, "*"]

  # Public API header for SHA3
  - name: libcrux_sha3
    inline_static: true
    api:
      exact:
        - [libcrux_sha3, hash]
        - [libcrux_sha3, sha224]
        - [libcrux_sha3, sha256]
        - [libcrux_sha3, sha384]
        - [libcrux_sha3, sha512]
        - [libcrux_sha3, keccakx1]
        - [libcrux_sha3, shake128]
        - [libcrux_sha3, shake256]
        - [libcrux_sha3, shake128_ema]
        - [libcrux_sha3, shake256_ema]
        - [libcrux_sha3, sha224_ema]
        - [libcrux_sha3, sha256_ema]
        - [libcrux_sha3, sha384_ema]
        - [libcrux_sha3, sha512_ema]
        - [libcrux_sha3, portable, sha224]
        - [libcrux_sha3, portable, sha256]
        - [libcrux_sha3, portable, sha384]
        - [libcrux_sha3, portable, sha512]
        - [libcrux_sha3, portable, keccakx1]
        - [libcrux_sha3, portable, shake128]
        - [libcrux_sha3, portable, shake256]

  # Common parts of SHA3 (this catches stuff that hasn't matched above). Must
  # come after the (more precise) patterns above concerning platform-specific hash_functions
  - name: libcrux_sha3_internal
    internal:
      patterns:
        - [libcrux_sha3, "*"]
      monomorphizations_of:
        - [libcrux_sha3, "*"]
      monomorphizations_using:
        - [libcrux_sha3, "*"]
    inline_static: true

  # MLKEM: HASH FUNCTIONS (as used by mlkem)

  - name: libcrux_mlkem_neon
    api:
      - [libcrux_ml_kem, vector, neon, "*"]
      - [libcrux_ml_kem, hash_functions, neon, "*"]
    private:
      monomorphizations_using:
        - [libcrux_ml_kem, vector, neon, "*"]
        - [libcrux_ml_kem, hash_functions, neon, "*"]
      monomorphizations_of:
        - [libcrux_ml_kem, vector, neon, "*"]
        - [libcrux_ml_kem, hash_functions, neon, "*"]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_arm64.h"'

  - name: libcrux_mlkem_avx2
    api:
      - [libcrux_ml_kem, vector, avx2, "*"]
      - [libcrux_ml_kem, hash_functions, avx2, "*"]
    private:
      monomorphizations_using:
        - [libcrux_ml_kem, vector, avx2, "*"]
        - [libcrux_ml_kem, hash_functions, avx2, "*"]
      monomorphizations_of:
        - [libcrux_ml_kem, vector, avx2, "*"]
        - [libcrux_ml_kem, hash_functions, avx2, "*"]
    include_in_h:
      - '"intrinsics/libcrux_intrinsics_avx2.h"'

  # This covers slightly more than the two bundles above, but this greatly
  # simplifies our lives.
  - name: libcrux_mlkem_portable
    api:
      - [libcrux_ml_kem, vector, "*"]
      - [libcrux_ml_kem, hash_functions, portable, "*"]
    private:
      patterns:
        - [ libcrux_ml_kem, polynomial, "*" ]
      monomorphizations_using:
        - [ libcrux_ml_kem, polynomial, "*" ]
        - [ libcrux_ml_kem, vector, "*"]
        - [ libcrux_ml_kem, hash_functions, portable, "*"]
      monomorphizations_of:
        - [ libcrux_ml_kem, polynomial, "*" ]
        - [ libcrux_ml_kem, vector, "*"]
        - [ libcrux_ml_kem, hash_functions, portable, "*"]

  # MLKEM: MISC NON-ARCHITECTURE SPECIFIC HEADERS
  - name: libcrux_core
    private:
      monomorphizations_of:
        - [ Eurydice, "*" ]
        - [ core, "*"]
        - [ libcrux_secrets, "*"]
        - [ libcrux_ml_kem, types, "*"]
        - [ libcrux_ml_kem, constant_time_ops, "*"]
        - [ libcrux_ml_kem, utils, "*" ]
      monomorphizations_using:
        - [ Eurydice, "*" ]
        - [ libcrux_ml_kem, types, "*"]
      patterns:
        - [ core, "*"]
        - [ libcrux_secrets, "*"]
        - [ libcrux_ml_kem, types ]
        - [ libcrux_ml_kem, constants ]
        - [ libcrux_ml_kem, constant_time_ops, "*"]
        - [ libcrux_ml_kem, utils, "*" ]
    api:
      - [Eurydice, "*"]

  # MLKEM-512

  - name: libcrux_mlkem512_avx2
    api:
      - [libcrux_ml_kem, mlkem512, avx2]
    internal:
      - [libcrux_ml_kem, mlkem512, avx2, unpacked]

  - name: libcrux_mlkem512_neon
    api:
      - [libcrux_ml_kem, mlkem512, neon]
    internal:
      - [libcrux_ml_kem, mlkem512, neon, unpacked]

  - name: libcrux_mlkem512_portable
    api:
      - [libcrux_ml_kem, mlkem512, portable]
    internal:
      - [libcrux_ml_kem, mlkem512, portable, unpacked]

  # This one contains common definitions like types, etc.
  - name: libcrux_mlkem512
    api:
      - [libcrux_ml_kem, mlkem512]

  # MLKEM-768

  - name: libcrux_mlkem768_avx2
    api:
      - [libcrux_ml_kem, mlkem768, avx2]
    internal:
      - [libcrux_ml_kem, mlkem768, avx2, unpacked]

  - name: libcrux_mlkem768_neon
    api:
      - [libcrux_ml_kem, mlkem768, neon]
    internal:
      - [libcrux_ml_kem, mlkem768, neon, unpacked]

  - name: libcrux_mlkem768_portable
    api:
      - [libcrux_ml_kem, mlkem768, portable]
    internal:
      - [libcrux_ml_kem, mlkem768, portable, unpacked]

  # This one contains common definitions like types, etc.
  - name: libcrux_mlkem768
    api:
      - [libcrux_ml_kem, mlkem768]

  # MLKEM-1024

  - name: libcrux_mlkem1024_avx2
    api:
      - [libcrux_ml_kem, mlkem1024, avx2]
    internal:
      - [libcrux_ml_kem, mlkem1024, avx2, unpacked]

  - name: libcrux_mlkem1024_neon
    api:
      - [libcrux_ml_kem, mlkem1024, neon]
    internal:
      - [libcrux_ml_kem, mlkem1024, neon, unpacked]

  - name: libcrux_mlkem1024_portable
    api:
      - [libcrux_ml_kem, mlkem1024, portable]
    internal:
      - [libcrux_ml_kem, mlkem1024, portable, unpacked]

  # This one contains common definitions like types, etc.
  - name: libcrux_mlkem1024
    api:
      - [libcrux_ml_kem, mlkem1024]

  # We let monomorphization insert things at the right place in each one of the
  # 9 variants above. Helpers that have not been assigned into any of the
  # individual libcrux_mlkemXXX files end up in a catch-all.
  - name: libcrux_mlkem_common
    private:
      - [libcrux_ml_kem, "*"]
    inline_static: true

naming:
  skip_prefix:
    - [ core, core_arch, arm_shared, neon ]
    - [ core, core_arch, x86 ]
    - [libcrux_intrinsics, arm64]
    - [libcrux_intrinsics, avx2]


================================================
FILE: test/libcrux-ml-kem/intrinsics/libcrux_intrinsics_avx2.h
================================================
/*
  This file was generated by KaRaMeL <https://github.com/FStarLang/karamel>
  KaRaMeL invocation:
  /nix/store/c9m211bm84ncjmaxx27ki9dymd4qkwm2-ocaml4.14.1-eurydice-dirty/eurydice
  --config ../c.yaml ../../libcrux_ml_kem.llbc F* version: <unknown> KaRaMeL
  version: <unknown>
 */

#ifndef __libcrux_intrinsics_avx2_H
#define __libcrux_intrinsics_avx2_H

#if defined(__cplusplus)
extern "C" {
#endif

#include "eurydice_glue.h"
#include "immintrin.h"

typedef __m128i core_core_arch_x86___m128i;
typedef __m256i core_core_arch_x86___m256i;

// Cast and Convert

static inline core_core_arch_x86___m128i mm256_castsi256_si128(
    core_core_arch_x86___m256i a) {
  return _mm256_castsi256_si128(a);
}

static inline core_core_arch_x86___m256i mm256_cvtepi16_epi32(
    core_core_arch_x86___m128i a) {
  return _mm256_cvtepi16_epi32(a);
}

static inline core_core_arch_x86___m256i mm256_castsi128_si256(
    core_core_arch_x86___m128i a) {
  return _mm256_castsi128_si256(a);
}

// Initialize, Load, Store

static inline core_core_arch_x86___m256i mm256_setzero_si256(void) {
  return _mm256_setzero_si256();
}

static inline core_core_arch_x86___m256i mm256_set1_epi16(int16_t a) {
  return _mm256_set1_epi16(a);
}

static inline core_core_arch_x86___m256i mm256_set1_epi32(int32_t a) {
  return _mm256_set1_epi32(a);
}

static inline core_core_arch_x86___m256i mm256_set1_epi64x(int64_t a) {
  return _mm256_set1_epi64x(a);
}

static inline core_core_arch_x86___m128i mm_set1_epi16(int16_t a) {
  return _mm_set1_epi16(a);
}

static inline core_core_arch_x86___m256i mm256_set_epi16(
    int16_t x0, int16_t x1, int16_t x2, int16_t x3, int16_t x4, int16_t x5,
    int16_t x6, int16_t x7, int16_t x8, int16_t x9, int16_t x10, int16_t x11,
    int16_t x12, int16_t x13, int16_t x14, int16_t x15) {
  return _mm256_set_epi16(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
                          x13, x14, x15);
}

static inline core_core_arch_x86___m256i mm256_set_epi8(
    int8_t x0, int8_t x1, int8_t x2, int8_t x3, int8_t x4, int8_t x5, int8_t x6,
    int8_t x7, int8_t x8, int8_t x9, int8_t x10, int8_t x11, int8_t x12,
    int8_t x13, int8_t x14, int8_t x15, int8_t x16, int8_t x17, int8_t x18,
    int8_t x19, int8_t x20, int8_t x21, int8_t x22, int8_t x23, int8_t x24,
    int8_t x25, int8_t x26, int8_t x27, int8_t x28, int8_t x29, int8_t x30,
    int8_t x31) {
  return _mm256_set_epi8(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
                         x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23,
                         x24, x25, x26, x27, x28, x29, x30, x31);
}

static inline core_core_arch_x86___m128i mm_set_epi8(
    uint8_t x0, uint8_t x1, uint8_t x2, uint8_t x3, uint8_t x4, uint8_t x5,
    uint8_t x6, uint8_t x7, uint8_t x8, uint8_t x9, uint8_t x10, uint8_t x11,
    uint8_t x12, uint8_t x13, uint8_t x14, uint8_t x15) {
  return _mm_set_epi8(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
                      x13, x14, x15);
}

static inline core_core_arch_x86___m256i mm256_set_epi32(int32_t x0, int32_t x1,
                                                         int32_t x2, int32_t x3,
                                                         int32_t x4, int32_t x5,
                                                         int32_t x6,
                                                         int32_t x7) {
  return _mm256_set_epi32(x0, x1, x2, x3, x4, x5, x6, x7);
}

static inline core_core_arch_x86___m256i mm256_loadu_si256_i16(
    Eurydice_borrow_slice_i16 a) {
  return _mm256_loadu_si256((const __m256i*)a.ptr);
}

static inline core_core_arch_x86___m256i mm256_loadu_si256_u8(
    Eurydice_borrow_slice_u8 a) {
  return _mm256_loadu_si256((const __m256i*)a.ptr);
}

static inline core_core_arch_x86___m128i mm_loadu_si128(Eurydice_borrow_slice_u8 a) {
  return _mm_loadu_si128((const __m128i*)a.ptr);
}

static inline void mm_storeu_bytes_si128(Eurydice_mut_borrow_slice_u8 a,
                                         core_core_arch_x86___m128i b) {
  _mm_storeu_si128((__m128i*)a.ptr, b);
}

static inline void mm256_storeu_si256_i16(Eurydice_mut_borrow_slice_i16 a,
                                          core_core_arch_x86___m256i b) {
  _mm256_storeu_si256((__m256i*)a.ptr, b);
}

static inline void mm256_storeu_si256_u8(Eurydice_mut_borrow_slice_u8 a,
                                         core_core_arch_x86___m256i b) {
  _mm256_storeu_si256((__m256i*)a.ptr, b);
}

static inline void mm_storeu_si128(Eurydice_mut_borrow_slice_i16 a,
                                   core_core_arch_x86___m128i b) {
  _mm_storeu_si128((__m128i*)a.ptr, b);
}

// Arithmetic: Add, Sub

static inline core_core_arch_x86___m256i mm256_add_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_add_epi16(a, b);
}

static inline core_core_arch_x86___m256i mm256_add_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_add_epi32(a, b);
}

static inline core_core_arch_x86___m128i mm_add_epi16(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_add_epi16(a, b);
}

static inline core_core_arch_x86___m256i mm256_sub_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_sub_epi16(a, b);
}

static inline core_core_arch_x86___m128i mm_sub_epi16(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_sub_epi16(a, b);
}

// Arithmetic: Mul low and high, Mul-Add combinations

static inline core_core_arch_x86___m256i mm256_mullo_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_mullo_epi16(a, b);
}

static inline core_core_arch_x86___m256i mm256_mulhi_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_mulhi_epi16(a, b);
}

static inline core_core_arch_x86___m256i mm256_mul_epu32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_mul_epu32(a, b);
}

static inline core_core_arch_x86___m256i mm256_mullo_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_mullo_epi32(a, b);
}

static inline core_core_arch_x86___m128i mm_mullo_epi16(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_mullo_epi16(a, b);
}

static inline core_core_arch_x86___m128i mm_mulhi_epi16(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_mulhi_epi16(a, b);
}

static inline core_core_arch_x86___m256i mm256_madd_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_madd_epi16(a, b);
}

// Comparison

static inline core_core_arch_x86___m256i mm256_cmpgt_epi16(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_cmpgt_epi16(a, b);
}

// Bitwise operations

static inline core_core_arch_x86___m256i mm256_and_si256(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_and_si256(a, b);
}

static inline core_core_arch_x86___m256i mm256_andnot_si256(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_andnot_si256(a, b);
}

static inline core_core_arch_x86___m256i mm256_xor_si256(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_xor_si256(a, b);
}

static inline int32_t mm_movemask_epi8(core_core_arch_x86___m128i a) {
  return _mm_movemask_epi8(a);
}

// Shift operations
#define mm256_srai_epi16(a, b, _) (_mm256_srai_epi16(b, a))

#define mm256_srli_epi16(a, b, _) (_mm256_srli_epi16(b, a))

#define mm256_slli_epi16(a, b, _) (_mm256_slli_epi16(b, a))

#define mm256_slli_epi32(a, b, _) (_mm256_slli_epi32(b, a))

static inline core_core_arch_x86___m256i mm256_slli_epi64_(
    int32_t a, core_core_arch_x86___m256i b) {
  return _mm256_slli_epi64(b, a);
}

#define mm256_slli_epi64(a, b, c) (mm256_slli_epi64_(a, b))

#define mm256_srai_epi32(a, b, _) (_mm256_srai_epi32(b, a))

#define mm256_srli_epi32(a, b, _) (_mm256_srli_epi32(b, a))

static inline core_core_arch_x86___m256i mm256_sllv_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_sllv_epi32(a, b);
}

static inline core_core_arch_x86___m256i mm256_srli_epi64_(
    int32_t a, core_core_arch_x86___m256i b) {
  return _mm256_srli_epi64(b, a);
}

#define mm256_srli_epi64(a, b, c) (mm256_srli_epi64_(a, b))

// Shuffle and Vector Interleaving

static inline core_core_arch_x86___m256i mm256_unpacklo_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_unpacklo_epi32(a, b);
}

static inline core_core_arch_x86___m256i mm256_unpacklo_epi64(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_unpacklo_epi64(a, b);
}

static inline core_core_arch_x86___m256i mm256_unpackhi_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_unpackhi_epi32(a, b);
}

static inline core_core_arch_x86___m256i mm256_unpackhi_epi64(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_unpackhi_epi64(a, b);
}

static inline core_core_arch_x86___m256i mm256_packs_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_packs_epi32(a, b);
}

static inline core_core_arch_x86___m128i mm_packs_epi16(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_packs_epi16(a, b);
}

#define mm256_shuffle_epi32(a, b, _) (_mm256_shuffle_epi32(b, a))

#define mm256_extracti128_si256(a, b, _) (_mm256_extracti128_si256(b, a))

#define mm256_permute4x64_epi64(a, b, _) (_mm256_permute4x64_epi64(b, a))

#define mm256_permute2x128_si256(a, b, c, d) \
  (_mm256_permute2x128_si256(b, c, a))

#define mm256_inserti128_si256(a, b, c, _) (_mm256_inserti128_si256(b, c, a))

#define mm256_blend_epi16(a, b, c, _) (_mm256_blend_epi16(b, c, a))

static inline core_core_arch_x86___m256i mm256_shuffle_epi8(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_shuffle_epi8(a, b);
}

static inline core_core_arch_x86___m256i mm256_permutevar8x32_epi32(
    core_core_arch_x86___m256i a, core_core_arch_x86___m256i b) {
  return _mm256_permutevar8x32_epi32(a, b);
}

static inline core_core_arch_x86___m128i mm_shuffle_epi8(
    core_core_arch_x86___m128i a, core_core_arch_x86___m128i b) {
  return _mm_shuffle_epi8(a, b);
}

#if defined(__cplusplus)
}
#endif

#define __libcrux_intrinsics_avx2_H_DEFINED
#endif


================================================
FILE: test/libcrux-ml-kem/tests/mlkem768.cc
================================================
/*
 *    Copyright 2023 Cryspen Sarl
 *
 *    Licensed under the Apache License, Version 2.0 or MIT.
 *    - http://www.apache.org/licenses/LICENSE-2.0
 *    - http://opensource.org/licenses/MIT
 */

#include <fstream>
#include <gtest/gtest.h>
#include <nlohmann/json.hpp>

#include "libcrux_sha3_portable.h"
#include "libcrux_mlkem768.h"
#include "libcrux_mlkem768_portable.h"
#include "internal/libcrux_core.h"

using namespace std;

typedef vector<uint8_t> bytes;

Eurydice_borrow_slice_u8 mk_slice_u8(uint8_t *x, size_t len)
{
    Eurydice_borrow_slice_u8 s;
    s.ptr = x;
    s.meta = len;
    return s;
}

// Not really random
void generate_random(uint8_t *output, uint32_t output_len)
{
    for (size_t i = 0; i < output_len; i++)
    {
        output[i] = 13;
    }
}

vector<uint8_t>
from_hex(const string &hex)
{
    if (hex.length() % 2 == 1)
    {
        throw invalid_argument("Odd-length hex string");
    }

    int len = static_cast<int>(hex.length()) / 2;
    vector<uint8_t> out(len);
    for (int i = 0; i < len; i += 1)
    {
        string byte = hex.substr(2 * i, 2);
        out[i] = static_cast<uint8_t>(strtol(byte.c_str(), nullptr, 16));
    }

    return out;
}

string
bytes_to_hex(const vector<uint8_t> &data)
{
    stringstream hex(ios_base::out);
    hex.flags(ios::hex);
    for (const auto &byte : data)
    {
        hex << setw(2) << setfill('0') << int(byte);
    }
    return hex.str();
}

class KAT
{
public:
    bytes key_generation_seed;
    bytes sha3_256_hash_of_public_key;
    bytes sha3_256_hash_of_secret_key;
    bytes encapsulation_seed;
    bytes sha3_256_hash_of_ciphertext;
    bytes shared_secret;
};

vector<KAT>
read_kats(string path)
{
    ifstream kat_file(path);
    nlohmann::json kats_raw;
    kat_file >> kats_raw;

    vector<KAT> kats;

    // Read test group
    for (auto &kat_raw : kats_raw.items())
    {
        auto kat_raw_value = kat_raw.value();

        kats.push_back(KAT{
            .key_generation_seed = from_hex(kat_raw_value["key_generation_seed"]),
            .sha3_256_hash_of_public_key =
                from_hex(kat_raw_value["sha3_256_hash_of_public_key"]),
            .sha3_256_hash_of_secret_key =
                from_hex(kat_raw_value["sha3_256_hash_of_secret_key"]),
            .encapsulation_seed = from_hex(kat_raw_value["encapsulation_seed"]),
            .sha3_256_hash_of_ciphertext =
                from_hex(kat_raw_value["sha3_256_hash_of_ciphertext"]),
            .shared_secret = from_hex(kat_raw_value["shared_secret"]),
        });
    }

    return kats;
}

void modify_ciphertext(uint8_t *ciphertext, size_t ciphertext_size)
{
    uint8_t randomness[3];
    generate_random(randomness, 3);

    uint8_t random_byte = randomness[0];
    if (random_byte == 0)
    {
        random_byte += 1;
    }

    uint16_t random_u16 = (randomness[2] << 8) | randomness[1];

    uint16_t random_position = random_u16 % ciphertext_size;

    ciphertext[random_position] ^= random_byte;
}

void modify_secret_key(uint8_t *secret_key,
                       size_t secret_key_size,
                       bool modify_implicit_rejection_value)
{
    uint8_t randomness[3];
    generate_random(randomness, 3);

    uint8_t random_byte = randomness[0];
    if (random_byte == 0)
    {
        random_byte += 1;
    }

    uint16_t random_u16 = (randomness[2] << 8) | randomness[1];

    uint16_t random_position = 0;

    if (modify_implicit_rejection_value == true)
    {
        random_position = (secret_key_size - 32) + (random_u16 % 32);
    }
    else
    {
        random_position = random_u16 % (secret_key_size - 32);
    }

    secret_key[random_position] ^= random_byte;
}

uint8_t *
compute_implicit_rejection_shared_secret(uint8_t *ciphertext,
                                         size_t ciphertext_size,
                                         uint8_t *secret_key,
                                         size_t secret_key_size)
{
    uint8_t *hashInput = new uint8_t[32 + ciphertext_size];
    uint8_t *sharedSecret = new uint8_t[32];
    Eurydice_mut_borrow_slice_u8 ss;
    ss.ptr = sharedSecret;
    ss.meta = 32;

    std::copy(secret_key + (secret_key_size - 32),
              secret_key + secret_key_size,
              hashInput);
    std::copy(ciphertext, ciphertext + ciphertext_size, hashInput + 32);

    libcrux_sha3_portable_shake256(ss, mk_slice_u8(hashInput, 32 + ciphertext_size));

    delete[] hashInput;
    return sharedSecret;
}

typedef Eurydice_arr_c7 libcrux_sha3_Sha3_512Digest;

TEST(MlKem768TestPortable, ConsistencyTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    for (int i = 0; i < 64; i++)
    {
        randomness.data[i] = 13;
    }
    auto key_pair = libcrux_ml_kem_mlkem768_portable_generate_key_pair(randomness);
    //  cout << "key pair.pk: " << bytes_to_hex(bytes(key_pair.pk.value, key_pair.pk.value + 16U)) << endl;
    //  cout << "key pair.sk: " << bytes_to_hex(bytes(key_pair.sk.value, key_pair.sk.value + 16U)) << endl;

    Eurydice_arr_ec randomness32;
    memcpy(randomness32.data, randomness.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate(&key_pair.pk, randomness32);

    // cout << "ctxt: " << bytes_to_hex(bytes(ctxt.fst.value, ctxt.fst.value + 16U)) << endl;

    Eurydice_arr_ec sharedSecret2 = libcrux_ml_kem_mlkem768_portable_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_EQ(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
}

#ifdef LIBCRUX_UNPACKED
TEST(MlKem768TestPortableUnpacked, ConsistencyTest)
{
    uint8_t randomness[64];
    generate_random(randomness, 64);
    auto key_pair = libcrux_ml_kem_mlkem768_portable_generate_key_pair_unpacked(randomness);

    uint8_t randomness2[32];
    generate_random(randomness2, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate_unpacked(&key_pair.public_key, randomness2);

    uint8_t sharedSecret2[LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE];
    libcrux_ml_kem_mlkem768_portable_decapsulate_unpacked(&key_pair, &ctxt.fst, sharedSecret2);

    EXPECT_EQ(0,
              memcmp(ctxt.snd,
                     sharedSecret2,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
}
#endif // #ifdef LIBCRUX_UNPACKED

TEST(Kyber768TestPortable, ModifiedCiphertextTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    generate_random(randomness.data, 64);
    auto key_pair = libcrux_ml_kem_mlkem768_portable_generate_key_pair(randomness);

    Eurydice_arr_ec randomness32;
    generate_random(randomness32.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate(&key_pair.pk, randomness32);

    modify_ciphertext(ctxt.fst.data,
                      LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE);
    auto sharedSecret2 = libcrux_ml_kem_mlkem768_portable_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_NE(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

    uint8_t *implicitRejectionSharedSecret =
        compute_implicit_rejection_shared_secret(
            ctxt.fst.data,
            LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE,
            key_pair.sk.data,
            LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE);

    EXPECT_EQ(0,
              memcmp(implicitRejectionSharedSecret,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    delete[] implicitRejectionSharedSecret;
}

TEST(Kyber768TestPortable, ModifiedSecretKeyTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    generate_random(randomness.data, 64);
    auto key_pair = libcrux_ml_kem_mlkem768_portable_generate_key_pair(randomness);

    Eurydice_arr_ec randomness32;
    generate_random(randomness32.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate(&key_pair.pk, randomness32);

    modify_secret_key(
        key_pair.sk.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE, false);
    auto sharedSecret2 = libcrux_ml_kem_mlkem768_portable_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_NE(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

    modify_secret_key(
        ctxt.snd.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE, true);
    sharedSecret2 = libcrux_ml_kem_mlkem768_portable_decapsulate(&key_pair.sk, &ctxt.fst);

    uint8_t *implicitRejectionSharedSecret =
        compute_implicit_rejection_shared_secret(
            ctxt.fst.data,
            LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE,
            key_pair.sk.data,
            LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE);
    EXPECT_EQ(0,
              memcmp(implicitRejectionSharedSecret,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    delete[] implicitRejectionSharedSecret;
}

TEST(MlKem768TestPortable, NISTKnownAnswerTest)
{
    // XXX: This should be done in a portable way.
    auto kats = read_kats("tests/mlkem768_nistkats.json");

    for (auto kat : kats)
    {
        libcrux_sha3_Sha3_512Digest randomness;
        memcpy(randomness.data, kat.key_generation_seed.data(), 64);
        auto key_pair =
            libcrux_ml_kem_mlkem768_portable_generate_key_pair(randomness);

        auto pk_hash =
          libcrux_sha3_sha256(
              mk_slice_u8(key_pair.pk.data,
                       LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE));
        EXPECT_EQ(0, memcmp(pk_hash.data, kat.sha3_256_hash_of_public_key.data(), 32));

        auto sk_hash =
          libcrux_sha3_sha256(
              mk_slice_u8(key_pair.sk.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE));
        EXPECT_EQ(0, memcmp(sk_hash.data, kat.sha3_256_hash_of_secret_key.data(), 32));

        Eurydice_arr_ec randomness32;
        memcpy(randomness32.data, kat.encapsulation_seed.data(), 32);
        auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate(
            &key_pair.pk, randomness32);
        auto ct_hash =
        libcrux_sha3_sha256(
            mk_slice_u8(ctxt.fst.data,
                     LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE));
        EXPECT_EQ(0, memcmp(ct_hash.data, kat.sha3_256_hash_of_ciphertext.data(), 32));
        EXPECT_EQ(0,
                  memcmp(ctxt.snd.data,
                         kat.shared_secret.data(),
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

        auto sharedSecret2 =
          libcrux_ml_kem_mlkem768_portable_decapsulate(&key_pair.sk, &ctxt.fst);

        EXPECT_EQ(0,
                  memcmp(ctxt.snd.data,
                         sharedSecret2.data,
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    }
}

#ifdef LIBCRUX_UNPACKED
TEST(MlKem768TestPortableUnpacked, NISTKnownAnswerTest)
{
    // XXX: This should be done in a portable way.
    auto kats = read_kats("tests/mlkem768_nistkats.json");

    for (auto kat : kats)
    {
        auto key_pair =
            libcrux_ml_kem_mlkem768_portable_generate_key_pair_unpacked(kat.key_generation_seed.data());

        // We can't check the keys because we don't really have them.

        auto ctxt = libcrux_ml_kem_mlkem768_portable_encapsulate_unpacked(&key_pair.public_key, kat.encapsulation_seed.data());

        uint8_t ct_hash[32];
        libcrux_sha3_sha256(
            mk_slice_u8(ctxt.fst.value,
                     LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE),
            ct_hash);
        EXPECT_EQ(0, memcmp(ct_hash, kat.sha3_256_hash_of_ciphertext.data(), 32));
        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         kat.shared_secret.data(),
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

        uint8_t sharedSecret2[LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE];
        libcrux_ml_kem_mlkem768_portable_decapsulate_unpacked(&key_pair, &ctxt.fst, sharedSecret2);

        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         sharedSecret2,
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    }
}
#endif // #ifdef LIBCRUX_UNPACKED

#ifdef LIBCRUX_X64
#include "libcrux_mlkem768_avx2.h"

TEST(MlKem768TestAvx2, ConsistencyTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    for (int i = 0; i < 64; i++)
    {
        randomness.data[i] = 13;
    }
    auto key_pair = libcrux_ml_kem_mlkem768_avx2_generate_key_pair(randomness);
    Eurydice_arr_ec randomness32;
    memcpy(randomness32.data, randomness.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_avx2_encapsulate(&key_pair.pk, randomness32);

    auto sharedSecret2 =
      libcrux_ml_kem_mlkem768_avx2_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_EQ(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
}

TEST(Kyber768TestAvx2, ModifiedCiphertextTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    generate_random(randomness.data, 64);
    auto key_pair = libcrux_ml_kem_mlkem768_avx2_generate_key_pair(randomness);

    Eurydice_arr_ec randomness32;
    generate_random(randomness32.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_avx2_encapsulate(&key_pair.pk, randomness32);

    modify_ciphertext(ctxt.fst.data,
                      LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE);
    auto sharedSecret2 =
      libcrux_ml_kem_mlkem768_avx2_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_NE(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

    uint8_t *implicitRejectionSharedSecret =
        compute_implicit_rejection_shared_secret(
            ctxt.fst.data,
            LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE,
            key_pair.sk.data,
            LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE);

    EXPECT_EQ(0,
              memcmp(implicitRejectionSharedSecret,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    delete[] implicitRejectionSharedSecret;
}

TEST(Kyber768TestAvx2, ModifiedSecretKeyTest)
{
    libcrux_sha3_Sha3_512Digest randomness;
    generate_random(randomness.data, 64);
    auto key_pair = libcrux_ml_kem_mlkem768_avx2_generate_key_pair(randomness);

    Eurydice_arr_ec randomness32;
    generate_random(randomness32.data, 32);
    auto ctxt = libcrux_ml_kem_mlkem768_avx2_encapsulate(&key_pair.pk, randomness32);

    modify_secret_key(
        key_pair.sk.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE, false);
    auto sharedSecret2 =
      libcrux_ml_kem_mlkem768_avx2_decapsulate(&key_pair.sk, &ctxt.fst);

    EXPECT_NE(0,
              memcmp(ctxt.snd.data,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

    modify_secret_key(
        ctxt.snd.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE, true);
    sharedSecret2 = libcrux_ml_kem_mlkem768_avx2_decapsulate(&key_pair.sk, &ctxt.fst);

    uint8_t *implicitRejectionSharedSecret =
        compute_implicit_rejection_shared_secret(
            ctxt.fst.data,
            LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE,
            key_pair.sk.data,
            LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE);
    EXPECT_EQ(0,
              memcmp(implicitRejectionSharedSecret,
                     sharedSecret2.data,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    delete[] implicitRejectionSharedSecret;
}

TEST(MlKem768TestAvx2, NISTKnownAnswerTest)
{
    // XXX: This should be done in a portable way.
    auto kats = read_kats("tests/mlkem768_nistkats.json");

    for (auto kat : kats)
    {
        libcrux_sha3_Sha3_512Digest randomness;
        memcpy(randomness.data, kat.key_generation_seed.data(), 64);
        auto key_pair = libcrux_ml_kem_mlkem768_avx2_generate_key_pair(randomness);

        auto pk_hash =
          libcrux_sha3_sha256(
              mk_slice_u8(key_pair.pk.data,
                       LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE));
        EXPECT_EQ(0, memcmp(pk_hash.data, kat.sha3_256_hash_of_public_key.data(), 32));

        auto sk_hash =
          libcrux_sha3_sha256(
              mk_slice_u8(key_pair.sk.data, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE));
        EXPECT_EQ(0, memcmp(sk_hash.data, kat.sha3_256_hash_of_secret_key.data(), 32));

        Eurydice_arr_ec randomness32;
        memcpy(randomness32.data, kat.encapsulation_seed.data(), 32);
        auto ctxt = libcrux_ml_kem_mlkem768_avx2_encapsulate(
            &key_pair.pk, randomness32);
        auto ct_hash =
          libcrux_sha3_sha256(
              mk_slice_u8(ctxt.fst.data,
                       LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE));
        EXPECT_EQ(0, memcmp(ct_hash.data, kat.sha3_256_hash_of_ciphertext.data(), 32));
        EXPECT_EQ(0,
                  memcmp(ctxt.snd.data,
                         kat.shared_secret.data(),
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

        auto sharedSecret2 =
          libcrux_ml_kem_mlkem768_avx2_decapsulate(&key_pair.sk, &ctxt.fst);

        EXPECT_EQ(0,
                  memcmp(ctxt.snd.data,
                         sharedSecret2.data,
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    }
}

#ifdef LIBCRUX_UNPACKED
TEST(MlKem768TestAvx2Unpacked, NISTKnownAnswerTest)
{
    // XXX: This should be done in a portable way.
    auto kats = read_kats("tests/mlkem768_nistkats.json");

    for (auto kat : kats)
    {
        auto key_pair =
            libcrux_ml_kem_mlkem768_avx2_generate_key_pair_unpacked(kat.key_generation_seed.data());

        // We can't check the keys because we don't really have them.

        auto ctxt = libcrux_ml_kem_mlkem768_avx2_encapsulate_unpacked(&key_pair.public_key, kat.encapsulation_seed.data());

        uint8_t ct_hash[32];
        libcrux_sha3_sha256(
            mk_slice_u8(ctxt.fst.value,
                     LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE),
            ct_hash);
        EXPECT_EQ(0, memcmp(ct_hash, kat.sha3_256_hash_of_ciphertext.data(), 32));
        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         kat.shared_secret.data(),
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

        uint8_t sharedSecret2[LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE];
        libcrux_ml_kem_mlkem768_avx2_decapsulate_unpacked(&key_pair, &ctxt.fst, sharedSecret2);

        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         sharedSecret2,
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    }
}
#endif // #ifdef LIBCRUX_UNPACKED

#endif // LIBCRUX_X64

#ifdef LIBCRUX_AARCH64
#include "libcrux_mlkem768_neon.h"

TEST(MlKem768TestNeon, ConsistencyTest)
{
    uint8_t randomness[64];
    for (int i = 0; i < 64; i++)
        randomness[i] = 13;
    auto key_pair = libcrux_ml_kem_mlkem768_neon_generate_key_pair(randomness);
    auto ctxt = libcrux_ml_kem_mlkem768_neon_encapsulate(&key_pair.pk, randomness);

    uint8_t sharedSecret2[LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE];
    libcrux_ml_kem_mlkem768_neon_decapsulate(&key_pair.sk, &ctxt.fst, sharedSecret2);

    EXPECT_EQ(0,
              memcmp(ctxt.snd,
                     sharedSecret2,
                     LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
}

TEST(MlKem768TestNeon, NISTKnownAnswerTest)
{
    // XXX: This should be done in a portable way.
    auto kats = read_kats("tests/mlkem768_nistkats.json");

    for (auto kat : kats)
    {
        auto key_pair = libcrux_ml_kem_mlkem768_neon_generate_key_pair(kat.key_generation_seed.data());

        uint8_t pk_hash[32];
        libcrux_sha3_sha256(
            mk_slice_u8(key_pair.pk.value,
                     LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_PUBLIC_KEY_SIZE),
            pk_hash);
        EXPECT_EQ(0, memcmp(pk_hash, kat.sha3_256_hash_of_public_key.data(), 32));

        uint8_t sk_hash[32];
        libcrux_sha3_sha256(
            mk_slice_u8(key_pair.sk.value, LIBCRUX_ML_KEM_MLKEM768_SECRET_KEY_SIZE), sk_hash);
        EXPECT_EQ(0, memcmp(sk_hash, kat.sha3_256_hash_of_secret_key.data(), 32));

        auto ctxt = libcrux_ml_kem_mlkem768_neon_encapsulate(
            &key_pair.pk, kat.encapsulation_seed.data());
        uint8_t ct_hash[32];
        libcrux_sha3_sha256(
            mk_slice_u8(ctxt.fst.value,
                     LIBCRUX_ML_KEM_MLKEM768_CPA_PKE_CIPHERTEXT_SIZE),
            ct_hash);
        EXPECT_EQ(0, memcmp(ct_hash, kat.sha3_256_hash_of_ciphertext.data(), 32));
        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         kat.shared_secret.data(),
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));

        uint8_t sharedSecret2[LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE];
        libcrux_ml_kem_mlkem768_neon_decapsulate(&key_pair.sk, &ctxt.fst, sharedSecret2);

        EXPECT_EQ(0,
                  memcmp(ctxt.snd,
                         sharedSecret2,
                         LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE));
    }
}
#endif // LIBCRUX_AARCH64


================================================
FILE: test/libcrux-ml-kem/tests/mlkem768_nistkats.json
================================================
[
    {
        "key_generation_seed": "7c9935a0b07694aa0c6d10e4db6b1add2fd81a25ccb148032dcd739936737f2d8626ed79d451140800e03b59b956f8210e556067407d13dc90fa9e8b872bfb8f",
        "sha3_256_hash_of_public_key": "f57262661358cde8d3ebf990e5fd1d5b896c992ccfaadb5256b68bbf5943b132",
        "sha3_256_hash_of_secret_key": "7deef44965b03d76de543ad6ef9e74a2772fa5a9fa0e761120dac767cf0152ef",
        "encapsulation_seed": "147c03f7a5bebba406c8fae1874d7f13c80efe79a3a9a874cc09fe76f6997615",
        "sha3_256_hash_of_ciphertext": "6e777e2cf8054659136a971d9e70252f301226930c19c470ee0688163a63c15b",
        "shared_secret": "e7184a0975ee3470878d2d159ec83129c8aec253d4ee17b4810311d198cd0368"
    },
    {
        "key_generation_seed": "d60b93492a1d8c1c7ba6fc0b733137f3406cee8110a93f170e7a78658af326d9003271531cf27285b8721ed5cb46853043b346a66cba6cf765f1b0eaa40bf672",
        "sha3_256_hash_of_public_key": "7b00751eb9b1253231213f8a14f06f0fe1b7a4fdb7d1cfe44c161e577e5e8f0a",
        "sha3_256_hash_of_secret_key": "3a8c009e8e648ac572d5592e4a92907fae0c1767be41c544b59dc3ffe61f7ded",
        "encapsulation_seed": "cde797df8ce67231f6c5d15811843e01eb2ab84c7490931240822adbddd72046",
        "sha3_256_hash_of_ciphertext": "bce1bf3450f574130b9561ee11565fa41d599d05d2136f10ad2c013eb5d13ca9",
        "shared_secret": "5f0c5d9f39d3e724b5a2bd54e69e360f72ffab5d4d6cc5e572fecba80acd4796"
    },
    {
        "key_generation_seed": "4b622de1350119c45a9f2e2ef3dc5df50a759d138cdfbd64c81cc7cc2f513345e82fcc97ca60ccb27bf6938c975658aeb8b4d37cffbde25d97e561f36c219ade",
        "sha3_256_hash_of_public_key": "9bda55b63cffa9bf953993918b18cd6595ea6433b479e89b5cd3c9339e4468cb",
        "sha3_256_hash_of_secret_key": "d5fc96564df6e53622b2db8295a80a44e3bad7147696e2ad1f728639c98791b1",
        "encapsulation_seed": "f43f68fbd694f0a6d307297110ecd4739876489fdf07eb9b03364e2ed0ff96e9",
        "sha3_256_hash_of_ciphertext": "2a8b5d9bdcac1b7ffb6d655368e15148308eee98ae34f4105eaae87f24a008a2",
        "shared_secret": "7f3bcc03a35a0030255264914e5d88a0c93611c7ca21f0609678a88ca42ce1c9"
    },
    {
        "key_generation_seed": "050d58f9f757edc1e8180e3808b806f5bbb3586db3470b069826d1bb9a4efc2cde950541fd53a8a47aaa8cdfe80d928262a5ef7f8129ec3ef92f78d7cc32ef60",
        "sha3_256_hash_of_public_key": "647a81f0f1b3e3dacb6e73e900f7c078cdfaa7119a5ede48c7685fdb7e0fe2f5",
        "sha3_256_hash_of_secret_key": "1cf686cb8732c73a38b35d73b0b28fb120bc89cda1554d9f12adedc057862081",
        "encapsulation_seed": "ea74fbc3c546500ed684bed6fe3c496d3b86d2d6dfaf223969b942e9a8c95e85",
        "sha3_256_hash_of_ciphertext": "1c51c85ce66d80c1f9bb138e5bce84dd75cee4260c8817e06c6f2bd920601530",
        "shared_secret": "c630736985fdb7830d7446e18b6b81fa4a707a6058964b99190120de85e7559c"
    },
    {
        "key_generation_seed": "66b79b844e0c2adad694e0478661ac46fe6b6001f6a71ff8e2f034b1fd8833d3be2d3c64d38269a1ee8660b9a2beaeb9f5ac022e8f0a357feebfd13b06813854",
        "sha3_256_hash_of_public_key": "811aea11a24a4b09e428415f82ee836e930c3b77867aafc5e6728149e3f2bd1b",
        "sha3_256_hash_of_secret_key": "6a1ff1351c538a5661fc3576c29408c19f42da3688fa16f9ec5ead6a84420db5",
        "encapsulation_seed": "64efa87a12cb96f98b9b81a7e5128a959c74e5332aaab0444fca7b4a5e5e0216",
        "sha3_256_hash_of_ciphertext": "db4dedc1e4d383acaf974fb50ffbf881bd3938ad196fb9aebeeb1bf1ddc94e10",
        "shared_secret": "41e078d0d0c4fe5df5c6683171d5c1c3f1ef152c4945f9cb299f74278ce4cc4f"
    },
    {
        "key_generation_seed": "7ec408f52c9aa723d0c41d9987682a5f4ce6c9da7cd0215af60bbaf5484ab353a08ccf451b049fd51d7a9ad77ae14a81569df8c9bd3a8f1ebea86fdcfb823082",
        "sha3_256_hash_of_public_key": "76c64235d8bd63438f13dcd038f286b9f4242070a5bec4d8990075008667aad3",
        "sha3_256_hash_of_secret_key": "fb19a847c01b5bb4bc607ce0c65e50ca6869946a97625baea129c2ba07e00c01",
        "encapsulation_seed": "8a95d71228acaa5f9ae6f9d9ca8ae55fde296463b41083a39e833e37c4c90f88",
        "sha3_256_hash_of_ciphertext": "c8c63c879a7a803db4e5779ca5acb1f16f5c86c38258f583a9f1e43303ff36d0",
        "shared_secret": "7da491b5623a43ae17160a54e45e8328453cfe1acc692a1e300906ebd2a1d9b2"
    },
    {
        "key_generation_seed": "c121915bfef6abdfc177dae2f5a24218f9abda2559afc6741b08e0e61ab433eb84ef52db5eaa6df8ec3a0bc5ffa730db0dde8c5f38f266d5c680a78d264a7b96",
        "sha3_256_hash_of_public_key": "ae654e4412fd220548280b7a6ace9f2f0bc7b059fc103060346e53bc3c3161d8",
        "sha3_256_hash_of_secret_key": "9088118150f9137e8ed76eb5e3a706f66f31c570fa7f0dfe75c0e81c4540878e",
        "encapsulation_seed": "90d79d75d0bbb8921cf70d46bab497022a8e750efdc99e5f1bae653275441c7b",
        "sha3_256_hash_of_ciphertext": "2ce235a49669184efdbff64176f93017127735170c2e1c1b159fc746ef30d18e",
        "shared_secret": "eeba3c0571fa453fcd9f7f0d6baeb75d59ec9854c12846089d65bd8dadf9f6b0"
    },
    {
        "key_generation_seed": "d86634ecf96cc2603761e284c0e36734cedec64e7ff486469e38539c71141c5a99daf37400cfe59841afc412ec97f2929dc84a6f3c36f378ee84ce3e46cd1209",
        "sha3_256_hash_of_public_key": "6ecea55c3d5c042d2dca3a3925faaa9112561827dceb0754580814a84be19b87",
        "sha3_256_hash_of_secret_key": "33448769334ee9aa43d7ac22a003d9ae89a1ef5a9765deef2946c91fea0a1a5e",
        "encapsulation_seed": "be8a32f97b9a8d596382c02fa2a0eeebc15c083e970ddaa4f2622b91d6718663",
        "sha3_256_hash_of_ciphertext": "14540bfc038f3eb76f418a8851513054a998e16a06f97c117417ae0a35f90e4f",
        "shared_secret": "8bf57e5d1ce24e9942b1b3f456d184d4c0937b9b699e69c6524e93e140f39c90"
    },
    {
        "key_generation_seed": "0610678ff4dc3128e1619f915dc192c220f8fad94da1943b90aaec401683a492da1804ddb5aa9b1c6a47a98f8505a49bae2affde5fe75e69e828e546a6771004",
        "sha3_256_hash_of_public_key": "576cb9d31e5146967756cf7356926f2e20fc7c1fde9954cb2f593d96a80ab860",
        "sha3_256_hash_of_secret_key": "2031c133d7d85e616d932c6204d7ec0f3bd0303ec609e3c7c08092e1ea443972",
        "encapsulation_seed": "da2cfaf69e25b2a89ff2557bbb6f69e01d8e2e7bb27a7a1ce7e40fead16f33b2",
        "sha3_256_hash_of_ciphertext": "20e06ce25d864f8e7a80a19e23cee6830575a072476504fd10e37b296ef8de73",
        "shared_secret": "2f714d31bbc778518e2b67d264065d9731c12149cf931211e649addd6daf0b92"
    },
    {
        "key_generation_seed": "d322d56d8ef067ba1f24c92492b9c56df3a6ef54a304adc1b69913766a1ce69756047447b810cc094d400ab204cf9ae71e3afa68b88586ecb6498c68ac0e51b9",
        "sha3_256_hash_of_public_key": "3e9976d61a687df88a8abcc6651446b81b7d136df42bfa03473c84dfd64fdb3b",
        "sha3_256_hash_of_secret_key": "5da40cacace6fa3712e49ef6700cd819aeea88264e6dc996681fff43d98c9830",
        "encapsulation_seed": "511c2ab40782322c06111e144e505328c4e5bfc890a5980a2bbc44aeda4c738b",
        "sha3_256_hash_of_ciphertext": "48ddf3c7cf3f02af111c71607e93922176d0173ec63e890235fe981412824edd",
        "shared_secret": "f2c29a0a4782d83f2073c7c37d90556b1a005f072f94063d2db8114430f36c8d"
    },
    {
        "key_generation_seed": "2f1d8a3bebb34540324b9485fdf3d5be3b858f544abc3fc641b5728cafab03ba8d6c42e7270ee2b77b6045385f3d175984a0e260363166c73b0c70c971644363",
        "sha3_256_hash_of_public_key": "c0cfd4113c5edd408adcd03d38b12f0b6ac17525c618d6d151a761a9eebc2635",
        "sha3_256_hash_of_secret_key": "2c6ec490ffd55e0a744f3c506a497cf4af575cce6368bdc3b3bdbbae733fe7b4",
        "encapsulation_seed": "dca92dbec9b260dd97e8886f876862d6effc3b91fcf3fbc986cf56ab93ae79a2",
        "sha3_256_hash_of_ciphertext": "b6ba4dfdae02842f96b915ea0ebd1c97972c170cae975c89c5fbf26cbe9a52d0",
        "shared_secret": "13c99ded4db3e6618f5927d58c89afbe83c86a86ac2073421b2560b3f8be5aa3"
    },
    {
        "key_generation_seed": "31beda3462627f601cbc56f3ddf4424e1529c04737ef0ef2af6d7401f653b8a1812083bfa3b670e3eaf9b443702fb6db16ac1197656bbd61a8e25ed523b8d1e5",
        "sha3_256_hash_of_public_key": "71c5534bb819e61a9d8a257ff2eb29598ae92eccfad38abbfc9bccde5ff95a1c",
        "sha3_256_hash_of_secret_key": "107c5ef0842d1dfda257138d681ad7e1390e12c697111a2c804d8f014361cb4f",
        "encapsulation_seed": "57c170e691d7a914a901b9a11c62b8b569b3806427557a9dbac9faa720ec3641",
        "sha3_256_hash_of_ciphertext": "671e3c316d4d8411237db4383fca82f76692867e9f6d15a2b82b17d934392341",
        "shared_secret": "83302cab48eb0832bd8df0db3fce81595754772e4c951c444a1b2ee9f58c48c1"
    },
    {
        "key_generation_seed": "cbdff028766d558af4466ef14043a1a9cf765f7748c63cc09dceb59ab39a4e4d8e9a30597e4b52ffa87a54b83c91d12a5e9c2cd90fcac2c11b3a348240411a4c",
        "sha3_256_hash_of_public_key": "4b53b4aec0d9f86a6377c63ff80150e40fc5347714c07591dc71c6beb8daaafc",
        "sha3_256_hash_of_secret_key": "ed13d2a9ae5541b3fbfa19891b8c8a9f4f0957d940eb5d08ee0cd18cfb28e7a4",
        "encapsulation_seed": "6b5a14e1473abf5a33d44975ca2088bd8fa6fddcb3f80e8fd5c45b9d90c24a5c",
        "sha3_256_hash_of_ciphertext": "b83f6022179a08cdadda2660f8cd7cb70df4be0be3ad85bebb090d086079b1d1",
        "shared_secret": "93ce6d06568d795c2a28d1196f53cbaa2cb05df1427ac76f44df09d479e14241"
    },
    {
        "key_generation_seed": "4c04310bea66305c6ca8ba6b8f61ca96257a67663afc11761f13fb5c7b324b6b8aec87a9a79204cee2986867a2906eb851b734b8b22b91d6749b1a5f07c44e3b",
        "sha3_256_hash_of_public_key": "c2d52d0c837eb40dac0653a5e862d9fb8b832629cece9eaeb6d5feb48b6ef5da",
        "sha3_256_hash_of_secret_key": "73ee0632229d740dd746e3ef7f0f1c29944dbc2d8f39b7860807c41c18bbb3af",
        "encapsulation_seed": "40e593754e6eddb7f9cf176ba2d5fd1087c90ad377556d0b0f686537b1a3165e",
        "sha3_256_hash_of_ciphertext": "3685126e86797a881f3bbee0eb85b76d755ff03858735c326731b8d802f023b5",
        "shared_secret": "071db527a2ee8ce982527cb19355793859bb8557e7cc99dec58a53153eceddf4"
    },
    {
        "key_generation_seed": "38a0d5f41d7dc1896efd1b45b0485634cef149828751b96087a0a6dd81b4d58aa2acf359556df4a2abaeb9dcee945829beb71185b4d6bd18b76e5668f253383a",
        "sha3_256_hash_of_public_key": "4ff02338c9bb711d263140c471409f3c42813f38424698563d9550f85a168f2d",
        "sha3_256_hash_of_secret_key": "3c89443dab5ce46f82f6b8260af0293ea52a680f1c4fe5e042f0aefb707526f3",
        "encapsulation_seed": "c152523abd8248bed40c3827bcf0f8e8127037a55c780695e2c28ea3e041a44c",
        "sha3_256_hash_of_ciphertext": "b20e28f42ee5cf5569f1833af90334952074dd0ea0c2520f03fdf0fb24c17a64",
        "shared_secret": "598bd66a4a063652b2a6b25b8d1c3bab0251682ce6c362a8c680295f47f3d6d9"
    },
    {
        "key_generation_seed": "97b5665676e59e3538ebadaa8cd50df1f9fda1502d9894c616a946078e56b621df05318b5f655efe36f1b678cf4b875108a18db2fa312261caf839f84bd956c5",
        "sha3_256_hash_of_public_key": "bbccdbce67cf49fea044df5c767996681dd2714937d31c822f3c58cc34785aa7",
        "sha3_256_hash_of_secret_key": "64fde53d297945ef2a0af6ddd044520cff8ec1388aa471e47ba4299c2cd46da4",
        "encapsulation_seed": "ad6466dd59f26b762fb02b19eedf5f79964da68bce0459b91c3a6ee5a7e01183",
        "sha3_256_hash_of_ciphertext": "6f4cde00d3775858761742957833fe632e3d3082a9a6180477291bc23b682674",
        "shared_secret": "92bd980f79cbb34c67594c6922549b99962e54d388034ea61f892fe250581c4e"
    },
    {
        "key_generation_seed": "ef99224a03a85a46ef115474ec5b5d620da6795d6efcca4c9135d19958a9de62df7d92dda83e6b2ef4cce08c9134563063068a196d7b1a1a13623e48ae12528e",
        "sha3_256_hash_of_public_key": "3ef3581d438af7dec621304e0091f797346ca18a41f39401e9d03200ef48beb6",
        "sha3_256_hash_of_secret_key": "299a76e97511d90f7925100db418472a9c3c12d6d48acf03618a6960998ee733",
        "encapsulation_seed": "1a4d5dff5847cfb48333e33bb00ca7301b144aa89dcd412ff5a3b1081d775b7f",
        "sha3_256_hash_of_ciphertext": "4ede793372276800e22c1893ae554ce0b53e413fbbc3595e69feadb2e1f6d57a",
        "shared_secret": "b7325a08fa617e19260264bb02ed6b8ab2081589fd5dcc1e92b9d0d4ebfdb6b6"
    },
    {
        "key_generation_seed": "b12f6fd965ea9c5b947db80fc60c83d5e232dca82e7263027c19bd62e5a6ff550f6aa3e88f7fa8a96067f8cdaeceeac90c2d0b5e277e56e9c405ec9420c30252",
        "sha3_256_hash_of_public_key": "fa06bb0ff42f4d610a7b3df7544d66b97a486967cd9b62ba0142ebb10b8ee4ee",
        "sha3_256_hash_of_secret_key": "4dcfc0ce12c4e87f02c616a8fb18c359cae017a2f8d339623a174dfaebfad98f",
        "encapsulation_seed": "34f44ec2092eeaf686f2ea170591a98527cbb03a4fa9477a7aef6b41a54feeb2",
        "sha3_256_hash_of_ciphertext": "591bf77f74463c50a4ffbe97c892e11f3cf7601813b7ad83b17038a173e21442",
        "shared_secret": "b400082a764291666c080ae9ea9f22c383f3c1e87b4cc56775a19c8ec29a4157"
    },
    {
        "key_generation_seed": "9f52af92ca165fdc38788f2b59ba02e01c8281ff7c1e60504688043a5fe814b04f3029e1be4e1c0258c3a22ff5b50b2674cc094ba7018da2a61569845c17d26f",
        "sha3_256_hash_of_public_key": "86538ecdf65b7a485b73a34a72193af1ea3f884d820463601c7f843672bbec7d",
        "sha3_256_hash_of_secret_key": "70e91b44585ed93e802868e0bfe88f68995f3c85d25c2a36b0b7d8de7c5e2f8d",
        "encapsulation_seed": "6250c81126572eec2da330271db36ee591f060fc7e53eeefe2e1c476c675fa33",
        "sha3_256_hash_of_ciphertext": "83754e315ef22788354c1ec632429566929f9bd53e77d1d2cb52005274f64e1e",
        "shared_secret": "03c7470224ba22fde280005d9a8f8354c49459e9a168cc282f9d41f4f0d2da2b"
    },
    {
        "key_generation_seed": "851ea90fd3854cbf28fe39fb81f68e4b14345cf0d6eee7ec4ce772513df8410d1c0ec046899a777655233e4e1b5ca44e9afbdc67964bfd5d5e3dbb45e60d03cf",
        "sha3_256_hash_of_public_key": "27757389a4a68c898dab92d0f63c3340dfba51e00312a05e721932b95b11f6da",
        "sha3_256_hash_of_secret_key": "b43f88e419ae589b85bb0ec6c9712d4870dbaf35d4c96d06ef0f8b9753b60034",
        "encapsulation_seed": "35d470bcc5880872754810dfb3f2796da2fd7f397537146f6488c27804072b34",
        "sha3_256_hash_of_ciphertext": "0eb3d2bc103f7801dd8e002c6cc81bbcf11e070f465aba9b0b725fa9454acda7",
        "shared_secret": "c31f7372e8c194a9589042477f34da3a60d591ea65e13bcccc07ba59402ede6d"
    },
    {
        "key_generation_seed": "d304c9389cc973477f169788abcb9d511f843219d246a9b587822f422a70c2386590a2e5c7ed86cf2c5c2a898662bc9a81418720bbb632ef9cf0b845ed052d73",
        "sha3_256_hash_of_public_key": "efe6e93d8e755292fa875609f2f63bd194c87e6f04db7c83d8bb1b9d868bb779",
        "sha3_256_hash_of_secret_key": "f54233dfd4679cbd6eb6f18c0615745d5b4fc2fefade52d966bffab6f0cc259f",
        "encapsulation_seed": "8d667921c5db401a86fe1c35dfcf164a6bb2ab7400fd6a0b67eafd4a0ed11940",
        "sha3_256_hash_of_ciphertext": "942f3cd64ed1b2675f9f9823c068d59b2e007e66d38e06a2e4558dcba7f11efd",
        "shared_secret": "9dfd08dbf59350ae2308096f935c6767daeddeb2c6997992d4a02c14b0e58c60"
    },
    {
        "key_generation_seed": "89a6e3be304a3518fb82b18ca730f0b359cd6ba90664a493fb4f8edaf965b9c3b6591121e25d64010c25a18676033e1d7278ac5f2d0b43a31f3a4156ae710465",
        "sha3_256_hash_of_public_key": "87ada29bf78a689417b645fe127d124339422be80a993e623d13bc59f3406a6f",
        "sha3_256_hash_of_secret_key": "6b8d44a2a71f2901b7ea97bd24df8d46041cd9ad4f0bc5d42ca27ee44981f740",
        "encapsulation_seed": "ec750b3939385a3f8df868119dc76f77ca845567ef068de6ada5478a56bc78b6",
        "sha3_256_hash_of_ciphertext": "aa86248e7e906ff3072a00647cbd3f6e5d0f3a4ec40efa6deb94b2df901d0097",
        "shared_secret": "03952e1a4915d112b87569d1f79a39f5d69a8dc11c96d70c529d2162a6024dd7"
    },
    {
        "key_generation_seed": "d569b935ce015c85f792f8f7fb0d83c4f53b492959361dd4f75fb764d656450176eae84d11c4528382828f7a689a0d5cff87b8ca0bba97feacb39b935a8788cb",
        "sha3_256_hash_of_public_key": "0c87bedd5c16c32cc3867910f734bdcf09869c7604a59ce36660074f561e12da",
        "sha3_256_hash_of_secret_key": "a72b7d93adcbfc6d89485fa923a4b1095e3d593916496e521187224efa42ffa5",
        "encapsulation_seed": "74f1d52af09b12c36eb062ea7528550cb4c18a3ce8e4f4ea9fac43ae383bc925",
        "sha3_256_hash_of_ciphertext": "7a75e486cc2dd3ffab4b1072b4056de9a56b55cf324e58d3f6cfd031a0dda594",
        "shared_secret": "6d2e1f456c87d5a3c79456a6d35fda52f3e9cb858f85a5f7931f532fffe26dee"
    },
    {
        "key_generation_seed": "5cbb141c2763425c274f7404fe530d9116e08c33f9f200a20b011cf563a28990fc9ebbe336dc464489861db8253606971bd0a9008a433ed17752d04023781552",
        "sha3_256_hash_of_public_key": "9a9a59f83fc58d7194ccc92bd78a45f97f721a1eb554499d0e4d5b37aefc23a8",
        "sha3_256_hash_of_secret_key": "ea5ce3a271f5e46f925259832d187a3c893e8088b76c19c93e0e798e4320d2fd",
        "encapsulation_seed": "4b3a70d85f640d1a2a852fb6fe96704af56a7415a8ee4282e9207bc3a2dc116a",
        "sha3_256_hash_of_ciphertext": "d71fc29140e8725a4c4e8779d0ad3007990e08b1eb38856cc56f522e3079f601",
        "shared_secret": "5c7c5cafe1fd7f3d12431ae93815c03419ff95b132caf568671ec23bdc74381c"
    },
    {
        "key_generation_seed": "293abb6d1c207927945417cf84883ef010823e11b487ed55239e466e83696d0cff8563038aad865a817cab9ce98846ba75be9363718ecf5fea538aea90b2a558",
        "sha3_256_hash_of_public_key": "bda0815dd53b263afcc1f71d2501128c41fb3606af71c5e68f0752c6d3a479c5",
        "sha3_256_hash_of_secret_key": "d502e7e6df2d84e46cef88a84c53f1fddd5488accd5e1e43aed5f4f08e16a8a7",
        "encapsulation_seed": "26e38ac804fb5b4d59ddf747715e7e6041d875f99c7b638024b4af82d622da60",
        "sha3_256_hash_of_ciphertext": "8d4b1f3ee23ceecf073d6576609767401286da5189a1b267bff30a710a69e67a",
        "shared_secret": "1427c322f72898a0fffd13f674719c9288d524bdd19e6a362533c1108e3a6d2c"
    },
    {
        "key_generation_seed": "74d87c7556f2671f2d666854a4d6e073e69f35421e6e1a428cccea49c37f972ce1fb7456ac0aa1b97068f452cba64ebdc138bcf5d36b0a0fada2a3b374141eb9",
        "sha3_256_hash_of_public_key": "e3e96e658787ba3f6ffb47de56322541a2c81f68e2825c74cb75ab01d4b719d6",
        "sha3_256_hash_of_secret_key": "17f821aae147fa517cf35169f9d0b59a30ffdd0ff8f46c1c9bfffe6791392f18",
        "encapsulation_seed": "a319d2b8f114f1acd866478bcdeba6fd164dc4e37b0adfa8d8034afb3e197376",
        "sha3_256_hash_of_ciphertext": "7638e455aa855489cedd385a58cad62c49ee25f60be02bbcca6d7c3c383d27af",
        "shared_secret": "d399b5ff0756707f8d1a1c2a683465c9ad4899788420643d59edf78f79b28dc1"
    },
    {
        "key_generation_seed": "013bab0212d04ecd54b478daf72748003a25e2cb060ba6cc50bf95c292b8206b9da0c5da5f195b80fbb99c2e8b06926074f3f604b3f6195b5a5b9737876bba72",
        "sha3_256_hash_of_public_key": "eb3fdfcc0b171aa975028f96cd47fdba421ac08e29a0044cedc29fce35eb8510",
        "sha3_256_hash_of_secret_key": "d1266b01cdbc6774ff0edbe64a593a110c462d07071077faa86faa9a0aa2365d",
        "encapsulation_seed": "ff646071b2509e6b75790917e08e4f0b0d9f0116ec6291c0b59eaa4b583ad830",
        "sha3_256_hash_of_ciphertext": "0ed3b8be821742190f88bce0d86f834dec2a829496c5eb5bf51bab1a8419064c",
        "shared_secret": "1a0ad65924728c415ee9c92d0dcd91396665a24c59cba878050390acf2eb44dd"
    },
    {
        "key_generation_seed": "ccb073c4b90be0ad746e26fb093b60c70110bd1dcbcddb566a8cffb7b3caf80e71600a8982c350df524cde514431ded7aec23576530894bcbf0ec0bfef0bb64f",
        "sha3_256_hash_of_public_key": "d046d93317dc6d0ff28990721c3f94a93024ce01b01c0ca55d634c191c4280fa",
        "sha3_256_hash_of_secret_key": "bdf5539c63b463c3dfefb7978bc44a46803117ccf066475bd17d5c82fcb49c0b",
        "encapsulation_seed": "0584270ec26f3b9818e4af074d17b2d51037cc8dfdcbe3b140fa4fed5deebc54",
        "sha3_256_hash_of_ciphertext": "b0cd3d31583e15ee8a55d85cd770cc6d64ab83429aebefdb55674f382b605c80",
        "shared_secret": "9104061d3dbfac187f3a9eed801545a52f1fb0c3979ca8315aa31f67775d1036"
    },
    {
        "key_generation_seed": "2e889f44e28901e9ac7ca6b2fffcb124c8979401b17064d7e1d51a7e3c3adbfa0e145e44aae52cfc609e6f47fd7a6f6af877190ff52256d0ac5b05b89c3f449f",
        "sha3_256_hash_of_public_key": "21b12640bf755e94ba06204982458a9be11e1da542ece4f3d284886800fc8e8e",
        "sha3_256_hash_of_secret_key": "4e3947282ebe9f8cd652343c30dfec9a5123c237af2fbb25aca522b6bb6bc4a9",
        "encapsulation_seed": "51e05c7b4ca3079781e8293f4eccebeeb2f8c8b4c59468eddb62a21bcb4ab8a3",
        "sha3_256_hash_of_ciphertext": "43c21d2fc350a9682e8105ed680b36a04d02579ebab292d0a05db185021dcb44",
        "shared_secret": "ca249f10d39267ec3725f56b90eb2e22cf8b577116af350f3d3c1e2cf090ff73"
    },
    {
        "key_generation_seed": "174aaa36410566dc15a5e62874218d7abdde0b2c0f30d877bb80b1abd5f5a0a450a7a2354f7e5cefa6f4a4e9a1c411eb9364506e9e1204a8acb3cb77fbd2c4ed",
        "sha3_256_hash_of_public_key": "95d9e5b9151d87fed52e287992acb897a07b10ada1dd83409a5ccddabf9d7cfa",
        "sha3_256_hash_of_secret_key": "79e973da94d9166321c476a28a98a8d03ce079c9a99d6e4f55d2e2b4de936123",
        "encapsulation_seed": "9eca0fe36c80fc5eba171c3ae66a5b1c923faa50b4521bb055e7bf51005c93df",
        "sha3_256_hash_of_ciphertext": "18ccc37804b42db21ae4d7e238fedf4594f3d55303dc80c0e51c748ff4906ac0",
        "shared_secret": "82a3856ca48c5dc582ac25605ab0c675ad646ee19acbaaab4ccb5350a3881b49"
    },
    {
        "key_generation_seed": "351fe4313e2da7fac83d509f3103caf7b4c64a4d458fefdf636785ac361a1390f072d9b5a99f9c7a0a011e4dc10f6b600d611f40bba75071e7bee61d23fd5eda",
        "sha3_256_hash_of_public_key": "3a7acfc3d283541d985e0abd85eba5315a17d6c4a7e4f248673da60c341c29fe",
        "sha3_256_hash_of_secret_key": "2fda122953c3d9db88caa36cb8d5621663fec1dd0e19a274a5d85bea7a126076",
        "encapsulation_seed": "0c5719261caab51ae66b8c32e21c34e6d86ee4aa127d1b0195663c066497b2e9",
        "sha3_256_hash_of_ciphertext": "024ade86d89c33d9d38face3b92986e72c699467402fe9c5aaca0904c5f5737a",
        "shared_secret": "f1e13731a14d39f474806b8c177e23e4e2301a3b839539fef9591a71e4f67d29"
    },
    {
        "key_generation_seed": "9bc5315580207c6c16dcf3a30c48daf278de12e8c27df6733e62f799068ad23d5a4d0a8a41c4f666854e9b13673071ceb2fd61def9a850c211e7c50071b1ddad",
        "sha3_256_hash_of_public_key": "21916dfe025b78fc6d4dd1d1541b51cd3eecca90ae52177431b33c708faf17b5",
        "sha3_256_hash_of_secret_key": "c98bada554f301506c532ec774ee112106358d0b320407fb34051a604777f030",
        "encapsulation_seed": "0e59f6f9047c784c1f00b24454aa4f1bd32c92ae7e626549972f86fab90e7e89",
        "sha3_256_hash_of_ciphertext": "b2737a0bd104c46a5f861914855f498287a33076c32a4241a46cf9690181ee98",
        "shared_secret": "79c5817a4ba25295cfdc817cd303f3465852b93c0c908fc4a79e88c45f3b81f6"
    },
    {
        "key_generation_seed": "d8b907b34d152ff8603b73051f772daa71eb902c47b7e2f070508269d757e02e36b817736cbc5f7b1dd6eef5fe6332fb1a598f3871e5470d440fd2ea631da28a",
        "sha3_256_hash_of_public_key": "8f62011fbd5a1c10713d42a00a79ae7672e5e321872971f24ff71ed754178d63",
        "sha3_256_hash_of_secret_key": "57d13f22524022911276023bff4af90abdf04885e2a598b04fa789123295835a",
        "encapsulation_seed": "a3963ade17d69debbc358dda82c7bebe2c39d25b36813058e7a161542e3f8c2b",
        "sha3_256_hash_of_ciphertext": "70dfcd3fb0d525cde1e38e158f6a4234006821031941efe3f9b4fa1e70c8bb36",
        "shared_secret": "d92f866a744d0af51c8c2ba7b1fdf816e0334bff45182cabdfc722d75f8140c4"
    },
    {
        "key_generation_seed": "684a29e4e5480a5f2533e1526b5fac8cdf5927f3d85087c71f928c59690eb56575d12195ec32a8686d0600e45d4a7f54219b0d7a3826d193a51b9156ecf2edd6",
        "sha3_256_hash_of_public_key": "ed3d1dd05854a6542b24090a680b9aa9d6c65ef31cf1f4f5708affafeb2e3989",
        "sha3_256_hash_of_secret_key": "d5bbcdd1c2fd57524e7926d071f71114a62b95f0579b62ac0f92ccaaac4e9dad",
        "encapsulation_seed": "97beafabf2c8575586487c7a80e8af5fc50f94b6051c1bc66a5ae9f66be3cea7",
        "sha3_256_hash_of_ciphertext": "c54e484b3b05c6bb40bef10662de29ecda288b9374dcef8f89220d1bff2d09cd",
        "shared_secret": "53b3b4ce1e75cfe52d22450bfa763d07985dbc585166b4781a7e6542f9bc03e3"
    },
    {
        "key_generation_seed": "d76b3573f596eb286ab5231feec7499686b13021be36cb126c7ebeb9d7030daf248c0a21ea0bb6d6f56f12300e8584d8e9a34e0e6f52227281151ae4c305fb8f",
        "sha3_256_hash_of_public_key": "6fe12a1e2d742dcaf56c585651ed6edce4f410aca0fc83275b5acb19daeb149d",
        "sha3_256_hash_of_secret_key": "b9e5eb23d136e49d2b5b7964430a1f98c78cd3526f97b1fa0ffb8fb0ea9ffd79",
        "encapsulation_seed": "75461decd34c50d6a094b4a64fb75e5e9479f8f9250d82bb7d729dedeb2d4b65",
        "sha3_256_hash_of_ciphertext": "763f4d04f8eb62a3599d9d095c77861f122e90a0113fa290b17d500766fe333e",
        "shared_secret": "e7165b66834d919f8c8737c7b4df17a0668c57a87b821af78fe68cbea325aab6"
    },
    {
        "key_generation_seed": "b87439fde81c9e39eebe7cf741c685785532c1dd23e8ef868b9ce7a541010f3d1646460817a0fce5836bdfe124a7448e7adf7b8ecc2652ac6d280e986682df71",
        "sha3_256_hash_of_public_key": "30c784bb2ca3538979b24246c2644907484719c531ea39f13c5a34046f8e5cc3",
        "sha3_256_hash_of_secret_key": "ff96c20a150142ec36186277a6f7b15e4fb93e9648385ef23186fbef674f1600",
        "encapsulation_seed": "2607dcf4fd6ca1c614c21b5e37c24981c32b91c8c3e6955777da8a3f5d9c9335",
        "sha3_256_hash_of_ciphertext": "edee28e97f72a1798809668a1b9b9b3dc05d794d69af6cb476f524e6acad3d8d",
        "shared_secret": "19599e218264837d06839b6cb9a09af3bc4cdc78f7d9c00fe030ee92ba3bd54c"
    },
    {
        "key_generation_seed": "056661b38038da4fdd7426f32a81576c73ed84843b305168a374f934e27a4e1b79238a80dcfd7c992d84b2dffa67493e669243d4fa38c46b090bdf86bc548411",
        "sha3_256_hash_of_public_key": "b30fe432c2e9744430805aef6b75cf3011ff387e323558212b9d71ed71f044f7",
        "sha3_256_hash_of_secret_key": "2c4c6d6ed6fd6cf8b53a352a038b9fea6648a9521604140f54268381dfaa1144",
        "encapsulation_seed": "38c89bbe7145c29e9a831c11431eb9929cb24fb4992db20737e4687d397fd732",
        "sha3_256_hash_of_ciphertext": "b536c56ac5b187bf7372e726bef28c7a46b51e2bb3bbbcb3cab014c6f5999061",
        "shared_secret": "dc5f3931026bcedd2f57b65601f683895c365862d28a65356e94049773de2ae0"
    },
    {
        "key_generation_seed": "a1b52d871612a1c611ae0944f9e71858f35d3bd14f20e96a931720668bdf0a6b1f135cf64b6403e103afae34da038613e2853bbfc36baafa3c6a95347193f37c",
        "sha3_256_hash_of_public_key": "ab02b962b6350a9e1314baaa272b6b13db3d1edc9f09d3addf07f6826a3556bf",
        "sha3_256_hash_of_secret_key": "abf4653476aae658e4603990ddddad56c09da5fab6b9a3e328b9fcd670547652",
        "encapsulation_seed": "b2c35e33c72d90182791f0e12a0324f5b216efcab2c8da1bee025dfbe13f4152",
        "sha3_256_hash_of_ciphertext": "fc2394d4ed9b1e2b073d73d02eb4ef8ab3633932e58641a58507d7c977b62c04",
        "shared_secret": "7dbfce1fc7d937884e7b3fa7c8eaadb37e1663f77d7c8659b8f43abadf16cba8"
    },
    {
        "key_generation_seed": "952b49c803d6d6fba69f4375adce8594847a00bcae2179da49af2aed0423250262d7033947ae42ca53522a65fbafe18d3bc3e0cb66164e9a094fe4b44d8977ed",
        "sha3_256_hash_of_public_key": "c153354b0187e658306a0c860b1fe6ed14686ca77d37b7c82d66ff62149406b7",
        "sha3_256_hash_of_secret_key": "bc48868d03fb12ad5a98d35a739388b66e17b589aeb6ad4335d2d2e0c933910f",
        "encapsulation_seed": "afb7d6dc2b7eb6d84acc080c1be63c98afe7b07786b5801f716444a3e8e64800",
        "sha3_256_hash_of_ciphertext": "0fdc0a9a35e5cdcdea8d39e95086e35db8f4ec92f13a7d9afad49adb5faf1e70",
        "shared_secret": "09f64cee1af4d8738ab149d34a106ea7b19ac43e5a2536defe689824409050ba"
    },
    {
        "key_generation_seed": "3c815e57e9233e975fa1630208aab206b71ae0db37a7a8789ac683d9f9b2d29801c8e376fdb140ee343106c093af7cb149b316ba79446ceb4e5e0cedb9b164f9",
        "sha3_256_hash_of_public_key": "2ab47ca9355ece6cc643c3274c46efbd6e927b8b4d11ae8f80b5345b487a5c71",
        "sha3_256_hash_of_secret_key": "9f65505a34f12eee3e5f6ba1cc622dc0024c4be87dc0648ff9e1edf9ffca943a",
        "encapsulation_seed": "28f5e9dbda122b2cf8f3754fe9e0c73a84ad4b0c093522e0b62cf815d60bbc3c",
        "sha3_256_hash_of_ciphertext": "5c7bfaf193010937498fafd5f4eb4665996c6a963ba25368439dbe05c56bd99c",
        "shared_secret": "7104fe381d6d7995b4d550278a66a719b9e79d9bdc38fb0bb60212c4355cc520"
    },
    {
        "key_generation_seed": "588760826dcfbd36d9abe6ae44a669bb3ebba6a218eab69e30f18a3bd536576e0e860576285483bb5fd36e2f944d32c4317bebc1e441470c1372046a790d79d4",
        "sha3_256_hash_of_public_key": "3ab27768ce397a94bb7d29f5dad97d54054915eb66be41023e5d7052a10ed1e6",
        "sha3_256_hash_of_secret_key": "2b091ca0237c155627226a58c1ea9a049127e7e30e397307ae20343e21408dbe",
        "encapsulation_seed": "b0d713cbef0bb1df70cbb425d1e9373e9f7790fdc7980cc96a240dfc53f1e8e2",
        "sha3_256_hash_of_ciphertext": "1987dbb44cd3fcd1b3fded283f54d82a2dd146508124282d59a8f862be82a2a0",
        "shared_secret": "79b1ce19715dd0a74ada36d31f63f3242716890a66d6348232c914c8e5c4c499"
    },
    {
        "key_generation_seed": "47550e9edacb6ddce3d9ab81f6b61080dd4f2693854acb05e0ccc7a4fb6390fbf89d7d99d5c3e0d10d6ef9af054d842375f695abb28e3b8eb495100f04306e92",
        "sha3_256_hash_of_public_key": "4c20aa5a85b2e43c56e051698c75bfc27bb9b1722501a6502d1c0dac0aa7f1b0",
        "sha3_256_hash_of_secret_key": "684968be82e153d8eafea3ad507544b512bc1b0768775fa5732a12ec2b3b22c6",
        "encapsulation_seed": "32bdcdb7059fe27f6409901980c080308951ffd90deffa8317b4d213a5f04495",
        "sha3_256_hash_of_ciphertext": "5a1273ac88362d6933e9f8e203af5df0ce809b23e125abfbea3f72bc386f17b6",
        "shared_secret": "66e872a4b3baa42bc3e8e4ee787ebe070a094f05d2a0792ae2ae60f8bd0ee0e7"
    },
    {
        "key_generation_seed": "610afb64be8cc1df288cfb016ee2f44c6c07113de7f6fee071fe0c3fe31c6215cd292e4c5f9e1a55e0489bceffb204d672a6215f4f3980a646d9f880817c52dd",
        "sha3_256_hash_of_public_key": "72c30933b8e50425fefbf58d711f58cbf9fd8ebd2835a1b55469a2a1b993eace",
        "sha3_256_hash_of_secret_key": "f156a8742efc92c7a7c5e07116d139872ec520aad1fdb146cbcff70c350a45a6",
        "encapsulation_seed": "4ed7c92d83bd03b2a25b567f17ae55542e2f6a4308ec0f3fe69f8ba5ae24331b",
        "sha3_256_hash_of_ciphertext": "c3c80130ce1ccb69036c753567b55e2e93df33496228735300b7640f2993c09b",
        "shared_secret": "56551e57abc7b80a842db9ee65aaf6e65b7c4ca10fc297e9bb0a6364e6255bdb"
    },
    {
        "key_generation_seed": "e1953800acaa85ac02a906c72cb8e8d704e8d27820345f88f71e89c1f549afcc8c64c049c6dfc0f1476cffd520b055756162f7ec94243de6b14ac0b9e5fb366c",
        "sha3_256_hash_of_public_key": "bce58a5d05a4840f835b8ce39703f77bb31f20b9ee4fd3795c2e326244208b28",
        "sha3_256_hash_of_secret_key": "abc33aecf69474343f3848633db85e595a465bcbd408472257e00be338664ecc",
        "encapsulation_seed": "060ea5d2ed1dd88144a9885e79278590821c22917b55a48920f96b53ebe0e689",
        "sha3_256_hash_of_ciphertext": "a500aa79a567933c2cb80ea580fff3298a345398243052f2ac292591810328b4",
        "shared_secret": "30abe054c82a82299e7edd52870f461ff6048daab627b6c848a9d4f1c4641a0f"
    },
    {
        "key_generation_seed": "c719f9b2d16399b7326ce4eca30dabefe8fdaab18e9f6df888b0a134ef355570e40771856eb77e4633504899fcb86c6a3d433d0b8d60e26f07bd61f1d4ed69bd",
        "sha3_256_hash_of_public_key": "0293675aaefa1219f8794d114bbb004463f9c631729734cb430f26f38886537e",
        "sha3_256_hash_of_secret_key": "b25401df9f852f7383fc87fa7cbd267b9de2e80bb37946e9fa8d040134a9e31d",
        "encapsulation_seed": "10ef9426f8c4a13b52325c5bb4ead4596ecf2c6b5bd2d37d8350e90d4164fdd9",
        "sha3_256_hash_of_ciphertext": "3e0e87ded530c595b63064109c6d64c78253f3bbac5f3bcba552539fa7daa004",
        "shared_secret": "4b525f467ee0d96c1f4b899a114936343ec21c74738b05555b2bab9a5d0b5513"
    },
    {
        "key_generation_seed": "e9acbb774be970206c3a738e243b420805a509fa59fa902044be2f0d013650d2ded5edaec5de3bf5b4d7c2f2e18e87f499c1968993eff196753db8045e2c8ba8",
        "sha3_256_hash_of_public_key": "cadbc64e263f1afdcddf2ad63f2fcd19799a0a8f43ec867477e249ed5fe716f8",
        "sha3_256_hash_of_secret_key": "ae483cd66ace708eb15d06b55b1414e1ca1cd440d8867932261fe16a41eab8dd",
        "encapsulation_seed": "a4bd30a64cbf29a4e290fa1cc1dfb99e68348713041e4409a1af23c5d80c15c4",
        "sha3_256_hash_of_ciphertext": "b4c90f9d9595c242112c963a6f24b6023083a0751e341522eb4460a0eed65f25",
        "shared_secret": "6cba1b31809b333ea40f2f67bad438226d91bd61b08860357a840cbcc8fabfc5"
    },
    {
        "key_generation_seed": "c1b3cbffad4b306f9af0cdd3028876486dbe858875c9b6497fe20172a986c82b1c96249919cedc2369d8d739ab125e0d2ccb82dfebcd90240a545cdfe07511f2",
        "sha3_256_hash_of_public_key": "5ca1708c7c6e354b69720b4b4a0c358fe9a6ad3febe78bb2a71691658acae21a",
        "sha3_256_hash_of_secret_key": "eb002a4709c8b95bf166e0942d47453c32b93e32e4273aef846c296d1590d58a",
        "encapsulation_seed": "f4b66a7d3b65b896dfe100b2cad24b175a1168cfd2ae11fd704b835f6bcd311a",
        "sha3_256_hash_of_ciphertext": "3d21fa1e7c4b9e5b3f68f956afe6fac216d42fd9a3707b7a61932c8ebb5103b3",
        "shared_secret": "8087b456d37e6aff785a0ca104cb03ef71fa2d6652c52dcd86220cacf878afeb"
    },
    {
        "key_generation_seed": "ff7495b8575b5a98e4fd21fb4c3e58cbb60f14bef21aa74cf8802e3153f14807bdc370460375a778d1a31d01c42b66367ed8d9e8f84551002f552f0e52102b5d",
        "sha3_256_hash_of_public_key": "04f0066489947b572f76e1dfc2e24297b210ed0aaf228788a0b349d11689e064",
        "sha3_256_hash_of_secret_key": "656696013b36db5535aa376104d5e2beb2c9a708282aa6a5f0ed42cbeefcf98c",
        "encapsulation_seed": "1d7b03d3c5eefb8ae5799dc569aa668f1bcb8c86607b089d3530cf61d6380147",
        "sha3_256_hash_of_ciphertext": "a29dc0e0107aed03c698c2448cba21940bf9923c2098225ea3421bdb474a8ecd",
        "shared_secret": "6799d393f4000857868049c19a102e5c04c55a6bfe3a41abeb4fb6d5228cda97"
    },
    {
        "key_generation_seed": "bdc3fba1c32751139fc45bacffb3ea97f26573d804a5f27a459293d95190ed8efd5a08f656a6eb8cd20679930a31caa6a6331c4b133a6838c223ef9f769f6246",
        "sha3_256_hash_of_public_key": "67ce6c8abcf3ec4d93505d3be02c039e5a12538e5e59adb5a5d709b9b342938d",
        "sha3_256_hash_of_secret_key": "b68d06399932cb2d32b2a2aaf12e68568f160092efac36ade3536cfe6fc88d45",
        "encapsulation_seed": "554f3385b382f4a46314de37ee3885addfc5332bd4038785094e0a832e9e8c2c",
        "sha3_256_hash_of_ciphertext": "93a08f27c7cd6ba3d5e6c8b6c833d8c65f05edb2cfd7eaf5bd392cd1563552ca",
        "shared_secret": "dbbe6f3b6f5a35789697792e209428ba1f53d1b98ac2c0d1893cfee641e40375"
    },
    {
        "key_generation_seed": "447f6076a627bbc5ad7773fbfeb14b4ba9ac43a0f8b99fb6dcd5e452aa3c47ec20a7237801f470fcc2bd9fd7bea8322859b850f7882d362947432913dd068c01",
        "sha3_256_hash_of_public_key": "7fe853da745a27a1462668bb66c4348b7f4bf25c70527b360b2fd104cda48fe5",
        "sha3_256_hash_of_secret_key": "85a7c0a52f7898df5e3ba9ee378057b9e354dc2108c5f8c60a10fc20c9eda749",
        "encapsulation_seed": "38bf0033b779edf5367d9ebc01c988af90904c560970815837380650e4749eea",
        "sha3_256_hash_of_ciphertext": "23e8b844258ff739aceecb17073a7f2be2f89030ba7ca699470e4add6f55321b",
        "shared_secret": "494550faf270431de90c96d2ddcb7c19249d5e85305b3b43626386c30b7aba5f"
    },
    {
        "key_generation_seed": "2d5df64d62cb07fe630310bb801c658dbf3d97993e68626745de39d37fbfc2b27b534537addaba4ecf14f02ab317d36cb9f0f50222ced7cf029dff8a0d3d2fd9",
        "sha3_256_hash_of_public_key": "65297f711f12a5ff123e6de59d1f16878e93a31612015fb961bc572f3e999cea",
        "sha3_256_hash_of_secret_key": "f80261900b053c4d1c5e3b445588f1aca6a9959b969b6a60df08f1a12da1b661",
        "encapsulation_seed": "048ea516d0ebbd9f709b47eaac66f344c571cf50f0d01c9466aa061a50b66a24",
        "sha3_256_hash_of_ciphertext": "7c4f753d71b67d7a6691db0e7d9bf2c2a13f9f48a0d9602be60e080262bf50f1",
        "shared_secret": "eec9e658edcad5a8a705644ccd35aa3d785cc258666ff749bdbbafae6700f1b9"
    },
    {
        "key_generation_seed": "25056d1b8113bb362dd979d98643d7a7ac9c4f95994c0ba060609b6d07002ff3f48a9254dd40b117941fa35a66bb50296327b725525deef70e128ca8045ec451",
        "sha3_256_hash_of_public_key": "51634cb33a2bc3fc22ff47b58d7879d703bdd661ad3c290a6d812485ef0ce8ff",
        "sha3_256_hash_of_secret_key": "e9d2895dabc85514f2f1a543440ac0de41d49cf21686327bcc6066d21a2b93a0",
        "encapsulation_seed": "686c921c9db1263e78ae753b1c9c2e7936b8229dca48c0942c56c6bca4f10917",
        "sha3_256_hash_of_ciphertext": "8d971865b1ec760640db6e480ed27fcac239bb1c36e72054afc530d957672c27",
        "shared_secret": "d5c5e6657d310b0ccef250c9664a02c846ecb241f2404ca851d8219f93cb0d27"
    },
    {
        "key_generation_seed": "e4d34e12982aeeb1d62fd488d9b9e28557ed3429292239fb4f76fa9098009acae6c45c7fc62329b13c8d29844405db8ff6860de474bf727ecd19e54e6e1a141b",
        "sha3_256_hash_of_public_key": "45cccc2997b502ed631257065214ab9afed11f00ca5c18c92c4d6b917165fd1c",
        "sha3_256_hash_of_secret_key": "3a0f0c13760dfc8bf1bf79bdb1b4f94aa33989529be306bb826b07e089105b47",
        "encapsulation_seed": "2387772e50059cabda53cb93ba24b19ae529496c03b36584169451525c4a0e7e",
        "sha3_256_hash_of_ciphertext": "c60ba523dc75a1c9f8dd617f1cc775f6d1cee0fd7614da1a5366eee5950b6f10",
        "shared_secret": "f62460025ebbb273f00207758a1215c3a8053d2ac66cee11c6760aeef7e35d24"
    },
    {
        "key_generation_seed": "cd6a99396eb3539ca663a51e42063a3a262cc1c5a5fce1566f0597b52ad9fa325a3407f591791a5db4578b5972093a95bec3b8e70c1d542c9b5c9789729f8922",
        "sha3_256_hash_of_public_key": "89560d4e598328f6302a9762bda2b0f29fa8ee34fe48dc4847810fc6f44cc198",
        "sha3_256_hash_of_secret_key": "30f40a1a6f4adda2a9e73f3a881f3d10414031a0f5fc0f70ffa4966b29bb1a7f",
        "encapsulation_seed": "155c29c5f0378df0cd0e847a80a07143cf7522fcd880c9229eb9feb1ce340cd2",
        "sha3_256_hash_of_ciphertext": "932a09da1c6de03fddf0b45ca31f2446c5c2a3d47af171cde29149167e735cd6",
        "shared_secret": "74efee46e7b26f5022416ae9bf4a52a3940966b37fab0c3ee2e8fbb24ded6bf8"
    },
    {
        "key_generation_seed": "6c8c53ed6f65e6b2e324b84364e10de42d1c26a106d4d1c99eee79c78586fb55b9402bf02481ce4b27a52e87feb92c4399c7f2988d40e942e7496ad15ad2aa88",
        "sha3_256_hash_of_public_key": "878025deeed7dab8e62d43c3d2096e4682692537c70ebab9e1561cba88b05ec0",
        "sha3_256_hash_of_secret_key": "5469881eca81b37faa66f4d9f63c20ecf61fa8337a095410fc19eeacd774b863",
        "encapsulation_seed": "a9cb9a61a3324b1ea5afe693b32784e2871096b2ca14a11acc9577c52359a241",
        "sha3_256_hash_of_ciphertext": "0407bedaefe91d921a6442f34fe88c04e62389fc63dafe78a1a2b93723786a10",
        "shared_secret": "92fd1bb6ea9f1a0a195b3ca29e457f4b3f401fb4521842196d9471f50f5c7249"
    },
    {
        "key_generation_seed": "2107204cd995f1df14314d5381f8c5440f09a347502e161cffc0a2ec3dcfbc7324c3da70fe850e80aa818301d60c70f3038153866dcd5d179e22db59b8991bb4",
        "sha3_256_hash_of_public_key": "7d30385f988dc748b843b7b7f569e58ccc9215503e1bc2f28f5019fc72fe6d33",
        "sha3_256_hash_of_secret_key": "5b425d514afec91db185ec5e84bfd545453da4f3acfef398e7b3548c63f713f9",
        "encapsulation_seed": "e99fbae8a024ebbbdcef32ce213f6aa942e3eca925e5da4c09975d773b33a175",
        "sha3_256_hash_of_ciphertext": "886a86759ae6a21a6dabe37a4b4443bdd358502f0719b5b9178dbb6b9f7e27e6",
        "shared_secret": "e1a195eb1093af69edf107980f94adb3058378cb79dc807684c26c4ee1308533"
    },
    {
        "key_generation_seed": "63a925685a8ac5bbd918faa33ac397d1ffbcf99135d9da7c3d6ff7aa4c50af3d3afdb8a246a56ee71465591831c371f2eb87467b0559dedd776ba063ee6d2f93",
        "sha3_256_hash_of_public_key": "0697d2f9e047e603b8845c9ecb168576f9d8bc7f3c831b6ec15c5fa4f744315d",
        "sha3_256_hash_of_secret_key": "8b634d3c1e118577cc095a8bc53d05bc8c869f2001f3ef591dffd8cffffea969",
        "encapsulation_seed": "67a216f37d67f5e74f782f1badbce1cc8c80a6130aec305b421899a4faa0a6c3",
        "sha3_256_hash_of_ciphertext": "a9c68747a9697af9d9442e3d5341161afcd1977777bb40dfd8642807d96f3ccb",
        "shared_secret": "fa8721164f599caeb949141b24a124f2d576b3b58c1914af2b05da26b09bee30"
    },
    {
        "key_generation_seed": "6a1aee5e708c1b47f02bdacce4f56c860f74fc7cfec1ef3b58285b1c8ad7fec2230e05b7114ff0395cc6634db1eae8258072d09c09f291e92d6620b177dc50d7",
        "sha3_256_hash_of_public_key": "d49e426ae85eaa6c911c4dca80caba6e28e5f645a54d8c016de51a2b98241a29",
        "sha3_256_hash_of_secret_key": "cb272fd45a2a27a517bbe1d77d99c027b8664d596bd77d18c4e861ab9900b0fe",
        "encapsulation_seed": "52b19fea232c9154a3e431e9d69cda40013cf2d485c3cd027ad24e645420420b",
        "sha3_256_hash_of_ciphertext": "a569fc93ed9b0342e4090782e82b576632dfef108ece59234c783f80e1862de8",
        "shared_secret": "d479c2f5e622cf848d921a7155cbbade062d0fb3ce7535d1859eb03e18ac64f1"
    },
    {
        "key_generation_seed": "6396b328b100e4c7f4bcae69875edea1a1982421558c608c13c592bf7b5d0fef1100ced48add211a5c937b8d6079d8e271af3f949edc61f70e60453aef20dea9",
        "sha3_256_hash_of_public_key": "903d69da169d8f3f65eec290acf30078fe51bcbd1aeaf412dfe2d31c7b10157c",
        "sha3_256_hash_of_secret_key": "87b236ca8da0c7a9d38d7714e7ac16e6dad2fb5282a04b846afedbbc0449b395",
        "encapsulation_seed": "64440adb05db3308b189bf999f9ee16e8ee3a6ccbe11eebf0d3ae4b172da7d2f",
        "sha3_256_hash_of_ciphertext": "d74122c64015ba74b20c9a675bf688952d42ea421aa5c7b6c82eb6dcf0cdc092",
        "shared_secret": "0dc813eb106eb0d4864ffc38432937a1db0d27745788775a8299e93d1c808f18"
    },
    {
        "key_generation_seed": "a453bcacdd2b0d4646009e5ed451c3c45f08fb827ef733db3c517a9dc1af93e67a3cc8aa3239d4c52ce4c95afdeff6efbfacac10d294edc0e7cf4535059bfdba",
        "sha3_256_hash_of_public_key": "08cff1967030a528e748b708b0fb783577f249c04ea5536d2da034fd0d15fbac",
        "sha3_256_hash_of_secret_key": "de3ea809c8eaa873e0aaef44d481d8ae72799a0b746c5847f3d412865871bf63",
        "encapsulation_seed": "c8bb46b3a7344ad170c2052fb042b5a3b62e0590562ee82577b1081f6f114d16",
        "sha3_256_hash_of_ciphertext": "f0cbdd82f5731bf4177a14a3abfdaaef5fbe94a71ff3f1b7852a010b1d4d7eff",
        "shared_secret": "c71d65ecbae83e06c622e28a4eff43c10041539d851149dbdf295eb121550d5e"
    },
    {
        "key_generation_seed": "47ca2b77c5b717f423222c2730ca5cb9c856bc951d01b2b2c80bd76ccb5539b78f1481d7cab000e33fa07de8dc9627a85e76fabb4428a3376e66300cf12a0787",
        "sha3_256_hash_of_public_key": "b5ed4c3fb678a44d92486cf091333c7f035541614729496d5dd45ce580f0d263",
        "sha3_256_hash_of_secret_key": "c313fdffb08de4e928bf32e08a8d0310ea94f9713381f81cdd494a3d4af09553",
        "encapsulation_seed": "2e2b70609f3fe029a14d09d5d659871ac776ce2797a0355f16e2eb68f5613fd1",
        "sha3_256_hash_of_ciphertext": "5c266d232b038abc42ac484a721f63094ce50740008e0be68571018d8355099f",
        "shared_secret": "82360ffb5455f6dfdfc6bfc1a3999eb7453365ca311a0077c9d74968ed27b7a1"
    },
    {
        "key_generation_seed": "aaf6eb40e596a5e3e8218871e708b089240dcbe7fd3641f0e5e41e071ce49107e2f8d320ac3cb0c52efdc753282f092bc39baf4a18783a48ea031a191865eb78",
        "sha3_256_hash_of_public_key": "e9037042553968ff3007cdb135e368ecf440e4187e554af9d0ff272911ced339",
        "sha3_256_hash_of_secret_key": "21dc6c39559081b2ca594cee9e9825ff973158cce0d11b38a51b503952daa372",
        "encapsulation_seed": "4725dd8fb314bfd8ee23731c2341dbe114606d9abe6434c471b5573e7df193bb",
        "sha3_256_hash_of_ciphertext": "525a66ef29f0c8a0f989dae8592e9e00cb7f347915217d53f08a7699c2b912ed",
        "shared_secret": "77ef6dc5a6c8ff657070e418fdb3eb272c8784a9c38bbef950c8ac1de5ec5578"
    },
    {
        "key_generation_seed": "6500f32c93415cfdbc0bd31d78d5be95cb9060c8cfa2013955b56f8b6868b322393308641a9a4647f230201e1389624a296b55192a9819fcb19ab77c25f95445",
        "sha3_256_hash_of_public_key": "806aea6700e293f433a97e4b2c8485e6b4ac19ad493c4c16a10a2a884d58f5ee",
        "sha3_256_hash_of_secret_key": "f446ecefbf4c63e8897a89123ff38bee2aece076fc7b268b6379c996999085ac",
        "encapsulation_seed": "818d3bb8ebfb32bf464775f7139bac0a5bddce80ec5798595992f9403002cd5d",
        "sha3_256_hash_of_ciphertext": "c7c82e2b3d0d3bcb73c5d9203ca3acc94ae8818794afc7610cf48a21e830c450",
        "shared_secret": "b0978add3085e1c972bfaf86655a287946f3853cfb372f6fa5813a11b6c4e103"
    },
    {
        "key_generation_seed": "7643cef2d62cc5aaeecf754653ea62294cd2208e5bf3ddeea209e3dc45373d49eac9d531a532770837a854b4f5531f6e0c8d6c10183b30d3435498c2dd142951",
        "sha3_256_hash_of_public_key": "33df23b37987c6b557e4c0f8fa9e466312f19e7e90cd0a67abe6a145cbca9d44",
        "sha3_256_hash_of_secret_key": "039031ac6171ad5fa8734fa3d60cc5b6590574c09ae0c02564c1907ebc772d3c",
        "encapsulation_seed": "c92aa5fb91c980d9cade9ce99d4c75b2ffa7d6a6ff9bd59def1aa701f2a0992b",
        "sha3_256_hash_of_ciphertext": "6fc3012eab242c5a3dcf99b82c5e5230fb8a4d45902afc7bb82648298d8a00b3",
        "shared_secret": "b888ef3a969e162edab17c3d3de9ca682de60a0fd6ac97e1b5a54171dba12a3f"
    },
    {
        "key_generation_seed": "f8ee95521060c03bb8dacc79f7eb7db640f545f315613a35d447a09e504cb4e13fc3d8392cb53f36ed647364a04e37278a0e0a45b720f4a75c580c9920eba98d",
        "sha3_256_hash_of_public_key": "30a5771b76066feb7f606a82cce122964da1be0b6872ee319832214ec677738c",
        "sha3_256_hash_of_secret_key": "644983542c87680786b41fb07f959451f1507165353080a3789810fdf557f961",
        "encapsulation_seed": "7e8086a01dc5b3bb9eda25bcc45d27f99874841b97237968495800e007696ac5",
        "sha3_256_hash_of_ciphertext": "6d468584c0336dad723a1c3ea970d53837373372287371eeed8e08ca06e010cc",
        "shared_secret": "2fc09a1852f458bc7afb58baea4d6e318bf6801e7804b98cfc250b0a1470c598"
    },
    {
        "key_generation_seed": "b8bd0493a882e3a49b4e0f6256fb1fea0912562fd9ba26ec3d6c9cc12c8973abd7e4b5d8021c486b9c3114d7cbbeb7cd49eba8a61bc2bcae1f1bef30a1daf76d",
        "sha3_256_hash_of_public_key": "31fcd120f19fe976236711e58b4ad172d25ce01eb88bc9d6d051c56564a0db11",
        "sha3_256_hash_of_secret_key": "1502619da09b1bb5e418004fb0263c8f067cb9317053ed502c501c5b5ba4d331",
        "encapsulation_seed": "bb321ef14d44d8698df879fd52450567657f52a2df8d111185dcd7d4f30a72d4",
        "sha3_256_hash_of_ciphertext": "369203e0da6ebef7ae651a3111e67303f89f568b9897ae4c24497b3180e0bcf2",
        "shared_secret": "930131d3145d5485f06c16a9420a612330843e6524dd74654a85c383e28f2cc1"
    },
    {
        "key_generation_seed": "c0407e41ddf48d333978b89bcf2db01e4613425b456249e76a6f25b8a2827bf5b2dca81e3f5f748d23c9d356a2209f6b2d60247b2e45c9808de497f64f124643",
        "sha3_256_hash_of_public_key": "42f75d6e3755c28f3081ecc9db44f6cc7cec9891756d74093716697781fc8cb5",
        "sha3_256_hash_of_secret_key": "21b9bc0035097cb2b892a3f4ad5660b160b18973b735181beec815eaf5ba5286",
        "encapsulation_seed": "210a423dadd899b810f011794b79aa7f860823ac1962370e791287d3a1afa384",
        "sha3_256_hash_of_ciphertext": "c6d1d905150eb6586eea72b13f7210d9830e8e689f9da7d9c04fa7705f21cf01",
        "shared_secret": "b276a4fb4cf77eab502dfdf56eae9f8a8ff5e7f5df3f6cfc80614b193c87f08d"
    },
    {
        "key_generation_seed": "334382d39164d1989696a2ff77b25a28af8bead9883b5365eb6fcca7c1781cc9aba5068af837be962f439f233593d193ce5e08f7d66efb3389885927b89d2523",
        "sha3_256_hash_of_public_key": "43d6c8562cdec0e87d00c8ca8060da3f031ab663ddb43148eebd67969b7fd490",
        "sha3_256_hash_of_secret_key": "d3c172cde1f249c0a7fdb003ecc0a189776b616378b188744e407ccc601fea7f",
        "encapsulation_seed": "bc856afe24213e3d14c3d6f9b89223bbcfb2c890722d770fa3492c1e46d1c302",
        "sha3_256_hash_of_ciphertext": "353cdb064a37df87524874d3f60afdf4077be0ad96e1ab61a9ff1745d1e6e5a3",
        "shared_secret": "f4924920e64013fae72cfdd1e94b217eebd55a011f6b7542958abb297e4fd180"
    },
    {
        "key_generation_seed": "6995143e8eb8a6e93840f76eec844f67d2b5f75b1839a5040337e61f9806764a0f4dff8e56f68440836a072412a30d851ace2c7c6f02d60e7a8420001a63e6c6",
        "sha3_256_hash_of_public_key": "3cabf1c47e7aaada59ded4fa8ce378ce1d9eba621ebfe8cc96a111aaedc4b6cf",
        "sha3_256_hash_of_secret_key": "225563503590841152fcf47d4665b7cfc76e2b9de23c0e24b527395549f9f7ff",
        "encapsulation_seed": "5fc00f89563e44b24cd67d0ce684effe5731619fd08e7d72e2406eb016afb66b",
        "sha3_256_hash_of_ciphertext": "f11aa37ffca654d11cb5f9aa294ab734302851b434b57e0f5bb811bb5bafc177",
        "shared_secret": "412bafc716efe4ff928d9a86ea4665dd841e2f102a8363b994a0faad63251eda"
    },
    {
        "key_generation_seed": "995eff7e0d195c6d0533f3dc194d47e60f9ad14696144cde694d60a95f3e96b4b28f7e7a15a005f92400ce33db073d49b53871594a88fc45e0f94207b5f0f2dc",
        "sha3_256_hash_of_public_key": "2853cbbda86e7039b635d4cc850f494d42b240acb54ab2316791e9ef5b45f1d2",
        "sha3_256_hash_of_secret_key": "87ffcfe7a504e0dca284d8cf509a92a24f82ed7c46a8c1604d9a2d6d14b1cd11",
        "encapsulation_seed": "ea22a76065db4b565ee1807fbd813b43bde72b0e08407fb867c6a18995025e50",
        "sha3_256_hash_of_ciphertext": "ae8fb4bcfc08f8daa486b185540b501680e511f46fe8a628b8fe449d5a51590a",
        "shared_secret": "c514d4086428200e118c1c297ce5ed865d7452cd7770363961bbb834f56c564a"
    },
    {
        "key_generation_seed": "3e809ec8dd0fec0d911a4e3fac20f70fbb128c5de94dc7184ca7310ae9157a98d8128601c28b1def8d393a0db283229f7c7383152a814e7cefe8ef9d9768c473",
        "sha3_256_hash_of_public_key": "2d5680b483287bbd3e61a91839cca9e761429186176b7bc64034ad43f16f65e9",
        "sha3_256_hash_of_secret_key": "bed74aff196e7ec7bbb4dcaac39ee1a79cfb35140cf4c400b6ef2fdfc53afc6f",
        "encapsulation_seed": "e9602b34fe73ad57f4bf6ead99743d645641553a5b9b9bf2e7016629e3e9bd76",
        "sha3_256_hash_of_ciphertext": "d46f403ce5a0dd92937acc508501305da6bcd32b56ff5d986fd6a07e713ab92c",
        "shared_secret": "a175feba4c1bab576085bb12683d2bc44e98c75f543cee714c75391c559450ce"
    },
    {
        "key_generation_seed": "dbf1c465fff3d9f783bd9ee61a573715e45691147b8904439b5ffaa64f94ff7bb6d75eac6c76ced1b0a025b40a55440712ad8424672e761e9bc400d63812006f",
        "sha3_256_hash_of_public_key": "38635cec71b814aaac223f748d13158dbe8eb902d9125fdc22202c4d59251cbc",
        "sha3_256_hash_of_secret_key": "f3b87926951408dbb27fc2a4a6c14c40fedc8a1cf5c34ab398d91d554eae344f",
        "encapsulation_seed": "f72b9080a6c051bbdb9b0abc1949034be0f89a9f73fe277ec4d4740c78d04a83",
        "sha3_256_hash_of_ciphertext": "50350977c400c1318bac5e32925d0f575dd3559587f42d025f4e71648e697218",
        "shared_secret": "9781578191ebf49b162aa768d093a332b9c849c11e240187cec2ee969d4b3860"
    },
    {
        "key_generation_seed": "1f7cfd2b70863154e8a69d1758532e86c20cfc763d67c758bd10a13b24e759b5273b38bddc18488024ec90e62a4110129a42a16d2a93c45439888e76008604c6",
        "sha3_256_hash_of_public_key": "af97825a77f2f4b6a45ec1a579f9f83e89c025d8d6876db26874f38348604293",
        "sha3_256_hash_of_secret_key": "b2f08250a2681bbbd3c355e2dc61bda33cfe39f3dbbd2a3f3c41ee2266084cc8",
        "encapsulation_seed": "f1e5542190db8ecf4b8d617a04fd3783ad0df78bf8dab749afb57db8321d151b",
        "sha3_256_hash_of_ciphertext": "33acafd1de1d8d8c7a9ff9a6cd69fd013b46b79e74a9180e99d5fa87805dc0de",
        "shared_secret": "515dc87c21e6b134a577e4eeccf43a982ba7eac1224d701cf099ad07fee77cb7"
    },
    {
        "key_generation_seed": "3a19577908efd37697b8edc7fdaf47d1bd3ad01a1b77faf794bee5b9c3192a6fa3729672816f3eba84c9638a79676eeac0f22c8a48e0c5d50a26ff0844c66b99",
        "sha3_256_hash_of_public_key": "8517ab7585926764ec7acff3c747479e837831429b97b7cf49ac3763bd9ebbe0",
        "sha3_256_hash_of_secret_key": "7e5684a04d59f9166f6b408dbc8ae5daf3ec6678cf5eec1e5a9016392cd6c8db",
        "encapsulation_seed": "74efa414ae171bf60b6f884cb7e5ce12028f49365daccfa23e845d551711660b",
        "sha3_256_hash_of_ciphertext": "0515c19fb395ed94194a60a6f7883d6351fa61ff18060be4cfe2eb9f81ec0024",
        "shared_secret": "edc2c0314c7c5b2b071b85e373c06b31fa54dc499168d4b43b15f1d05b8b7ea9"
    },
    {
        "key_generation_seed": "ae0f65e29f38804a6759f70f4d01e2aaff7fe1c91ebc4f892dd0de3ab2e68ea5e03ff73e02a217659f53d8c47556bf3d8c94040f630d63605e2d0f923579370c",
        "sha3_256_hash_of_public_key": "1bb014bb0d6489c14f5411051f9667aabce54da7a8deb73b627e3873d9390a35",
        "sha3_256_hash_of_secret_key": "b890e330079934f2aac63e5f8d236054fabc8d6a6e057672a7a20150ae08a9a0",
        "encapsulation_seed": "0b4c3cffb2ba4380ead13dc0d8acad2356b448a810da1df29f264c44aab6d24f",
        "sha3_256_hash_of_ciphertext": "79018c9e998deaec058d73d702b669e10c89dd8285f431aa6e422a948a39cce2",
        "shared_secret": "b3363e6e6dba3e41ac2c63895c461765bc8a0250880d3dd6e8a4479a7fd3921c"
    },
    {
        "key_generation_seed": "6084a235f79dd093ef6d185b54e69df33dacee73a9bf2f379004421a10e3a79d9f684fb055ece19459eb464e91e126a7a6e3ed11ccee0046da234d964c985110",
        "sha3_256_hash_of_public_key": "c9a546b5c0a567855039f6c1bca60414684e7bd1f8eeb7913f3a1795ba4bad4c",
        "sha3_256_hash_of_secret_key": "be5fc57b3efd80d7e82b23f62123814ce04e83ce5c998ba42e7bb978dc70469a",
        "encapsulation_seed": "1c82471dcdfca3a6942061ab4f3d5bf0d197321437c706d9cccccce449447002",
        "sha3_256_hash_of_ciphertext": "6c1b69d56c493f6f313d3c996336b8f84b76fac2d5ab5a3d795613b27eb10912",
        "shared_secret": "8e648593c8f6f6f7a97ce7a2d151ada30fbbc7f3c4fc517d8cbadd71e6a17476"
    },
    {
        "key_generation_seed": "acd1c0217fad5caa4235544dd9de153ab1880ccf4c76f16f236fae4e4bfda04cf03a8abb0a5010f400ae5722a75bdf5a2f6d5b546b34d73857cb1bfc7e587aa7",
        "sha3_256_hash_of_public_key": "8f7bfdde2a7116ff4010cf829cbb18512f7cf44237c02241a1f75fe3ba8d22bf",
        "sha3_256_hash_of_secret_key": "3f53a0acb384db89ca83d031bf210b072860adcaceecd79c36b4669407c1c227",
        "encapsulation_seed": "46fe60a18124125ab93e0c578f1c02f1bd1301595013001c7f3c2fa56cde294e",
        "sha3_256_hash_of_ciphertext": "cc25f35631396f01cc366e019a7f15034cb2341d6c00924b538d25a227ed181b",
        "shared_secret": "bcdd6f0d744d2a35147323a4a0451fbfb7d60d73c161c1f8c6a2b5e9f4239c65"
    },
    {
        "key_generation_seed": "241191401a63afa750f05662e354dddbc683c776ce3222beb83e3cf913d7ed7ca59b3bd23b49a95bc1fad20070fec930b6060bd827d742b077092e422268e15d",
        "sha3_256_hash_of_public_key": "27b1b921723cedf55fe756ff5fb67d555296c6185d171ed8ba01393d1a735018",
        "sha3_256_hash_of_secret_key": "40db89fcd941566546d554db0342237611e5ef6fdf8c790f03357091af0648ee",
        "encapsulation_seed": "52fb7cb6a633fd2e83f2892bd9441b48fe59ecee6d026f5246fa7f2a5e55ee3b",
        "sha3_256_hash_of_ciphertext": "c5b4844dd10ecf508ea6ed2d96d2328d3f14df6a2a16093bf88ca1283e30f41f",
        "shared_secret": "072551e254959ce9f2c67657b41122d8a98cde044bb2f60955bdc6e5dbe55277"
    },
    {
        "key_generation_seed": "b9a6b0c05677e957d41a34ba03bd06f2a9092e31f63389397d7e70fde6409d18e99c0e7b82be89bc3c1eaee6680aa4efd394e40c2b3f30523c8117f7c26a8969",
        "sha3_256_hash_of_public_key": "32a2a1197d78798bbeb13ce2e92cd7ed94b410adc37b1b31dc060af11fec8a8b",
        "sha3_256_hash_of_secret_key": "602bedde695713681a96c94a9a6d35308102ae18d3f3beb92a981e4a3b7704f3",
        "encapsulation_seed": "0f81a5f97082121244403da3feeb734f6084b314b8d94beb11627aa6ad1914e9",
        "sha3_256_hash_of_ciphertext": "e4631748f7cba566889ca2c5d90c47bba17000a0d934c4242a9a3d6dfac039e8",
        "shared_secret": "88c0c1e22b68cd65e1eedd6d6208c36492fb674e26ba4e0d4e55f831a1affc96"
    },
    {
        "key_generation_seed": "28a96c71577ba00c94f99fe965bc595a26db2b3ca6ab5cf8e443cdd8462b17929c35d165453e5fcdc6f9df64526d9de698f2bd3e6bac6c7fdd86601b9ba5f4a5",
        "sha3_256_hash_of_public_key": "7cc3f47f319f88da508f841e536a056625f206fe499387d27307257682237f96",
        "sha3_256_hash_of_secret_key": "064bf50ddc823a97adfc93d52ecbff03a0fd5d94ab38874a5abaedbdaba67309",
        "encapsulation_seed": "31af9345365549ea0360169ed57daf98cc5444799d4c75d9f1f5d615e9df8a91",
        "sha3_256_hash_of_ciphertext": "b34a0a91afbc9599ae00e67ba4ebf0d8308b3e06efcfa148aed519b0f073ddc8",
        "shared_secret": "56f717e4baddc2250873d667f73a442b05ca2f8714d4dc4d295f899217c92c9e"
    },
    {
        "key_generation_seed": "c08ba2ef8c3a0a043afad931652d7a19e6e8cb670f840de5f1fa03309b2ca9ec5fe6141a25f7ab9f875f79e0a82d6ea5cde5a017ab637d5fdb7c42646a1d71df",
        "sha3_256_hash_of_public_key": "beaeb6ff178f3228defdd117e6ba75a34abb70e86f31fdb16d74d91e6c1b47a7",
        "sha3_256_hash_of_secret_key": "9cf056be85f240e1ae5b73656c07bfe83ba8ec7212973bac19cffbb80dae7249",
        "encapsulation_seed": "774ae54093d694ef40b63b62c73e6c98295f606feb8699807eda1d030ffb996d",
        "sha3_256_hash_of_ciphertext": "89243e04aa17615c309cae73fbfe985e0716c7fe3b8283b5e84c3caa67b5ad3f",
        "shared_secret": "35f5517999e15ed842904d53d5b4747639d1165014ab77474c0dbc310e586186"
    },
    {
        "key_generation_seed": "0e3b30e102d707538c2671060f603bb0b8a014103f132d63b09ece07e4a4c75b11eafeca9e810796c34e8cfce9d59342884456007b01ddd12edce6d10ed87e4c",
        "sha3_256_hash_of_public_key": "b2b71b8aaccf14842a6d4ecb713612f801a5044147fb9e6987ad3863759de31e",
        "sha3_256_hash_of_secret_key": "01158ea58361ef89d935c9f845711c7f581322afddaf14e255f71c1dcc9c0024",
        "encapsulation_seed": "9f27a47604ab5146caaf0aafe6d149424f8d66e39ba3baf5e6c73b19221b7e21",
        "sha3_256_hash_of_ciphertext": "ddf853fbd339780b3f571de2aefb30f760454f2cc1f0fca009bc829afb1f3f7d",
        "shared_secret": "a7159981a68244549b96b27991e1323013c353bdd9c8d6f583897c35923e87a8"
    },
    {
        "key_generation_seed": "2478f7d3de6041e7e5cd11c5e2ef483d1aa6218eb126444091535f6ae532fa7311136e2681df2ef881b51a092a9badbe72c9772c169808521c47149578621e28",
        "sha3_256_hash_of_public_key": "a13cb3f23ccbd9ca6a75823d1ba14ef03664560f397133935103ded2d7480b99",
        "sha3_256_hash_of_secret_key": "710b3a8c8d49ee38390cd2776c42ad74a520c8d6ebd39b514f6fbf28c6c74b45",
        "encapsulation_seed": "90044031b7597b5e60a4f946b713e8996d0426d2cb013243d9b7d8f8ef159a0f",
        "sha3_256_hash_of_ciphertext": "f5c4738d0ac3b25048186a2049668247c04033cb363e9d23b5d1518f8fa7e70f",
        "shared_secret": "c4041a29c5b744e9039bf5155cb3ac0b799356829557a7aa3feb4b3585e6cf62"
    },
    {
        "key_generation_seed": "9d405d3ebdaf35fa8722de431b669722acaaea2fd10b814310b17f78b66147d16ceb14f7662be0c42779459f69a145c0e2ce9f0bd9a0cd1bf32ed5694cc9ae32",
        "sha3_256_hash_of_public_key": "68302cc5af214ceda67ff8161b29bc300c4be8e1a4139437aead8a9ede3cd4ca",
        "sha3_256_hash_of_secret_key": "5d6904a6478f0632ec56477321a6d6ec5ccdf299bed0b6ee9f4b32c6b5effec3",
        "encapsulation_seed": "a7a31e140891ea37d2b6424b59b1f84f89220f32dcb73e037eb912b389d34a48",
        "sha3_256_hash_of_ciphertext": "b4ddaeac7b4080e5e9bccdd2cbec4395a1393e61e038bedae9542db78769b923",
        "shared_secret": "b8441852349193321f466ccbd3afa48bafe903288108312de26e9bf0de9f680c"
    },
    {
        "key_generation_seed": "9a86490f0615f3edf789cb0654066e9ee339cc59f968281f3b89213f83c692edfaeb2ef44d2f608621e831187ce79b2d2f4a20f1568bbe76b0d3d5af36111714",
        "sha3_256_hash_of_public_key": "149ca4d94813f81c792060502e09a88ea694c5de863ce6a50516cacb1c3f44bc",
        "sha3_256_hash_of_secret_key": "8e69c68f8a7a0ad82b033a0bdc94d253d3e7e8516d67e86bb95d219a1090529c",
        "encapsulation_seed": "70eb3f791faa91f1f982fa477dbcddeb2c55691c07f93b04cd31b37544c94b42",
        "sha3_256_hash_of_ciphertext": "5fbbb17b2c8ecbb8c74f2cf6259404cb9e0cadd393174e49e88298c6b7a34a22",
        "shared_secret": "9d0d9ba501da1b46775258f5c0904721906b237c3461da6c31d70da8575fac37"
    },
    {
        "key_generation_seed": "6dfd9b575872560c7bdc2732c4a28dac4db04e535eb8e402c3dffd145c09ce47a2985c1c4d203778597947d710dec806e36b0cd949fe460ef141213bfc525e5b",
        "sha3_256_hash_of_public_key": "e5c52e639e5acd0fb97c7eb44df56df5250c6de7d171c467ce6887eaa4ee3d61",
        "sha3_256_hash_of_secret_key": "6b452ca57379b09ea36746b5b55be3b73df4faf809d7899c5368a51eb4b18cab",
        "encapsulation_seed": "30f4095015ba88b6d969672ca3f438c395dacf7d476ea7a9e805ce932d270a13",
        "sha3_256_hash_of_ciphertext": "9ec7acd421fd05aeb4440720890cb1ebfba0f0ba3d9b57268b583ea10720a32d",
        "shared_secret": "188aa07faa2b7a19b6b7bfbd4cbb1ad829a7415d601fdc3b635528db136cac52"
    },
    {
        "key_generation_seed": "6fca9f4e384d8418075cc064c70730801bdb8249899d456a77130d5beeb3662cce7683f8a03d3cf04e46970ff7d6a12494ae12558346dfc8fd9370bf944a0102",
        "sha3_256_hash_of_public_key": "9a350302631bd506be010a3f42112ae4ea731d515d80c3a21fcce60cc4d945ab",
        "sha3_256_hash_of_secret_key": "985f528fdd675f3efdbe95a03e071f28e2dd16b425c51651a1e645f6b87eb25e",
        "encapsulation_seed": "cf31220f44de862e1719570e1b26e897790159366a385452334fe24cdcae28ba",
        "sha3_256_hash_of_ciphertext": "df8cc2e78b5df8a43e7ae87566452a5df656f13f93a22566116a84c30b786f8c",
        "shared_secret": "70df7eeecb6ad19b54498071e0840f4957e935a62feba82fe29531f79c2c1651"
    },
    {
        "key_generation_seed": "e58f71bf175c0550a67e00e0f7b3b7fc36bc2707bf0c93044a492626de36301a7f7054814869cf7625e45647bc1547aff288dbb90699b2ad84893f3b755d9722",
        "sha3_256_hash_of_public_key": "866573e536b4017c02e31c8ed7455c841a5ccdb795fc200acaf1da2fb936bb59",
        "sha3_256_hash_of_secret_key": "e8a4ede82799c3a425b82912df460d5d1e78757b4a917177489839abb92029f2",
        "encapsulation_seed": "bb5e65669a44e5d5c709bafa98c16ccba6ac2c4ae923334f69a11543eda64f5d",
        "sha3_256_hash_of_ciphertext": "99d967e7c92a7d7e2ed54b1339472d8780e0a7671aa9afb8fa2f19cf96353821",
        "shared_secret": "8baaf439867c9761e78a64652a383e21682969d18f84dbae0d3a63095948863d"
    },
    {
        "key_generation_seed": "e3fc575ed51513e62aba655d24cd9c8f1c6c848aaffa946c49a53ac3ea59e474d82c2f1bf2e6aebde5660fa73356982e12999d8fdafbb3cb186341d0386dead0",
        "sha3_256_hash_of_public_key": "b33387825115cba8b0ae7da0d1aada1ce4ab05bc2479b360b6c56dfa870ca825",
        "sha3_256_hash_of_secret_key": "7c35640775e31eaba8a119a8e89e1e2180177a55e54391c3fa6675829d721b01",
        "encapsulation_seed": "9ddb3aa9c7905d1a438c93bcf78e3e321813580371ab4e1289e2dbf3701972c2",
        "sha3_256_hash_of_ciphertext": "d42759ad66725175d4d8d3cb6519e9074d6c13d4d183863f1695f0e3b831a10a",
        "shared_secret": "60b466221ec831f91a91b76ec6bbc29726f65ebcacc96f9e191f57a1399be186"
    },
    {
        "key_generation_seed": "470b4943f0fe7fd0d8ec5185aba0d1db09d112934e4fb4787e2bbc6b88466e7b8b2809fd40008be70a6b184981101724bc3d5ec5e1956b510b82fd5ad0668a5a",
        "sha3_256_hash_of_public_key": "720fd4f96ab2cac1be382907e8cba0702018ca27b28ea8f93cc19c4809885a3b",
        "sha3_256_hash_of_secret_key": "c1ec32b739485e2437a6b4dbed289f0cb7dea0ed3b2add99d4c49a3eeda1b0fe",
        "encapsulation_seed": "26d90b190a6c3d0d9a86cf66005154e7086749e966e7187c249ccb9329fd3b8b",
        "sha3_256_hash_of_ciphertext": "5fae7a10471d5303e5f6ee5d1e34013528af4945de811ffa1828648986607299",
        "shared_secret": "6a302778f406082fa285c5ee299d78b048e837c5012f42f9a80e8659b10defda"
    },
    {
        "key_generation_seed": "6df4385db978d27b27d2aa5e452e4152b36f097503d9581ac3390105c5727e7dc95fa08ed106ce84660e8a4c90bd2b22634e40769aa0090a101c5dddad45edc5",
        "sha3_256_hash_of_public_key": "bfa4b55c7baf2651415d3f28d221b291b175340a07843b299a46e02e22657634",
        "sha3_256_hash_of_secret_key": "605c4a98f3775c9678804fd5795946c1657311d123b5c7d1544192a205c043d3",
        "encapsulation_seed": "7db6d1a129d6123f1f805b79ad3b413012ea86aed42a05e98e7b1f32f9fbbdec",
        "sha3_256_hash_of_ciphertext": "39e07846b4ca91147a0b680f5411c75db937a6855f08939f746ea3d5f9a11d51",
        "shared_secret": "88a46d35cf07e48c6528b95016aa0c414344e090ee897fd80f26b67bc0451c7f"
    },
    {
        "key_generation_seed": "dbacba825728444921b227cdba54446b3f6881b47be9cd02832f78b023b1bee0e15274a8e2bc08fe818b117ba28c5dfae74d54fcdf6f20052f79be333edc8dde",
        "sha3_256_hash_of_public_key": "9675fc6d1e3cc4e0eb62d31b6b4f10022d373d2718f3d20ee1cc00ef6892d9a0",
        "sha3_256_hash_of_secret_key": "c463b8ab9069814e5308cf9742c6ab6e08c355fa34c0d2e65df1962589eba56e",
        "encapsulation_seed": "1d129b27be7384c359d04311fe5c44917d1fde4bfb57314f483ac617edd5ac49",
        "sha3_256_hash_of_ciphertext": "5c7ef87c49f71d3098fe3d33b22bc8191f440bcdf1d04a46f293c5e6b16af12f",
        "shared_secret": "f3c5586476f4814a2d3728a6f0ceed7d19d076b790d3675e48611c4b8df9702e"
    },
    {
        "key_generation_seed": "690eb71fd7052b906eaec09937a8ed374e0b02afa27c2f14399932be5839fad281c38c2cb5cfafac81b96a810ab749b61806b6d54c9f8cf4bf1be0192423288f",
        "sha3_256_hash_of_public_key": "9d162fce2f019205a2106acc8e3e3465b6fa3912a06c764e625cbe3b95dea6c8",
        "sha3_256_hash_of_secret_key": "eeb3bd9d8636b55722f42b3342e415b23df96d1c9b2c5b9c1c2a3e619348ba6f",
        "encapsulation_seed": "bbc773ebd2df42c36ae05952d6a64c63a5dfb82ceb3ef4f8d4df3a30ec8c0467",
        "sha3_256_hash_of_ciphertext": "d482f25e93fd142aa009f2f2569427ebcf04b87aca2bef5e022bcbc1e5972ed1",
        "shared_secret": "a828fc1446ff04a950e4f551e442aeba279f44de0ec5296fd981bcbe6ee90d8e"
    },
    {
        "key_generation_seed": "32e0ea9089fa928482c0770da545af1bb871a03ce38604138b0d08ea2a10ca2bc06c5bef7b6508409daf847a64c8d30d0974fd3ba7476dc76c46b458a036d884",
        "sha3_256_hash_of_public_key": "3e834e34f198ab5a3504cfa0c6af6ab78de3a3ef5667e6065e084cf5d2a5bb32",
        "sha3_256_hash_of_secret_key": "d74767e217cfaaf75adc92927107c76d7267b1d7b3b76f2f8ae5a9044aa290f2",
        "encapsulation_seed": "5b17a6adad541efcbf5ae4b0c0452cd2ce32e4f0f8701801c5b63e197c1fcbf4",
        "sha3_256_hash_of_ciphertext": "3a41b6054d918e9613e8d4eab83628f7c82b6ef447ecdacd0a74cc21be6b47aa",
        "shared_secret": "d98b18f7b6717b8f6b3e331d6d8f9d3633eb70f54133a78e2345138420edf89d"
    },
    {
        "key_generation_seed": "6fb2ec719f2a0dea152bf3f64b9d148f8ab8ba88f64e61f5db53e12d59f525574f797c007e4061f95c7d56cfc7ee5c49e849dde3fea8f25e7876df2a18515c34",
        "sha3_256_hash_of_public_key": "c5e157ff4357d3c26b7c4b45315f0689f135c85d952a64648b0a8cec03741fe0",
        "sha3_256_hash_of_secret_key": "edc6b8e2036f9ce7ef87dc58d4866ad9f320ffab1aa22371b7b56ec727f77531",
        "encapsulation_seed": "61ab87659525de9656af41246f20e1dbe85c24e335e7ecf9493f46168bc14e94",
        "sha3_256_hash_of_ciphertext": "7324a073d06af373494ecfc7960cfb81484e9ae64bc16e13651b015cdfb73668",
        "shared_secret": "b7d5919f0bab0e2715a97cab993656831bc8a3dc86c3bd32e64ccb4762f70499"
    },
    {
        "key_generation_seed": "527fb88c8bd9a4d6031dad15e63878abd2b559e7e08d61f69e8e78fca964ee6ae32d432b4f9f751bde0496c580a181ffed762aa35454a02d3f1f47ee0394c89c",
        "sha3_256_hash_of_public_key": "f5cedd022077b1a6a052f5287219393cd2e0366d0f5531b2f7ea8704d2900ce5",
        "sha3_256_hash_of_secret_key": "882916ad7b7707feae2885f13bdf19d36931886c4bfd188fd46b6b6adeeb8d78",
        "encapsulation_seed": "eca2adc3da1fb15f34033405ec08ef2f46163df4bfcccf8842c600ce0bc2026c",
        "sha3_256_hash_of_ciphertext": "84e4fab74ef96f7b3ec50d7afdf69445b4326fe3ad695efcbf56426c0a6df6c8",
        "shared_secret": "149e4e38a07d18c0b08edf9c47e425b56f7da87b2b9c855bedd29f6f0a8fe5fa"
    },
    {
        "key_generation_seed": "ac6fcfaeeef795b6ef9e062f02bf42975fa01e7d91ba832f74e05269a72684d05aeda108ea4d6c6bc0fb958286850422bc357ca67b83c986048e0d0087fa11ec",
        "sha3_256_hash_of_public_key": "a53a20ea03e400a843c8cf4d04bfe0c0a3ce63dde01045e2669f7ae5da790577",
        "sha3_256_hash_of_secret_key": "9d1e4432908352535074efbfa7cde3e6738e073fd512e04e9601380fb40b7614",
        "encapsulation_seed": "c4f15bec2d7701339d0ade4835193bea3632edcf89e74992620d9eb623a0d0d4",
        "sha3_256_hash_of_ciphertext": "071204e26ed00e7a1f226d4e971cfb2d9502e17da99f5479235763cb7723ac5d",
        "shared_secret": "38a1fcaf302905e18940605e49e5f44c747b06e789acc9c395211823598ef516"
    },
    {
        "key_generation_seed": "ba2fb9318d4dbe7488057c33e95e6f054583a2800c41bb83083c330a914a12cfe63f8ffda3565c2424c89b20974b748a65a5aba75133fcb3156dfb6626a83bab",
        "sha3_256_hash_of_public_key": "cacca228846450ebb8f04a2a5ef2d919dfa47c4aa265f4cedd10cf74eef3ecc1",
        "sha3_256_hash_of_secret_key": "a01db77c5983b2472e616dfc04666a2112924dda5ffbf00a989cf1a48578898b",
        "encapsulation_seed": "28878249e2ac2b6263422993923a0c8bd05ce56e385ed13c943b03d226856947",
        "sha3_256_hash_of_ciphertext": "dd0b438cb7dcda28762d06e61f1765baef8003d0d86ff48cd4f9788cae8e8618",
        "shared_secret": "403543b0f8e519ba4ab878c40ab5aed412ea06bfeb2b864baa5ef4b81a42c454"
    },
    {
        "key_generation_seed": "aa6dd1e5799cdf7af9c4fc632b3eb9d51d66e85c8e0a21ec98664fc51ab63c7dfda268813efab5204efa60f78bf81d320d01ac09ac06244f7afbd2d80fd356d9",
        "sha3_256_hash_of_public_key": "4126f5151d1b086e26a88bd9f20710ef06aa0f834722b801f6b79c031f1f9213",
        "sha3_256_hash_of_secret_key": "9a6c24b5ae556241f3e6b07a7576971173ecfe474be9c6b09fd12ddef8b5f75e",
        "encapsulation_seed": "17fc65f7fbd7c75ceec421dee84dff5a8cb22764a182db17e0ebe857f54d60eb",
        "sha3_256_hash_of_ciphertext": "7c2b9cd82c349fdc534ac30eaa18bf83afd0736b17a4320963571c109451a5b6",
        "shared_secret": "f7a280462f93b619888b5a72da3749556e53ef4f4440df728c8db1edcc86cea4"
    },
    {
        "key_generation_seed": "195d6c86a3df4c21e3007d7f2768b43c74cb3060e0eca77f0a5d3271542b9a84ae77e0f9f21eabd8c0c6eea7767f4e10fde5c2d79b8400bf96b19014b457ec21",
        "sha3_256_hash_of_public_key": "b6f12914ed31f14f79c652eed4db478de7ebd263fe27052509fee10b50f2d053",
        "sha3_256_hash_of_secret_key": "1a4de442c4c6db97bfa12227c4423237a869c93154e2c5ca49cacbd0ef730485",
        "encapsulation_seed": "fa0489f3730100609488e951e6aaa15c0f193bc1dbcfcd013bc418d6c507b176",
        "sha3_256_hash_of_ciphertext": "41d75dd4690637576652071cb46987cc26321a07bb47a1cfb07f30d2153920c5",
        "shared_secret": "fef3730b905431d14aa7aa7bb1d253cd912335c590b8d7de1e7aa4e0ff76be04"
    }
]

================================================
FILE: test/libcrux-ml-kem/tests/sha3.cc
================================================

#include <gtest/gtest.h>
#include <nlohmann/json.hpp>

#include "libcrux_sha3_portable.h"
#include "libcrux_mlkem768.h"

using namespace std;

typedef vector<uint8_t> bytes;

vector<uint8_t>
from_hex(const string& hex)
{
  if (hex.length() % 2 == 1) {
    throw invalid_argument("Odd-length hex string");
  }

  int len = static_cast<int>(hex.length()) / 2;
  vector<uint8_t> out(len);
  for (int i = 0; i < len; i += 1) {
    string byte = hex.substr(2 * i, 2);
    out[i] = static_cast<uint8_t>(strtol(byte.c_str(), nullptr, 16));
  }

  return out;
}

string
bytes_to_hex(const vector<uint8_t>& data)
{
  stringstream hex(ios_base::out);
  hex.flags(ios::hex);
  for (const auto& byte : data) {
    hex << setw(2) << setfill('0') << int(byte);
  }
  return hex.str();
}

TEST(Sha3Test, ConsistencyTest)
{
    const char* message = "Hello, World!";
    uint32_t message_size = strlen(message);

    Eurydice_borrow_slice_u8 input;
    input.ptr = (uint8_t*) message;
    input.meta = message_size;

    auto digest = libcrux_sha3_sha256(input);

    bytes expected_digest = from_hex(
      "1af17a664e3fa8e419b8ba05c2a173169df76162a5a286e0c405b460d478f7ef");

    EXPECT_EQ(strncmp((char*)digest.data,
                      (char*)expected_digest.data(),
                      32),
              0);
}


================================================
FILE: test/lvalue.rs
================================================
enum Struct {
  A(Vec<u8>),
  B(Box<i32>),
  C
}
enum ThreeWays {
  Middle(i32),
  Left(Vec<u8>),
  Right(Box<f64>),
}
fn use_struct(s: ThreeWays) -> Struct {
  match s {
    ThreeWays::Middle(i) => Struct::B(Box::new(i)),
    ThreeWays::Left(st) => Struct::A(st),
    _ => Struct::C,
  }
}
fn main() { }



================================================
FILE: test/main.c
================================================
#include "__NAME__.h"
#include "eurydice_glue.h"

int main() {
  __NAME___main();
  return 0;
}


================================================
FILE: test/mismatch.rs
================================================
pub trait Operations: Clone + Copy {
    fn zero() -> Self;
}
pub struct MlKemKeyPairUnpacked<const K: usize, Vector: Operations> {
    x: [Vector; K],
}

impl<const K: usize, Vector: Operations> MlKemKeyPairUnpacked<K, Vector> {
    #[inline(always)]
    pub(crate) fn default() -> Self {
        Self {
            x: core::array::from_fn(|_| Vector::zero()),
        }
    }
}

fn main() {
}


================================================
FILE: test/more_dst.rs
================================================
struct S<U: ?Sized> {
    foo: u32,
    data: U,
}

type T1 = S<[u32]>;
type TS1 = S<[u32; 4]>;

type T2 = S<T1>;
type TS2 = S<TS1>;

type T3 = S<T2>;
type TS3 = S<TS2>;

fn main() {
    let x1 = TS1 { foo: 0, data: [0; 4]};
    let y1 : &T1 = &x1;
    assert_eq!(y1.data[1],0);

    let x2 = TS2 { foo: 0, data: x1};
    let y2 : &T2 = &x2;
    assert_eq!(y2.data.data[2],0);

    let x3 = TS3 { foo: 0, data: x2};
    let y3 : &T3 = &x3;
    assert_eq!(y3.data.data.data[3],0);
}


================================================
FILE: test/more_primitive_types.rs
================================================
struct MorePrimitiveTypes {
    int128: i128,
    uint128: u128,
    c : char
}

fn match_u128(p : &MorePrimitiveTypes) -> i32 {
    match p.uint128 {
        0xffff | 0xffffffff => 3,
        0xffff_ffff_ffff_ffff_ffff_ffff_ffff => 4,
        0xffff_ffff_ffff_ffff_ffff_ffff_ffff_ffff => 5,
        _ => 1
    }
}

fn match_i128(p : &MorePrimitiveTypes) -> i32 {
    match p.int128 {
        -0xffff | -0xffffffff => 3,
        -0xffff_ffff_ffff_ffff => 4,
        -0xffff_ffff_ffff_ffff_ffff_ffff_fff => 5,
        _ => 1
    }
}

fn int128_operations(p : &mut MorePrimitiveTypes) -> i32 {
    p.int128 = p.int128 & 0xffff_ffff_1 - 0x1ff_ffff_ffff_ffff * 0x1 << 10;
    p.uint128 = p.uint128 & 0xffff_ffff_1 - 0x1f;
    let x = 1u128 >> p.uint128 << p.int128;
    x as i32
}

fn more_operations(p : &mut MorePrimitiveTypes) -> i32 {
    let mut result = 0;

    // Add
    result += (p.int128 + 1) as i32;
    result += (p.uint128 + 1) as i32;

    // Sub
    result += (p.int128 - 1) as i32;
    result += (p.uint128 - 1) as i32;

    // Mult
    result += (p.int128 * 2) as i32;
    result += (p.uint128 * 2) as i32;

    // Div
    result += (p.int128 / 2) as i32;
    result += (p.uint128 / 2) as i32;

    // Mod
    result += (p.int128 % 3) as i32;
    result += (p.uint128 % 3) as i32;

    // BShiftL
    result += (p.int128 << 1) as i32;
    result += (p.uint128 << 1) as i32;

    // BShiftR
    result += (p.int128 >> 1) as i32;
    result += (p.uint128 >> 1) as i32;

    // BAnd
    result += (p.int128 & 0xff) as i32;
    result += (p.uint128 & 0xff) as i32;

    // BOr
    result += (p.int128 | 0xff) as i32;
    result += (p.uint128 | 0xff) as i32;

    // BXor
    result += (p.int128 ^ 0xff) as i32;
    result += (p.uint128 ^ 0xff) as i32;

    // Eq
    if p.int128 == 0 {
        result += 1;
    }
    if p.uint128 == 0 {
        result += 1;
    }

    // Neq
    if p.int128 != 0 {
        result += 1;
    }
    if p.uint128 != 0 {
        result += 1;
    }

    // Lt
    if p.int128 < 0 {
        result += 1;
    }
    if p.uint128 < 1 {
        result += 1;
    }

    // Lte
    if p.int128 <= 0 {
        result += 1;
    }
    if p.uint128 <= 1 {
        result += 1;
    }

    // Gt
    if p.int128 > 0 {
        result += 1;
    }
    if p.uint128 > 1 {
        result += 1;
    }

    // Gte
    if p.int128 >= 0 {
        result += 1;
    }
    if p.uint128 >= 1 {
        result += 1;
    }

    // Neg
    result += (-p.int128) as i32;

    // BNot
    result += (!p.int128) as i32;
    result += (!p.uint128) as i32;

    result
}

fn use_more_primitive_types() {
    let s = b"ahello";
    let p = MorePrimitiveTypes {
        int128: -0xffff_ffff_ffff_ffff_ffff_ffff_fff,
        uint128: 0xffff_ffff_ffff_ffff_ffff_ffff_ffff,
        c: 'a'
    };
    match_u128(&p);
    match_i128(&p);
    assert!(p.c == s[0] as char);
}

fn main() {
    use_more_primitive_types();
}

================================================
FILE: test/more_primitive_types.yaml
================================================
files:
  - name: more_primitive_types
    include_in_h: [ "\"eurydice/int128.h\"" ]
    api:
      - [ more_primitive_types ]
    private:
      - [ "*" ]


================================================
FILE: test/more_str.rs
================================================
// This file describes the usage of multiple UTF-8 strings in Rust.

fn use_str(s: &str) {
  // This function takes a string slice and does trivial operations on it.
  assert!(s.len() > 2);
}

fn main() {
  // various UTF-8 strings
  let eng = "Hello, world!";
  let chn = "你好，世界！";
  let jpn = "こんにちは世界！";
  let mix = "Hello, 你好，こんにちは世界！123Hi";
  use_str(eng);
  use_str(chn);
  use_str(jpn);
  use_str(mix);
}


================================================
FILE: test/mutable_slice_range.rs
================================================
fn test(x: &mut [u8]) -> u8 {
    x[0]
}

fn main() {
    let mut x = [ 0; 8 ];
    let result = test(&mut x[..]);
    let expected = 0;
    assert_eq!(result, expected);
}


================================================
FILE: test/names.rs
================================================
struct Foo { x: u32, y: u32 }
enum Baz { Foo(u32, u32), Bar(u32) }
struct Type {
  switch : i32,
  class : i32,
}
fn f(r#struct: u32){ let r#class = 0; }
fn main() {}


================================================
FILE: test/nested_arrays.rs
================================================
type Key = [ u32; 8 ];
const ZERO: Key = [ 0, 1, 2, 3, 4, 5, 6, 7 ];

fn test() -> [[u8; 200]; 4] {
    let mut out0 = [0u8; 200];
    let mut out1 = [0u8; 200];
    let mut out2 = [0u8; 200];
    let mut out3 = [0u8; 200];
    [out0, out1, out2, out3]
}

fn main() {
    let keys = [ [ ZERO; 3 ]; 3 ];
    for i in 0..3 {
        for j in 0..3 {
            for k in 0..8 {
                let actual = keys[i][j][k];
                let expected = k as u32;
                assert_eq!(actual, expected);
            }
        }
    }
}


================================================
FILE: test/nested_arrays2.rs
================================================
const TABLE: [[u8; 1]; 1] = [[1]];

fn main() {
}


================================================
FILE: test/option.rs
================================================
type Val = [u8; 16];
struct S {
    v: Option<Val>,
}
impl S {
    fn option_ref(&self) -> Option<&Val> {
        self.v.as_ref()
    }
}

fn main(){}


================================================
FILE: test/parentparent.rs
================================================
trait A: B {
}

trait B: C {
}

trait C {
    fn foo(&mut self);
}

fn f<U: A> (mut x: U) {
    x.foo()
}

fn main() {}


================================================
FILE: test/partial_eq.rs
================================================
#[derive(PartialEq, Debug)]
#[repr(u32)]
pub enum Enum { A = 0 }

fn main() {
    let expected = Enum::A;
    assert_eq!(expected, expected);
    assert_eq!(&expected, &expected);
}


================================================
FILE: test/partial_eq_stubs.c
================================================
#include "partial_eq.h"

extern core_result_Result_10
core_fmt__core__fmt__Formatter__a___write_str(core_fmt_Formatter *x0, Eurydice_dst_ref_shared_0d x1) {
  return core_result_Ok;
}


================================================
FILE: test/println.rs
================================================
fn main() {
    println!("What is up");
    let x = [0; 4];
    println!("x[0] is: {}", x[0]);
}


================================================
FILE: test/raw_pointers.rs
================================================
fn main() {
    let mut x = 0u8;
    let mut px = &mut x as *mut u8 as *const u8;
    unsafe {
        assert_eq!(0u8, *px);
    }
}


================================================
FILE: test/reborrow.rs
================================================
fn main() {
  let mut x = 0u8;
  let mut px = &mut x as *mut u8 as *const u8;
  unsafe {
    assert_eq!(0u8, *px);
    // Reborrow the pointer
    let py = &*px;
    assert_eq!(0u8, *py);
  }

  let val = 0u8;
  let b = Box::new(val);
  let pb = &*b;
  unsafe {
    assert_eq!(0u8, *pb);
    // Reborrow the pointer
    let pb2 = &*pb;
    assert_eq!(0u8, *pb2);
  }
}

================================================
FILE: test/recursion.rs
================================================
fn is_odd(y: i32) -> bool {
   if y < 0 { return is_odd(-y); }
   match y {
       0 => false,
       1 => true,
       y => is_odd(y - 2)
   }
}

fn main() {
    assert!(is_odd(5));
}


================================================
FILE: test/repeat.rs
================================================
const C1: [u32; 1] = [0u32; 1];
const C2: [[u32; 1]; 1] = [[0u32; 1]; 1];

const REJECTION_SAMPLE_SHUFFLE_TABLE: [[u8; 16]; 256] = [
    [
        0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
        0xff,
    ],
    [
        0, 1, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0xff, 0xff, 0xff, 0xff],
    [
        12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 0xff, 0xff, 0xff, 0xff],
    [
        10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 0xff, 0xff],
    [
        14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 15, 0xff, 0xff, 0xff, 0xff],
    [
        10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 14, 15, 0xff, 0xff],
    [
        12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 0xff, 0xff],
    [
        10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 4, 5, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 15, 0xff, 0xff],
    [
        8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 2, 3, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff],
    [
        6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        0, 1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [
        2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 2, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff],
    [
        4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff, 0xff, 0xff,
    ],
    [0, 1, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff],
    [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 0xff, 0xff],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15],
];

fn main() { if C1[0] + C2[0][0] + REJECTION_SAMPLE_SHUFFLE_TABLE[255][0] as u32 != 0 { panic!("oh noes") } }


================================================
FILE: test/result.rs
================================================
enum S {
    S1 { x1: u32, y1: u32 },
    S2 { x2: u32, y2: u32  }
}

fn mk1(x: u32, y: u32) -> S {
    S::S1 { x1: x, y1: y }
}

fn ident(x: S) -> S { x }

fn main() {
    match mk1(0, 0) {
        S::S1 { x1 : 0, y1 : 0 } => (),
        _ => panic!("oh noes")
    };
    match ident(S::S2 { x2: 0, y2: 0 }) {
        S::S2 { x2 : 0, y2 : 0 } => (),
        _ => panic!("oh noes")
    }
}


================================================
FILE: test/signed_wrapping.rs
================================================
fn main() {
    // i8 wrapping operations
    assert_eq!(100i8.wrapping_add(27), 127);
    assert_eq!(100i8.wrapping_add(100), -56);
    assert_eq!((-128i8).wrapping_add(-1), 127);

    assert_eq!(10i8.wrapping_sub(20), -10);
    assert_eq!((-128i8).wrapping_sub(1), 127);
    assert_eq!(127i8.wrapping_sub(-1), -128);

    assert_eq!(10i8.wrapping_mul(5), 50);
    assert_eq!(100i8.wrapping_mul(2), -56);
    assert_eq!((-128i8).wrapping_mul(-1), -128);

    assert_eq!(5i8.wrapping_neg(), -5);
    assert_eq!((-128i8).wrapping_neg(), -128);

    // i16 wrapping operations
    assert_eq!(30000i16.wrapping_add(2768), -32768);
    assert_eq!((-32768i16).wrapping_add(-1), 32767);

    assert_eq!((-32768i16).wrapping_sub(1), 32767);
    assert_eq!(32767i16.wrapping_sub(-1), -32768);

    assert_eq!(200i16.wrapping_mul(200), -25536);
    assert_eq!((-32768i16).wrapping_mul(-1), -32768);

    assert_eq!(5i16.wrapping_neg(), -5);
    assert_eq!((-32768i16).wrapping_neg(), -32768);

    // i32 wrapping operations
    assert_eq!(2_000_000_000i32.wrapping_add(2_000_000_000), -294967296);
    assert_eq!((-2_147_483_648i32).wrapping_add(-1), 2_147_483_647);

    assert_eq!((-2_147_483_648i32).wrapping_sub(1), 2_147_483_647);
    assert_eq!(2_147_483_647i32.wrapping_sub(-1), -2_147_483_648);

    assert_eq!(100_000i32.wrapping_mul(100_000), 1_410_065_408);
    assert_eq!((-2_147_483_648i32).wrapping_mul(-1), -2_147_483_648);

    assert_eq!(5i32.wrapping_neg(), -5);
    assert_eq!((-2_147_483_648i32).wrapping_neg(), -2_147_483_648);

    // i64 wrapping operations
    assert_eq!(
        5_000_000_000_000_000_000i64.wrapping_add(5_000_000_000_000_000_000),
        -8_446_744_073_709_551_616
    );
    assert_eq!((-9_223_372_036_854_775_808i64).wrapping_add(-1), 9_223_372_036_854_775_807);

    assert_eq!((-9_223_372_036_854_775_808i64).wrapping_sub(1), 9_223_372_036_854_775_807);
    assert_eq!(9_223_372_036_854_775_807i64.wrapping_sub(-1), -9_223_372_036_854_775_808);

    assert_eq!(
        3_000_000_000i64.wrapping_mul(3_000_000_000),
        9_000_000_000_000_000_000
    );
    assert_eq!((-9_223_372_036_854_775_808i64).wrapping_mul(-1), -9_223_372_036_854_775_808);

    assert_eq!(5i64.wrapping_neg(), -5);
    assert_eq!((-9_223_372_036_854_775_808i64).wrapping_neg(), -9_223_372_036_854_775_808);
}


================================================
FILE: test/slice_array.rs
================================================
fn f1() {
    let mut x = [[0u8; 4]; 4];
    let (y0, _y1) = x.split_at_mut(2);
    y0[0][0] = 1;
    let actual = x[0][0];
    let expected = 1;
    assert_eq!(actual, expected);
}

fn f4<const K: usize>() {
    let mut x = [[0u8; K]; K];
    let (y0, _y1) = x.split_at_mut(2);
    y0[0][0] = 1;
    let actual = x[0][0];
    let expected = 1;
    assert_eq!(actual, expected);
}

fn f2() {
    let mut x = [[0u8; 4]; 4];
    let (y0, _y1) = x.split_at_mut(2);
    // generates a copy
    let mut z = y0[0];
    z[0] = 1;
    let actual = x[0][0];
    let expected = 0;
    assert_eq!(actual, expected);
    assert_eq!(z[0],1);
}

use std::convert::TryInto;
fn f3() {
    let x1 : &[u8] = &[0u8;4];
    let y1 : [u8;4] = x1.try_into().unwrap();
    
    let x2 : &[u8] = &[0u8;4];
    let y2 : &[u8;4] = x2.try_into().unwrap();
    
    let x3 : &mut [u8] = &mut [0u8;4];
    let y3 : [u8;4] = x3.try_into().unwrap();
    
    assert_eq!(y1[0],y2[0]);
    assert_eq!(y1[0],y3[0]);
}

fn f5<const K:usize>() {
    let x1 : &[u8] = &[0u8;K];
    let y1 : [u8;K] = x1.try_into().unwrap();
    
    let x2 : &[u8] = [0u8;K].as_slice();
    let y2 : &[u8;K] = x2.try_into().unwrap();
    
    assert_eq!(y1[0],y2[0]);
}

fn main() {
    f1();
    f2();
    f3();
    f4::<4>();
    f5::<4>();
}


================================================
FILE: test/step_by.rs
================================================
fn bar() {
    let mut i = 0;
    for j in (0..24).step_by(6) {
        i = i + j;
    }
    assert_eq!(i, 36);
}

fn main1() {
    bar();
    let mut i = 0;
    for j in (0..24).step_by(6) {
        i = i + j;
    }
    for j in (0..24).step_by(6) {
        i = i + j;
    }
}

fn main2() {
    main1();
    for j in (0..24).step_by(6) {
    }
    for j in (0..24).step_by(6) {
    }
}

fn main() {
    main2();
    for j in 0..24 {
    }
    for j in 0..24 {
    }
}


================================================
FILE: test/substr.rs
================================================
fn main() {
  let str = "abc";
  let take = &str[1..];
  assert!(take.len() == 2);
}


================================================
FILE: test/substr.yaml
================================================
files:
  - name: substr
    include_in_h: [ "\"substr_stubs.h\"" ]
    api:
      patterns:
        - [ substr, "*" ]
      exact:
        - [ core, str, "{str}", len ]
    private:
      - [ "*" ]



================================================
FILE: test/substr_impl.c
================================================
#include "substr.h"

size_t core_str__str__len(Eurydice_dst_ref_shared_0d x0) {
  return x0.meta;
}


================================================
FILE: test/substr_stubs.h
================================================
#define core_str_traits__core__ops__index__Index_I__Clause1_Output__for_str__index(_0, _1, _2, _3, _4, _5, str, start, _t0, _t1, t) \
  ((t){ .ptr = str.ptr + start, .meta = str.meta - start })


================================================
FILE: test/symcrust.rs
================================================
#[allow(non_snake_case)]
#[no_mangle]
pub fn SymCrustMlKemPolyElementCompressAndEncode(
    coeffs:              &[u16; 256],
    nBitsPerCoefficient: u32,
    dst:                 &mut [u8] )
{
    let SYMCRYPT_MLKEM_COMPRESS_MULCONSTANT : u64 = 0x9d7dbb;
    let SYMCRYPT_MLKEM_COMPRESS_SHIFTCONSTANT : u32 = 35;
    let mut multiplication: u64;
    let mut coefficient: u32;
    let mut nBitsInCoefficient: u32;
    let mut bitsToEncode: u32;
    let mut nBitsToEncode: u32;
    let mut cbDstWritten: usize = 0;
    let mut accumulator: u32 = 0;
    let mut nBitsInAccumulator: u32 = 0;

    assert!(nBitsPerCoefficient > 0);
    assert!(nBitsPerCoefficient <= 12);
    assert!( dst.len() as u64 == (256*u64::from(nBitsPerCoefficient) / 8) );

    for i in 0..256
    {
        nBitsInCoefficient = nBitsPerCoefficient;
        coefficient = u32::from(coeffs[i]); // in range [0, Q-1]

        // first compress the coefficient
        // when nBitsPerCoefficient < 12 we compress per Compress_d in draft FIPS 203;
        if nBitsPerCoefficient < 12
        {
            // Multiply by 2^(nBitsPerCoefficient+1) / Q by multiplying by constant and shifting right
            multiplication = u64::from(coefficient) * SYMCRYPT_MLKEM_COMPRESS_MULCONSTANT;
            coefficient = (multiplication >> (SYMCRYPT_MLKEM_COMPRESS_SHIFTCONSTANT-(nBitsPerCoefficient+1))) as u32;

            // add "half" to round to nearest integer
            coefficient += 1;

            // final divide by two to get multiplication by 2^nBitsPerCoefficient / Q
            coefficient >>= 1;                              // in range [0, 2^nBitsPerCoefficient]

            // modular reduction by masking
            coefficient &= (1u32<<nBitsPerCoefficient)-1;    // in range [0, 2^nBitsPerCoefficient - 1]
        }

        // encode the coefficient
        // simple loop to add bits to accumulator and write accumulator to output
        while nBitsInCoefficient > 0
        {
            nBitsToEncode = nBitsInCoefficient.min(32-nBitsInAccumulator);

            bitsToEncode = coefficient & ((1u32<<nBitsToEncode)-1);
            coefficient >>= nBitsToEncode;
            nBitsInCoefficient -= nBitsToEncode;

            accumulator |= bitsToEncode << nBitsInAccumulator;
            nBitsInAccumulator += nBitsToEncode;
            if nBitsInAccumulator == 32
            {
                dst[cbDstWritten..cbDstWritten+4].copy_from_slice( &accumulator.to_le_bytes() );
                cbDstWritten += 4;
                accumulator = 0;
                nBitsInAccumulator = 0;
            }
        }
    }
}

fn main() {
    // let mut dst = [0; 256];
    // SymCrustMlKemPolyElementCompressAndEncode(&[0; 256], 1, &mut dst);
}


================================================
FILE: test/trait_generics.rs
================================================
struct Foo<const K: usize>;

trait MyFnOnce {
    fn call_once(self) -> u32;
}

impl<const K: usize> MyFnOnce for Foo<K> {
    fn call_once(self) -> u32 {
        0
    }
}

fn from_fn<F>(f: F)
where
    F: MyFnOnce,
{
    f.call_once();
}

fn main() {
    from_fn(Foo::<10>);
}


================================================
FILE: test/traits.rs
================================================
enum Foo { Foo1, Foo2 }

trait ToInt {
    fn to_int(&self) -> u32;
}

impl ToInt for Foo {
    fn to_int(&self) -> u32 {
        match self {
          | Foo::Foo1 => 1,
          | Foo::Foo2 => 2
        }
    }
}

impl ToInt for &[Foo] {
    fn to_int(&self) -> u32 {
        self[0].to_int() * self[1].to_int()
    }
}

fn main() {
    let foos = [Foo::Foo1, Foo::Foo2];
    // TODO: [..] (full range)
    // TODO: assert_eq -- interesting pattern where some intermediary computations need to be
    // allocated
    // assert_eq!((&foos[0..2]).to_int(), 2u32);
    if (&foos[0..2]).to_int() != 2u32 {
        panic!();
    }
}


================================================
FILE: test/traits2.rs
================================================
pub trait Operations: Copy + Clone {
    fn zero() -> Self;
    fn from_i16_array(array: &[i16]) -> Self;
}

pub(crate) struct PolynomialRingElement<Vector: Operations> {
    pub(crate) coefficients: [Vector; 16],
}

fn re_zero<Vector: Operations>() -> PolynomialRingElement<Vector> {
    PolynomialRingElement {
        coefficients: [Vector::zero(); 16],
    }
}

fn re_from_i16_array<Vector: Operations>(a: &[i16]) -> PolynomialRingElement<Vector> {
    let mut result = re_zero();
    for i in 0..16 {
        result.coefficients[i] = Vector::from_i16_array(&a[i * 16..(i + 1) * 16]);
    }
    result
}

impl<Vector: Operations> PolynomialRingElement<Vector> {
    pub(crate) fn zero() -> Self {
        re_zero()
    }
    pub fn from_i16_array(a: &[i16]) -> Self {
        re_from_i16_array(a)
    }
}

fn sample_from_xof<const K: usize, Vector: Operations>() -> [PolynomialRingElement<Vector>; K] {

    let mut out: [[i16; 272]; K] = [[0; 272]; K];
    out.map(|s| PolynomialRingElement::<Vector>::from_i16_array(&s[0..256]))
}

fn main() {}


================================================
FILE: test/traits3.rs
================================================
pub trait KeccakStateItem<const N: usize>: internal::KeccakItem<N> {}

impl<const N: usize, T: internal::KeccakItem<N>> KeccakStateItem<N> for T {}

pub(crate) mod internal {
    /// A trait for multiplexing implementations.
    pub trait KeccakItem<const N: usize>: Clone + Copy {
        fn zero() -> Self;
    }
}

pub(crate) fn keccak<const N: usize, T: KeccakStateItem<N>>(
) {
}

type uint64x2_t = (u64,u64);

impl internal::KeccakItem<2> for uint64x2_t {
    fn zero() -> Self {
        (0, 0)
    }
}

fn keccakx2() {
    keccak::<2, uint64x2_t>()
}

fn main() {}


================================================
FILE: test/we_need_charon_monomorphization.rs
================================================
fn use_ref<T : ?Sized>(_t : &T) { }
fn supply_ref(s: &[i32]) { use_ref(s) }
fn main() { supply_ref(&[1,2,3]) }


================================================
FILE: test/where_clauses.rs
================================================
trait Mul2 {
    fn mul2 (x: Self) -> Self;
    fn add (x: Self, y: Self) -> Self;
}

trait MyImpl<T: Mul2> {
    fn mul4 (x: T, y: T) -> T {
        T::add(T::mul2(x), T::mul2(y))
    }
}

struct Foo { }

impl Mul2 for u64 {
    fn mul2(x: u64) -> u64 { x << 2 }
    fn add(x: u64, y: u64) -> u64 { x + y }
}

impl MyImpl<u64> for Foo {
}

fn main() {
    let x = Foo::mul4(0u64, 0u64);
    assert_eq!(x, 0u64);
}


================================================
FILE: test/where_clauses_closures.rs
================================================
trait Ops<const K: usize> {
    fn zero() -> Self;
    fn of_usize(x: usize) -> Self;
}

impl Ops<1> for usize {
    fn zero() -> Self { 0 }
    fn of_usize(x: usize) -> Self { x.into() }
}

fn test<const K:usize, T: Ops<K>+Copy>() -> (T, T) {
    let x: [ T; 1 ] = core::array::from_fn(|i| T::of_usize(i));
    let y = T::zero();
    (x[0], y)
}

fn main() { let (x, y) = test::<1,usize>(); assert_eq!(x, y); }


================================================
FILE: test/where_clauses_fncg.rs
================================================
trait Foo<const K: usize> {
    fn bar<const L: usize>(x: [[u8; L]; K], y: [[u8; K]; L]) -> Self;
}

impl<const K: usize> Foo<K> for u64 {
    fn bar<const L: usize>(x: [[u8; L]; K], _: [[u8; K]; L]) -> Self {
        x[0][0].into()
    }
}

fn f<const K: usize, const L: usize, const M: usize, T: Foo<L>>() -> T {
    T::bar([[0; 4]; L], [[0; L]; 4])
}

trait UseFoo {
    fn method_foo<const K: usize, T: Foo<K>>() -> T;
}

impl UseFoo for () {
    fn method_foo<const K: usize, T: Foo<K>>() -> T {
        T::bar([[0; 4]; K], [[0; K]; 4])
    }
}

fn g<Scheme: UseFoo>() -> u64 {
    Scheme::method_foo::<12, u64>()
}

fn main() {
    let r = f::<6, 8, 10, u64>();
    assert_eq!(r, 0);

    let r = g::<()>();
    assert_eq!(r, 0);
}


================================================
FILE: test/where_clauses_simple.rs
================================================
// The difficulty with implementing traits as dictionaries is the mismatch in terms of const
// generics (types are less of an issue somewhat).

// In this trait decl, method signatures (as found in the trait_decl) are all parametric over K
trait Ops<const K: usize> {
    // usize -> Self -> Self -> Self
    fn add (x: [u16; K], y: Self) -> Self;
    // usize -> u16 -> Self
    fn of_u16 (x: u16) -> Self;
}

// Here, however, the signatures in this trait impl are NOT parametric over K
impl Ops<1> for u64 {
    // [u16; 1] -> u64 -> u64
    fn add (x: [u16; 1], y: u64) -> u64 { Into::<u64>::into(x[0]) + y }
    // u16 -> u64
    fn of_u16 (x: u16) -> u64 { x.into() }
}

impl<const K: usize> Ops<K> for usize {
    // usize -> [u16; 1] -> usize -> usize
    fn add (x: [u16; K], y: usize) -> usize { Into::<usize>::into(x[0]) + y + K }
    // usize -> u16 -> usize
    fn of_u16 (x: u16) -> usize { x.into() }
}

fn fn_k<const K: usize, T: Ops<K>>() -> T {
    // NO CONST GENERICS PROVIDED AT THIS CALL-SITE
    // The call sites only have the the method-level const generics.
    let x = T::of_u16(0);
    T::add([0; K], x)
}

fn fn_1<T: Ops<1>+Copy>() -> T {
    // NO CONST GENERICS PROVIDED AT THIS CALL-SITE
    let x = T::of_u16(0);
    T::add([0; 1], x)
}

fn k_calls_k() {
    // fn_k receives an add function that starts with size_t -> ... (for the impl-level const
    // generic)
    let r = fn_k::<3, usize>();
    let r_expected = 3;
    assert_eq!(r, r_expected);
}

fn k_calls_one() {
    // fn_k receives an add function that DOES NOT start with size_t -> ...
    let r = fn_k::<1, u64>();
    let r_expected = 0;
    assert_eq!(r, r_expected);
}

fn one_calls_k() {
    let r = fn_1::<usize>();
    let r_expected = 1;
    assert_eq!(r, r_expected);
}

fn one_calls_one() {
    let r = fn_1::<u64>();
    let r_expected = 0;
    assert_eq!(r, r_expected);
}

fn double<T: Ops<1> + Copy, U: Ops<1>+Copy> (x: T, y: U) -> (T, U) {
    (T::add([0; 1], x), U::add([0; 1], y))
}

fn double_k<const K: usize, T: Ops<K> + Copy, U: Ops<1>+Copy> (x: T, y: U) -> (T, U) {
    (T::add([0; K], x), U::add([0; 1], y))
}

fn main() {
    // The four common situations with const generics in bounds.
    k_calls_k();
    k_calls_one();
    one_calls_k();
    one_calls_one();

    // Slightly more involved tests.
    let x = double(1u64, 1usize);
    let y = double_k::<3usize, usize, u64>(1usize, 1u64);
    let x_0 = 1u64;
    let x_1 = 2usize;
    assert_eq!(x.0, x_0);
    assert_eq!(x.1, x_1);
    let y_0 = 4usize;
    let y_1 = 1u64;
    assert_eq!(y.0, y_0);
    assert_eq!(y.1, y_1);
}