/*  $OpenBSD: libcrux_mlkem768_sha3.h,v 1.4 2025/11/13 05:13:06 djm Exp $ */

/* Extracted from libcrux revision 026a87ab6d88ad3626b9fbbf3710d1e0483c1849 */

/*

 * MIT License

 *

 * Copyright (c) 2024 Cryspen

 *

 * 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.

 */

#if !defined(__GNUC__) || (__GNUC__ < 2)

# define __attribute__(x)

#endif

#define KRML_MUSTINLINE inline

#define KRML_NOINLINE __attribute__((noinline, unused))

#define KRML_HOST_EPRINTF(...)

#define KRML_HOST_EXIT(x) fatal_f("internal error")

static inline void

store64_le(uint8_t dst[8], uint64_t src)

{

  dst[0] = src & 0xff;

  dst[1] = (src >> 8) & 0xff;

  dst[2] = (src >> 16) & 0xff;

  dst[3] = (src >> 24) & 0xff;

  dst[4] = (src >> 32) & 0xff;

  dst[5] = (src >> 40) & 0xff;

  dst[6] = (src >> 48) & 0xff;

  dst[7] = (src >> 56) & 0xff;

}

static inline void

store32_le(uint8_t dst[4], uint32_t src)

{

  dst[0] = src & 0xff;

  dst[1] = (src >> 8) & 0xff;

  dst[2] = (src >> 16) & 0xff;

  dst[3] = (src >> 24) & 0xff;

}

static inline void

store32_be(uint8_t dst[4], uint32_t src)

{

  dst[0] = (src >> 24) & 0xff;

  dst[1] = (src >> 16) & 0xff;

  dst[2] = (src >> 8) & 0xff;

  dst[3] = src & 0xff;

}

static inline uint64_t

load64_le(uint8_t src[8])

{

  return (uint64_t)(src[0]) |

      ((uint64_t)(src[1]) << 8) |

      ((uint64_t)(src[2]) << 16) |

      ((uint64_t)(src[3]) << 24) |

      ((uint64_t)(src[4]) << 32) |

      ((uint64_t)(src[5]) << 40) |

      ((uint64_t)(src[6]) << 48) |

      ((uint64_t)(src[7]) << 56);

}

static inline uint32_t

load32_le(uint8_t src[4])

{

  return (uint32_t)(src[0]) |

      ((uint32_t)(src[1]) << 8) |

      ((uint32_t)(src[2]) << 16) |

      ((uint32_t)(src[3]) << 24);

}

#ifdef MISSING_BUILTIN_POPCOUNT

static inline unsigned int

__builtin_popcount(unsigned int num)

{

  const int v[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };

  return v[num & 0xf] + v[(num >> 4) & 0xf];

}

#endif

/* from libcrux/libcrux-ml-kem/extracts/c_header_only/generated/eurydice_glue.h */

#pragma once

#ifdef _MSC_VER

// For __popcnt

#endif

// C++ HELPERS

#if defined(__cplusplus)

#ifndef KRML_HOST_EPRINTF

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

#endif

#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)

// SLICES, ARRAYS, ETC.

// We represent a slice as a pair of an (untyped) pointer, along with the length

// of the slice, i.e. the number of elements in the slice (this is NOT the

// number of bytes). This design choice has two important consequences.

// - if you need to use `ptr`, you MUST cast it to a proper type *before*

//   performing pointer arithmetic on it (remember that C desugars pointer

//   arithmetic based on the type of the address)

// - if you need to use `len` for a C style function (e.g. memcpy, memcmp), you

//   need to multiply it by sizeof t, where t is the type of the elements.

//

// Empty slices have `len == 0` and `ptr` always needs to be a valid pointer

// that is not NULL (otherwise the construction in EURYDICE_SLICE computes `NULL

// + start`).

typedef struct {

  void *ptr;

  size_t len;

} Eurydice_slice;

#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

// Helper macro to create a slice out of a pointer x, a start index in x

// (included), and an end index in x (excluded). The argument x must be suitably

// cast to something that can decay (see remark above about how pointer

// arithmetic works in C), meaning either pointer or array type.

#define EURYDICE_SLICE(x, start, end) \

  (KRML_CLITERAL(Eurydice_slice){(void *)(x + start), end - start})

// Slice length

#define EURYDICE_SLICE_LEN(s, _) (s).len

#define Eurydice_slice_len(s, _) (s).len

// This macro is a pain because in case the dereferenced element type is an

// array, you cannot simply write `t x` as it would yield `int[4] x` instead,

// which is NOT correct C syntax, so we add a dedicated phase in Eurydice that

// adds an extra argument to this macro at the last minute so that we have the

// correct type of *pointers* to elements.

#define Eurydice_slice_index(s, i, t, t_ptr_t) (((t_ptr_t)s.ptr)[i])

// The following functions get sub slices from a slice.

#define Eurydice_slice_subslice(s, r, t, _0, _1) \

  EURYDICE_SLICE((t *)s.ptr, r.start, r.end)

// Variant for when the start and end indices are statically known (i.e., the

// range argument `r` is a literal).

#define Eurydice_slice_subslice2(s, start, end, t) \

  EURYDICE_SLICE((t *)s.ptr, (start), (end))

// Previous version above does not work when t is an array type (as usual). Will

// be deprecated soon.

#define Eurydice_slice_subslice3(s, start, end, t_ptr) \

  EURYDICE_SLICE((t_ptr)s.ptr, (start), (end))

#define Eurydice_slice_subslice_to(s, subslice_end_pos, t, _0, _1) \

  EURYDICE_SLICE((t *)s.ptr, 0, subslice_end_pos)

#define Eurydice_slice_subslice_from(s, subslice_start_pos, t, _0, _1) \

  EURYDICE_SLICE((t *)s.ptr, subslice_start_pos, s.len)

#define Eurydice_array_to_slice(end, x, t) \

  EURYDICE_SLICE(x, 0,                     \

                 end) /* x is already at an array type, no need for cast */

#define Eurydice_array_to_subslice(_arraylen, x, r, t, _0, _1) \

  EURYDICE_SLICE((t *)x, r.start, r.end)

// Same as above, variant for when start and end are statically known

#define Eurydice_array_to_subslice2(x, start, end, t) \

  EURYDICE_SLICE((t *)x, (start), (end))

// Same as above, variant for when start and end are statically known

#define Eurydice_array_to_subslice3(x, start, end, t_ptr) \

  EURYDICE_SLICE((t_ptr)x, (start), (end))

#define Eurydice_array_repeat(dst, len, init, t) \

  ERROR "should've been desugared"

// The following functions convert an array into a slice.

#define Eurydice_array_to_subslice_to(_size, x, r, t, _range_t, _0) \

  EURYDICE_SLICE((t *)x, 0, r)

#define Eurydice_array_to_subslice_from(size, x, r, t, _range_t, _0) \

  EURYDICE_SLICE((t *)x, r, size)

// Copy a slice with memcopy

#define Eurydice_slice_copy(dst, src, t) \

  memcpy(dst.ptr, src.ptr, dst.len * sizeof(t))

#define core_array___Array_T__N___as_slice(len_, ptr_, t, _ret_t) \

  KRML_CLITERAL(Eurydice_slice) { ptr_, len_ }

#define core_array__core__clone__Clone_for__Array_T__N___clone( \

    len, src, dst, elem_type, _ret_t)                           \

  (memcpy(dst, src, len * sizeof(elem_type)))

#define TryFromSliceError uint8_t

#define core_array_TryFromSliceError uint8_t

#define Eurydice_array_eq(sz, a1, a2, t) (memcmp(a1, a2, sz * sizeof(t)) == 0)

// core::cmp::PartialEq<&0 (@Slice<U>)> for @Array<T, N>

#define Eurydice_array_eq_slice(sz, a1, s2, t, _) \

  (memcmp(a1, (s2)->ptr, sz * sizeof(t)) == 0)

#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___3__eq( \

    sz, a1, a2, t, _, _ret_t)                                                               \

  Eurydice_array_eq(sz, a1, ((a2)->ptr), t, _)

#define Eurydice_slice_split_at(slice, mid, element_type, ret_t)          \

  KRML_CLITERAL(ret_t) {                                                  \

    EURYDICE_CFIELD(.fst =)                                               \

    EURYDICE_SLICE((element_type *)(slice).ptr, 0, mid),                  \

        EURYDICE_CFIELD(.snd =)                                           \

            EURYDICE_SLICE((element_type *)(slice).ptr, mid, (slice).len) \

  }

#define Eurydice_slice_split_at_mut(slice, mid, element_type, ret_t)  \

  KRML_CLITERAL(ret_t) {                                              \

    EURYDICE_CFIELD(.fst =)                                           \

    KRML_CLITERAL(Eurydice_slice){EURYDICE_CFIELD(.ptr =)(slice.ptr), \

                                  EURYDICE_CFIELD(.len =) mid},       \

        EURYDICE_CFIELD(.snd =) KRML_CLITERAL(Eurydice_slice) {       \

      EURYDICE_CFIELD(.ptr =)                                         \

      ((char *)slice.ptr + mid * sizeof(element_type)),               \

          EURYDICE_CFIELD(.len =)(slice.len - 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_array2(dst, src, _0, t_arr, _1)                 \

  Eurydice_slice_to_array3(&(dst)->tag, (char *)&(dst)->val.case_Ok, src, \

                           sizeof(t_arr))

static inline void Eurydice_slice_to_array3(uint8_t *dst_tag, char *dst_ok,

                                            Eurydice_slice src, size_t sz) {

  *dst_tag = 0;

  memcpy(dst_ok, src.ptr, sz);

}

// SUPPORT FOR DSTs (Dynamically-Sized Types)

// A DST is a fat pointer that keeps tracks of the size of it flexible array

// member. Slices are a specific case of DSTs, where [T; N] implements

// Unsize<[T]>, meaning an array of statically known size can be converted to a

// fat pointer, i.e. a slice.

//

// Unlike slices, DSTs have a built-in definition that gets monomorphized, of

// the form:

//

// typedef struct {

//   T *ptr;

//   size_t len; // number of elements

// } Eurydice_dst;

//

// Furthermore, T = T0<[U0]> where `struct T0<U: ?Sized>`, where the `U` is the

// last field. This means that there are two monomorphizations of T0 in the

// program. One is `T0<[V; N]>`

// -- this is directly converted to a Eurydice_dst via suitable codegen (no

// macro). The other is `T = T0<[U]>`, where `[U]` gets emitted to

// `Eurydice_derefed_slice`, a type that only appears in that precise situation

// and is thus defined to give rise to a flexible array member.

typedef char Eurydice_derefed_slice[];

#define Eurydice_slice_of_dst(fam_ptr, len_, t, _) \

  ((Eurydice_slice){.ptr = (void *)(fam_ptr), .len = len_})

#define Eurydice_slice_of_boxed_array(ptr_, len_, t, _) \

  ((Eurydice_slice){.ptr = (void *)(ptr_), .len = len_})

// 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

static inline void core_num__u32__to_be_bytes(uint32_t src, uint8_t dst[4]) {

  store32_be(dst, src);

}

static inline void core_num__u32__to_le_bytes(uint32_t src, uint8_t dst[4]) {

  store32_le(dst, src);

}

static inline uint32_t core_num__u32__from_le_bytes(uint8_t buf[4]) {

  return load32_le(buf);

}

static inline void core_num__u64__to_le_bytes(uint64_t v, uint8_t buf[8]) {

  store64_le(buf, v);

}

static inline uint64_t core_num__u64__from_le_bytes(uint8_t buf[8]) {

  return load64_le(buf);

}

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__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 uint16_t core_num__u16__wrapping_add(uint16_t x, uint16_t y) {

  return x + y;

}

static inline uint8_t core_num__u8__wrapping_sub(uint8_t x, uint8_t y) {

  return x - y;

}

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1) {

  return (x0 << x1 | x0 >> (64 - x1));

}

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(uint8_t *p, uint8_t v) {

  return (*p) & v;

}

static inline uint8_t Eurydice_shr_pv_u8(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___a__u8___46__bitand(

    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___a__u8___792__shr(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__26__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___6__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__1__into_iter \

  Eurydice_into_iter

typedef struct {

  Eurydice_slice slice;

  size_t chunk_size;

} Eurydice_chunks;

// Can't use macros Eurydice_slice_subslice_{to,from} because they require a

// type, and this static inline function cannot receive a type as an argument.

// Instead, we receive the element size and use it to peform manual offset

// computations rather than going through the macros.

static inline Eurydice_slice chunk_next(Eurydice_chunks *chunks,

                                        size_t element_size) {

  size_t chunk_size = chunks->slice.len >= chunks->chunk_size

                          ? chunks->chunk_size

                          : chunks->slice.len;

  Eurydice_slice curr_chunk;

  curr_chunk.ptr = chunks->slice.ptr;

  curr_chunk.len = chunk_size;

  chunks->slice.ptr = (char *)(chunks->slice.ptr) + chunk_size * element_size;

  chunks->slice.len = chunks->slice.len - chunk_size;

  return curr_chunk;

}

#define core_slice___Slice_T___chunks(slice_, sz_, t, _ret_t) \

  ((Eurydice_chunks){.slice = slice_, .chunk_size = sz_})

#define core_slice___Slice_T___chunks_exact(slice_, sz_, t, _ret_t)         \

  ((Eurydice_chunks){                                                       \

      .slice = {.ptr = slice_.ptr, .len = slice_.len - (slice_.len % sz_)}, \

      .chunk_size = sz_})

#define core_slice_iter_Chunks Eurydice_chunks

#define core_slice_iter_ChunksExact Eurydice_chunks

#define Eurydice_chunks_next(iter, t, ret_t)                     \

  (((iter)->slice.len == 0) ? ((ret_t){.tag = core_option_None}) \

                            : ((ret_t){.tag = core_option_Some,  \

                                       .f0 = chunk_next(iter, sizeof(t))}))

#define core_slice_iter___core__iter__traits__iterator__Iterator_for_core__slice__iter__Chunks__a__T___70__next \

  Eurydice_chunks_next

// This name changed on 20240627

#define core_slice_iter___core__iter__traits__iterator__Iterator_for_core__slice__iter__Chunks__a__T___71__next \

  Eurydice_chunks_next

#define core_slice_iter__core__slice__iter__ChunksExact__a__T__89__next( \

    iter, t, _ret_t)                                                     \

  core_slice_iter__core__slice__iter__Chunks__a__T__70__next(iter, t)

typedef struct {

  Eurydice_slice s;

  size_t index;

} Eurydice_slice_iterator;

#define core_slice___Slice_T___iter(x, t, _ret_t) \

  ((Eurydice_slice_iterator){.s = x, .index = 0})

#define core_slice_iter_Iter Eurydice_slice_iterator

#define core_slice_iter__core__slice__iter__Iter__a__T__181__next(iter, t, \

                                                                  ret_t)   \

  (((iter)->index == (iter)->s.len)                                        \

       ? (KRML_CLITERAL(ret_t){.tag = core_option_None})                   \

       : (KRML_CLITERAL(ret_t){                                            \

             .tag = core_option_Some,                                      \

             .f0 = ((iter)->index++,                                       \

                    &((t *)((iter)->s.ptr))[(iter)->index - 1])}))

#define core_option__core__option__Option_T__TraitClause_0___is_some(X, _0, \

                                                                     _1)    \

  ((X)->tag == 1)

// STRINGS

typedef const char *Prims_string;

// MISC (UNTESTED)

typedef void *core_fmt_Formatter;

typedef void *core_fmt_Arguments;

typedef void *core_fmt_rt_Argument;

#define core_fmt_rt__core__fmt__rt__Argument__a__1__new_display(x1, x2, x3, \

                                                                x4)         \

  NULL

// BOXES

// Crimes.

static inline char *malloc_and_init(size_t sz, char *init) {

  char *ptr = (char *)malloc(sz);

  memcpy(ptr, init, sz);

  return ptr;

}

#define Eurydice_box_new(init, t, t_dst) \

  ((t_dst)(malloc_and_init(sizeof(t), (char *)(&init))))

#define Eurydice_box_new_array(len, ptr, t, t_dst) \

  ((t_dst)(malloc_and_init(len * sizeof(t), (char *)(ptr))))

/* from libcrux/libcrux-ml-kem/extracts/c_header_only/generated/libcrux_mlkem_core.h */

/*

 * SPDX-FileCopyrightText: 2025 Cryspen Sarl <info@cryspen.com>

 *

 * SPDX-License-Identifier: MIT or Apache-2.0

 *

 * This code was generated with the following revisions:

 * Charon: 667d2fc98984ff7f3df989c2367e6c1fa4a000e7

 * Eurydice: 2381cbc416ef2ad0b561c362c500bc84f36b6785

 * Karamel: 80f5435f2fc505973c469a4afcc8d875cddd0d8b

 * F*: 71d8221589d4d438af3706d89cb653cf53e18aab

 * Libcrux: 68dfed5a4a9e40277f62828471c029afed1ecdcc

 */

#ifndef libcrux_mlkem_core_H

#define libcrux_mlkem_core_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_08_s {

  size_t start;

  size_t end;

} core_ops_range_Range_08;

static inline uint16_t core_num__u16__wrapping_add(uint16_t x0, uint16_t x1);

static inline uint64_t core_num__u64__from_le_bytes(uint8_t x0[8U]);

static inline uint64_t core_num__u64__rotate_left(uint64_t x0, uint32_t x1);

static inline void core_num__u64__to_le_bytes(uint64_t x0, uint8_t x1[8U]);

static inline uint32_t core_num__u8__count_ones(uint8_t x0);

static inline uint8_t core_num__u8__wrapping_sub(uint8_t x0, uint8_t x1);

#define LIBCRUX_ML_KEM_CONSTANTS_SHARED_SECRET_SIZE ((size_t)32U)

#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_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)

#define LIBCRUX_ML_KEM_CONSTANTS_G_DIGEST_SIZE ((size_t)64U)

#define LIBCRUX_ML_KEM_CONSTANTS_H_DIGEST_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.

*/

static inline 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

libcrux_secrets_int_public_integers_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

*/

static KRML_MUSTINLINE 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}

*/

static KRML_MUSTINLINE uint8_t libcrux_secrets_int_as_u8_f5(int16_t self) {

  return libcrux_secrets_int_public_integers_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

*/

static KRML_MUSTINLINE 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

libcrux_secrets_int_public_integers_declassify_d8_90(uint8_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u8}

*/

static KRML_MUSTINLINE int16_t libcrux_secrets_int_as_i16_59(uint8_t self) {

  return libcrux_secrets_int_public_integers_classify_27_39(

      (int16_t)libcrux_secrets_int_public_integers_declassify_d8_90(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 int32_t

*/

static KRML_MUSTINLINE int32_t

libcrux_secrets_int_public_integers_classify_27_a8(int32_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for i16}

*/

static KRML_MUSTINLINE int32_t libcrux_secrets_int_as_i32_f5(int16_t self) {

  return libcrux_secrets_int_public_integers_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

libcrux_secrets_int_public_integers_declassify_d8_a8(int32_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for i32}

*/

static KRML_MUSTINLINE int16_t libcrux_secrets_int_as_i16_36(int32_t self) {

  return libcrux_secrets_int_public_integers_classify_27_39(

      (int16_t)libcrux_secrets_int_public_integers_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

libcrux_secrets_int_public_integers_declassify_d8_df(uint32_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u32}

*/

static KRML_MUSTINLINE int32_t libcrux_secrets_int_as_i32_b8(uint32_t self) {

  return libcrux_secrets_int_public_integers_classify_27_a8(

      (int32_t)libcrux_secrets_int_public_integers_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

libcrux_secrets_int_public_integers_classify_27_de(uint16_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for i16}

*/

static KRML_MUSTINLINE uint16_t libcrux_secrets_int_as_u16_f5(int16_t self) {

  return libcrux_secrets_int_public_integers_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

libcrux_secrets_int_public_integers_declassify_d8_de(uint16_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u16}

*/

static KRML_MUSTINLINE int16_t libcrux_secrets_int_as_i16_ca(uint16_t self) {

  return libcrux_secrets_int_public_integers_classify_27_39(

      (int16_t)libcrux_secrets_int_public_integers_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

libcrux_secrets_int_public_integers_classify_27_49(uint64_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u16}

*/

static KRML_MUSTINLINE uint64_t libcrux_secrets_int_as_u64_ca(uint16_t self) {

  return libcrux_secrets_int_public_integers_classify_27_49(

      (uint64_t)libcrux_secrets_int_public_integers_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

*/

static KRML_MUSTINLINE 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

libcrux_secrets_int_public_integers_declassify_d8_49(uint64_t self) {

  return self;

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u64}

*/

static KRML_MUSTINLINE uint32_t libcrux_secrets_int_as_u32_a3(uint64_t self) {

  return libcrux_secrets_int_public_integers_classify_27_df(

      (uint32_t)libcrux_secrets_int_public_integers_declassify_d8_49(self));

}

/**

This function found in impl {libcrux_secrets::int::CastOps for u32}

*/

static KRML_MUSTINLINE int16_t libcrux_secrets_int_as_i16_b8(uint32_t self) {

  return libcrux_secrets_int_public_integers_classify_27_39(

      (int16_t)libcrux_secrets_int_public_integers_declassify_d8_df(self));

}

/**

This function found in impl {libcrux_secrets::int::CastOps for i16}

*/

static KRML_MUSTINLINE 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));

}

typedef struct libcrux_ml_kem_utils_extraction_helper_Keypair768_s {

  uint8_t fst[1152U];

  uint8_t snd[1184U];

} libcrux_ml_kem_utils_extraction_helper_Keypair768;

#define Ok 0

#define Err 1

typedef uint8_t Result_b2_tags;

/**

A monomorphic instance of core.result.Result

with types uint8_t[24size_t], core_array_TryFromSliceError

*/

typedef struct Result_b2_s {

  Result_b2_tags tag;

  union {

    uint8_t case_Ok[24U];

    TryFromSliceError case_Err;

  } val;

} Result_b2;

/**

This function found in impl {core::result::Result<T, E>[TraitClause@0,

TraitClause@1]}

*/

/**

A monomorphic instance of core.result.unwrap_26

with types uint8_t[24size_t], core_array_TryFromSliceError

*/

static inline void unwrap_26_70(Result_b2 self, uint8_t ret[24U]) {

  if (self.tag == Ok) {

    uint8_t f0[24U];

    memcpy(f0, self.val.case_Ok, (size_t)24U * sizeof(uint8_t));

    memcpy(ret, f0, (size_t)24U * sizeof(uint8_t));

  } 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 core.result.Result

with types uint8_t[20size_t], core_array_TryFromSliceError

*/

typedef struct Result_e1_s {

  Result_b2_tags tag;

  union {

    uint8_t case_Ok[20U];

    TryFromSliceError case_Err;

  } val;

} Result_e1;

/**

This function found in impl {core::result::Result<T, E>[TraitClause@0,

TraitClause@1]}

*/

/**

A monomorphic instance of core.result.unwrap_26

with types uint8_t[20size_t], core_array_TryFromSliceError

*/

static inline void unwrap_26_20(Result_e1 self, uint8_t ret[20U]) {

  if (self.tag == Ok) {

    uint8_t f0[20U];

    memcpy(f0, self.val.case_Ok, (size_t)20U * sizeof(uint8_t));

    memcpy(ret, f0, (size_t)20U * sizeof(uint8_t));

  } else {

    KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__,

                      "unwrap not Ok");

    KRML_HOST_EXIT(255U);

  }

}

/**

 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

*/

static KRML_MUSTINLINE void libcrux_ml_kem_utils_into_padded_array_9e(

    Eurydice_slice slice, uint8_t ret[32U]) {

  uint8_t out[32U] = {0U};

  uint8_t *uu____0 = out;

  Eurydice_slice_copy(

      Eurydice_array_to_subslice3(

          uu____0, (size_t)0U, Eurydice_slice_len(slice, uint8_t), uint8_t *),

      slice, uint8_t);

  memcpy(ret, out, (size_t)32U * sizeof(uint8_t));

}

/**

A monomorphic instance of libcrux_ml_kem.types.MlKemPrivateKey

with const generics

- $2400size_t

*/

typedef struct libcrux_ml_kem_types_MlKemPrivateKey_d9_s {

  uint8_t value[2400U];

} libcrux_ml_kem_types_MlKemPrivateKey_d9;

/**

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

*/

static inline libcrux_ml_kem_types_MlKemPrivateKey_d9

libcrux_ml_kem_types_default_d3_28(void) {

  return (

      KRML_CLITERAL(libcrux_ml_kem_types_MlKemPrivateKey_d9){.value = {0U}});

}

/**

A monomorphic instance of libcrux_ml_kem.types.MlKemPublicKey

with const generics

- $1184size_t

*/

typedef struct libcrux_ml_kem_types_MlKemPublicKey_30_s {

  uint8_t value[1184U];

} libcrux_ml_kem_types_MlKemPublicKey_30;

/**

This function found in impl {core::convert::From<@Array<u8, SIZE>> for

libcrux_ml_kem::types::MlKemPublicKey<SIZE>}

*/

/**

A monomorphic instance of libcrux_ml_kem.types.from_fd

with const generics

- SIZE= 1184

*/

static inline libcrux_ml_kem_types_MlKemPublicKey_30

libcrux_ml_kem_types_from_fd_d0(uint8_t value[1184U]) {

  /* Passing arrays by value in Rust generates a copy in C */

  uint8_t copy_of_value[1184U];

  memcpy(copy_of_value, value, (size_t)1184U * sizeof(uint8_t));

  libcrux_ml_kem_types_MlKemPublicKey_30 lit;

  memcpy(lit.value, copy_of_value, (size_t)1184U * sizeof(uint8_t));

  return lit;

}

typedef struct libcrux_ml_kem_mlkem768_MlKem768KeyPair_s {

  libcrux_ml_kem_types_MlKemPrivateKey_d9 sk;

  libcrux_ml_kem_types_MlKemPublicKey_30 pk;

} libcrux_ml_kem_mlkem768_MlKem768KeyPair;

/**

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

*/

static inline libcrux_ml_kem_mlkem768_MlKem768KeyPair

libcrux_ml_kem_types_from_17_74(libcrux_ml_kem_types_MlKemPrivateKey_d9 sk,

                                libcrux_ml_kem_types_MlKemPublicKey_30 pk) {

  return (KRML_CLITERAL(libcrux_ml_kem_mlkem768_MlKem768KeyPair){.sk = sk,

                                                                 .pk = pk});

}