libcrux_sha3_portable.c (130083B)
1 /* 2 * SPDX-FileCopyrightText: 2025 Cryspen Sarl <info@cryspen.com> 3 * 4 * SPDX-License-Identifier: MIT or Apache-2.0 5 * 6 * This code was generated with the following revisions: 7 * Charon: 667d2fc98984ff7f3df989c2367e6c1fa4a000e7 8 * Eurydice: 2381cbc416ef2ad0b561c362c500bc84f36b6785 9 * Karamel: 80f5435f2fc505973c469a4afcc8d875cddd0d8b 10 * F*: 71d8221589d4d438af3706d89cb653cf53e18aab 11 * Libcrux: 68dfed5a4a9e40277f62828471c029afed1ecdcc 12 */ 13 14 #include "libcrux_sha3_portable.h" 15 16 #include "internal/libcrux_core.h" 17 #include "libcrux_core.h" 18 #include "libcrux_sha3_internal.h" 19 20 /** 21 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 22 */ 23 KRML_MUSTINLINE uint64_t 24 libcrux_sha3_simd_portable_zero_d2(void) 25 { 26 return 0ULL; 27 } 28 29 KRML_MUSTINLINE uint64_t 30 libcrux_sha3_simd_portable__veor5q_u64( 31 uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e) 32 { 33 return (((a ^ b) ^ c) ^ d) ^ e; 34 } 35 36 /** 37 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 38 */ 39 KRML_MUSTINLINE uint64_t 40 libcrux_sha3_simd_portable_xor5_d2( 41 uint64_t a, uint64_t b, uint64_t c, uint64_t d, uint64_t e) 42 { 43 return libcrux_sha3_simd_portable__veor5q_u64(a, b, c, d, e); 44 } 45 46 /** 47 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 48 with const generics 49 - LEFT= 1 50 - RIGHT= 63 51 */ 52 KRML_MUSTINLINE uint64_t 53 libcrux_sha3_simd_portable_rotate_left_76(uint64_t x) 54 { 55 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)1); 56 } 57 58 KRML_MUSTINLINE uint64_t 59 libcrux_sha3_simd_portable__vrax1q_u64(uint64_t a, 60 uint64_t b) 61 { 62 uint64_t uu____0 = a; 63 return uu____0 ^ libcrux_sha3_simd_portable_rotate_left_76(b); 64 } 65 66 /** 67 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 68 */ 69 KRML_MUSTINLINE uint64_t 70 libcrux_sha3_simd_portable_rotate_left1_and_xor_d2(uint64_t a, uint64_t b) 71 { 72 return libcrux_sha3_simd_portable__vrax1q_u64(a, b); 73 } 74 75 KRML_MUSTINLINE uint64_t 76 libcrux_sha3_simd_portable__vbcaxq_u64(uint64_t a, 77 uint64_t b, 78 uint64_t c) 79 { 80 return a ^ (b & ~c); 81 } 82 83 /** 84 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 85 */ 86 KRML_MUSTINLINE uint64_t 87 libcrux_sha3_simd_portable_and_not_xor_d2(uint64_t a, 88 uint64_t b, 89 uint64_t c) 90 { 91 return libcrux_sha3_simd_portable__vbcaxq_u64(a, b, c); 92 } 93 94 KRML_MUSTINLINE uint64_t 95 libcrux_sha3_simd_portable__veorq_n_u64(uint64_t a, 96 uint64_t c) 97 { 98 return a ^ c; 99 } 100 101 /** 102 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 103 */ 104 KRML_MUSTINLINE uint64_t 105 libcrux_sha3_simd_portable_xor_constant_d2(uint64_t a, uint64_t c) 106 { 107 return libcrux_sha3_simd_portable__veorq_n_u64(a, c); 108 } 109 110 /** 111 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 112 */ 113 KRML_MUSTINLINE uint64_t 114 libcrux_sha3_simd_portable_xor_d2(uint64_t a, 115 uint64_t b) 116 { 117 return a ^ b; 118 } 119 120 const uint64_t libcrux_sha3_generic_keccak_constants_ROUNDCONSTANTS[24U] = { 121 1ULL, 122 32898ULL, 123 9223372036854808714ULL, 124 9223372039002292224ULL, 125 32907ULL, 126 2147483649ULL, 127 9223372039002292353ULL, 128 9223372036854808585ULL, 129 138ULL, 130 136ULL, 131 2147516425ULL, 132 2147483658ULL, 133 2147516555ULL, 134 9223372036854775947ULL, 135 9223372036854808713ULL, 136 9223372036854808579ULL, 137 9223372036854808578ULL, 138 9223372036854775936ULL, 139 32778ULL, 140 9223372039002259466ULL, 141 9223372039002292353ULL, 142 9223372036854808704ULL, 143 2147483649ULL, 144 9223372039002292232ULL 145 }; 146 147 /** 148 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 149 N>[TraitClause@0, TraitClause@1]} 150 */ 151 /** 152 A monomorphic instance of libcrux_sha3.generic_keccak.new_80 153 with types uint64_t 154 with const generics 155 - N= 1 156 */ 157 KRML_MUSTINLINE libcrux_sha3_generic_keccak_KeccakState_17 158 libcrux_sha3_generic_keccak_new_80_04(void) 159 { 160 libcrux_sha3_generic_keccak_KeccakState_17 lit; 161 uint64_t repeat_expression[25U]; 162 for (size_t i = (size_t)0U; i < (size_t)25U; i++) { 163 repeat_expression[i] = libcrux_sha3_simd_portable_zero_d2(); 164 } 165 memcpy(lit.st, repeat_expression, (size_t)25U * sizeof(uint64_t)); 166 return lit; 167 } 168 169 /** 170 A monomorphic instance of libcrux_sha3.traits.get_ij 171 with types uint64_t 172 with const generics 173 - N= 1 174 */ 175 KRML_MUSTINLINE uint64_t * 176 libcrux_sha3_traits_get_ij_04(uint64_t *arr, size_t i, 177 size_t j) 178 { 179 return &arr[(size_t)5U * j + i]; 180 } 181 182 /** 183 A monomorphic instance of libcrux_sha3.traits.set_ij 184 with types uint64_t 185 with const generics 186 - N= 1 187 */ 188 KRML_MUSTINLINE void 189 libcrux_sha3_traits_set_ij_04(uint64_t *arr, size_t i, 190 size_t j, uint64_t value) 191 { 192 arr[(size_t)5U * j + i] = value; 193 } 194 195 /** 196 A monomorphic instance of libcrux_sha3.simd.portable.load_block 197 with const generics 198 - RATE= 72 199 */ 200 KRML_MUSTINLINE void 201 libcrux_sha3_simd_portable_load_block_f8( 202 uint64_t *state, Eurydice_slice blocks, size_t start) 203 { 204 uint64_t state_flat[25U] = { 0U }; 205 for (size_t i = (size_t)0U; i < (size_t)72U / (size_t)8U; i++) { 206 size_t i0 = i; 207 size_t offset = start + (size_t)8U * i0; 208 uint8_t uu____0[8U]; 209 core_result_Result_15 dst; 210 Eurydice_slice_to_array2( 211 &dst, 212 Eurydice_slice_subslice3(blocks, offset, offset + (size_t)8U, 213 uint8_t *), 214 Eurydice_slice, uint8_t[8U], core_array_TryFromSliceError); 215 core_result_unwrap_26_68(dst, uu____0); 216 state_flat[i0] = core_num__u64__from_le_bytes(uu____0); 217 } 218 for (size_t i = (size_t)0U; i < (size_t)72U / (size_t)8U; i++) { 219 size_t i0 = i; 220 libcrux_sha3_traits_set_ij_04( 221 state, i0 / (size_t)5U, i0 % (size_t)5U, 222 libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, 223 i0 % (size_t)5U)[0U] ^ 224 state_flat[i0]); 225 } 226 } 227 228 /** 229 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 230 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 231 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 232 u64}]} 233 */ 234 /** 235 A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1 236 with const generics 237 - RATE= 72 238 */ 239 void 240 libcrux_sha3_simd_portable_load_block_a1_f8( 241 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 242 size_t start) 243 { 244 libcrux_sha3_simd_portable_load_block_f8(self->st, input[0U], start); 245 } 246 247 /** 248 This function found in impl {core::ops::index::Index<(usize, usize), T> for 249 libcrux_sha3::generic_keccak::KeccakState<T, N>[TraitClause@0, TraitClause@1]} 250 */ 251 /** 252 A monomorphic instance of libcrux_sha3.generic_keccak.index_c2 253 with types uint64_t 254 with const generics 255 - N= 1 256 */ 257 uint64_t * 258 libcrux_sha3_generic_keccak_index_c2_04( 259 libcrux_sha3_generic_keccak_KeccakState_17 *self, size_t_x2 index) 260 { 261 return libcrux_sha3_traits_get_ij_04(self->st, index.fst, index.snd); 262 } 263 264 /** 265 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 266 N>[TraitClause@0, TraitClause@1]} 267 */ 268 /** 269 A monomorphic instance of libcrux_sha3.generic_keccak.theta_80 270 with types uint64_t 271 with const generics 272 - N= 1 273 */ 274 KRML_MUSTINLINE void 275 libcrux_sha3_generic_keccak_theta_80_04( 276 libcrux_sha3_generic_keccak_KeccakState_17 *self, uint64_t ret[5U]) 277 { 278 uint64_t c[5U] = { 279 libcrux_sha3_simd_portable_xor5_d2( 280 libcrux_sha3_generic_keccak_index_c2_04( 281 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 282 .snd = (size_t)0U }))[0U], 283 libcrux_sha3_generic_keccak_index_c2_04( 284 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 285 .snd = (size_t)0U }))[0U], 286 libcrux_sha3_generic_keccak_index_c2_04( 287 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 288 .snd = (size_t)0U }))[0U], 289 libcrux_sha3_generic_keccak_index_c2_04( 290 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 291 .snd = (size_t)0U }))[0U], 292 libcrux_sha3_generic_keccak_index_c2_04( 293 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 294 .snd = (size_t)0U }))[0U]), 295 libcrux_sha3_simd_portable_xor5_d2( 296 libcrux_sha3_generic_keccak_index_c2_04( 297 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 298 .snd = (size_t)1U }))[0U], 299 libcrux_sha3_generic_keccak_index_c2_04( 300 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 301 .snd = (size_t)1U }))[0U], 302 libcrux_sha3_generic_keccak_index_c2_04( 303 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 304 .snd = (size_t)1U }))[0U], 305 libcrux_sha3_generic_keccak_index_c2_04( 306 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 307 .snd = (size_t)1U }))[0U], 308 libcrux_sha3_generic_keccak_index_c2_04( 309 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 310 .snd = (size_t)1U }))[0U]), 311 libcrux_sha3_simd_portable_xor5_d2( 312 libcrux_sha3_generic_keccak_index_c2_04( 313 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 314 .snd = (size_t)2U }))[0U], 315 libcrux_sha3_generic_keccak_index_c2_04( 316 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 317 .snd = (size_t)2U }))[0U], 318 libcrux_sha3_generic_keccak_index_c2_04( 319 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 320 .snd = (size_t)2U }))[0U], 321 libcrux_sha3_generic_keccak_index_c2_04( 322 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 323 .snd = (size_t)2U }))[0U], 324 libcrux_sha3_generic_keccak_index_c2_04( 325 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 326 .snd = (size_t)2U }))[0U]), 327 libcrux_sha3_simd_portable_xor5_d2( 328 libcrux_sha3_generic_keccak_index_c2_04( 329 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 330 .snd = (size_t)3U }))[0U], 331 libcrux_sha3_generic_keccak_index_c2_04( 332 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 333 .snd = (size_t)3U }))[0U], 334 libcrux_sha3_generic_keccak_index_c2_04( 335 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 336 .snd = (size_t)3U }))[0U], 337 libcrux_sha3_generic_keccak_index_c2_04( 338 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 339 .snd = (size_t)3U }))[0U], 340 libcrux_sha3_generic_keccak_index_c2_04( 341 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 342 .snd = (size_t)3U }))[0U]), 343 libcrux_sha3_simd_portable_xor5_d2( 344 libcrux_sha3_generic_keccak_index_c2_04( 345 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 346 .snd = (size_t)4U }))[0U], 347 libcrux_sha3_generic_keccak_index_c2_04( 348 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 349 .snd = (size_t)4U }))[0U], 350 libcrux_sha3_generic_keccak_index_c2_04( 351 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 352 .snd = (size_t)4U }))[0U], 353 libcrux_sha3_generic_keccak_index_c2_04( 354 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 355 .snd = (size_t)4U }))[0U], 356 libcrux_sha3_generic_keccak_index_c2_04( 357 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 358 .snd = (size_t)4U }))[0U]) 359 }; 360 uint64_t uu____0 = libcrux_sha3_simd_portable_rotate_left1_and_xor_d2( 361 c[((size_t)0U + (size_t)4U) % (size_t)5U], 362 c[((size_t)0U + (size_t)1U) % (size_t)5U]); 363 uint64_t uu____1 = libcrux_sha3_simd_portable_rotate_left1_and_xor_d2( 364 c[((size_t)1U + (size_t)4U) % (size_t)5U], 365 c[((size_t)1U + (size_t)1U) % (size_t)5U]); 366 uint64_t uu____2 = libcrux_sha3_simd_portable_rotate_left1_and_xor_d2( 367 c[((size_t)2U + (size_t)4U) % (size_t)5U], 368 c[((size_t)2U + (size_t)1U) % (size_t)5U]); 369 uint64_t uu____3 = libcrux_sha3_simd_portable_rotate_left1_and_xor_d2( 370 c[((size_t)3U + (size_t)4U) % (size_t)5U], 371 c[((size_t)3U + (size_t)1U) % (size_t)5U]); 372 ret[0U] = uu____0; 373 ret[1U] = uu____1; 374 ret[2U] = uu____2; 375 ret[3U] = uu____3; 376 ret[4U] = libcrux_sha3_simd_portable_rotate_left1_and_xor_d2( 377 c[((size_t)4U + (size_t)4U) % (size_t)5U], 378 c[((size_t)4U + (size_t)1U) % (size_t)5U]); 379 } 380 381 /** 382 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 383 N>[TraitClause@0, TraitClause@1]} 384 */ 385 /** 386 A monomorphic instance of libcrux_sha3.generic_keccak.set_80 387 with types uint64_t 388 with const generics 389 - N= 1 390 */ 391 void 392 libcrux_sha3_generic_keccak_set_80_04( 393 libcrux_sha3_generic_keccak_KeccakState_17 *self, size_t i, size_t j, 394 uint64_t v) 395 { 396 libcrux_sha3_traits_set_ij_04(self->st, i, j, v); 397 } 398 399 /** 400 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 401 with const generics 402 - LEFT= 36 403 - RIGHT= 28 404 */ 405 KRML_MUSTINLINE uint64_t 406 libcrux_sha3_simd_portable_rotate_left_02(uint64_t x) 407 { 408 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)36); 409 } 410 411 /** 412 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 413 with const generics 414 - LEFT= 36 415 - RIGHT= 28 416 */ 417 KRML_MUSTINLINE uint64_t 418 libcrux_sha3_simd_portable__vxarq_u64_02(uint64_t a, 419 uint64_t b) 420 { 421 return libcrux_sha3_simd_portable_rotate_left_02(a ^ b); 422 } 423 424 /** 425 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 426 */ 427 /** 428 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 429 with const generics 430 - LEFT= 36 431 - RIGHT= 28 432 */ 433 KRML_MUSTINLINE uint64_t 434 libcrux_sha3_simd_portable_xor_and_rotate_d2_02(uint64_t a, uint64_t b) 435 { 436 return libcrux_sha3_simd_portable__vxarq_u64_02(a, b); 437 } 438 439 /** 440 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 441 with const generics 442 - LEFT= 3 443 - RIGHT= 61 444 */ 445 KRML_MUSTINLINE uint64_t 446 libcrux_sha3_simd_portable_rotate_left_ac(uint64_t x) 447 { 448 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)3); 449 } 450 451 /** 452 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 453 with const generics 454 - LEFT= 3 455 - RIGHT= 61 456 */ 457 KRML_MUSTINLINE uint64_t 458 libcrux_sha3_simd_portable__vxarq_u64_ac(uint64_t a, 459 uint64_t b) 460 { 461 return libcrux_sha3_simd_portable_rotate_left_ac(a ^ b); 462 } 463 464 /** 465 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 466 */ 467 /** 468 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 469 with const generics 470 - LEFT= 3 471 - RIGHT= 61 472 */ 473 KRML_MUSTINLINE uint64_t 474 libcrux_sha3_simd_portable_xor_and_rotate_d2_ac(uint64_t a, uint64_t b) 475 { 476 return libcrux_sha3_simd_portable__vxarq_u64_ac(a, b); 477 } 478 479 /** 480 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 481 with const generics 482 - LEFT= 41 483 - RIGHT= 23 484 */ 485 KRML_MUSTINLINE uint64_t 486 libcrux_sha3_simd_portable_rotate_left_020(uint64_t x) 487 { 488 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)41); 489 } 490 491 /** 492 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 493 with const generics 494 - LEFT= 41 495 - RIGHT= 23 496 */ 497 KRML_MUSTINLINE uint64_t 498 libcrux_sha3_simd_portable__vxarq_u64_020(uint64_t a, 499 uint64_t b) 500 { 501 return libcrux_sha3_simd_portable_rotate_left_020(a ^ b); 502 } 503 504 /** 505 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 506 */ 507 /** 508 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 509 with const generics 510 - LEFT= 41 511 - RIGHT= 23 512 */ 513 KRML_MUSTINLINE uint64_t 514 libcrux_sha3_simd_portable_xor_and_rotate_d2_020(uint64_t a, uint64_t b) 515 { 516 return libcrux_sha3_simd_portable__vxarq_u64_020(a, b); 517 } 518 519 /** 520 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 521 with const generics 522 - LEFT= 18 523 - RIGHT= 46 524 */ 525 KRML_MUSTINLINE uint64_t 526 libcrux_sha3_simd_portable_rotate_left_a9(uint64_t x) 527 { 528 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)18); 529 } 530 531 /** 532 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 533 with const generics 534 - LEFT= 18 535 - RIGHT= 46 536 */ 537 KRML_MUSTINLINE uint64_t 538 libcrux_sha3_simd_portable__vxarq_u64_a9(uint64_t a, 539 uint64_t b) 540 { 541 return libcrux_sha3_simd_portable_rotate_left_a9(a ^ b); 542 } 543 544 /** 545 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 546 */ 547 /** 548 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 549 with const generics 550 - LEFT= 18 551 - RIGHT= 46 552 */ 553 KRML_MUSTINLINE uint64_t 554 libcrux_sha3_simd_portable_xor_and_rotate_d2_a9(uint64_t a, uint64_t b) 555 { 556 return libcrux_sha3_simd_portable__vxarq_u64_a9(a, b); 557 } 558 559 /** 560 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 561 with const generics 562 - LEFT= 1 563 - RIGHT= 63 564 */ 565 KRML_MUSTINLINE uint64_t 566 libcrux_sha3_simd_portable__vxarq_u64_76(uint64_t a, 567 uint64_t b) 568 { 569 return libcrux_sha3_simd_portable_rotate_left_76(a ^ b); 570 } 571 572 /** 573 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 574 */ 575 /** 576 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 577 with const generics 578 - LEFT= 1 579 - RIGHT= 63 580 */ 581 KRML_MUSTINLINE uint64_t 582 libcrux_sha3_simd_portable_xor_and_rotate_d2_76(uint64_t a, uint64_t b) 583 { 584 return libcrux_sha3_simd_portable__vxarq_u64_76(a, b); 585 } 586 587 /** 588 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 589 with const generics 590 - LEFT= 44 591 - RIGHT= 20 592 */ 593 KRML_MUSTINLINE uint64_t 594 libcrux_sha3_simd_portable_rotate_left_58(uint64_t x) 595 { 596 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)44); 597 } 598 599 /** 600 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 601 with const generics 602 - LEFT= 44 603 - RIGHT= 20 604 */ 605 KRML_MUSTINLINE uint64_t 606 libcrux_sha3_simd_portable__vxarq_u64_58(uint64_t a, 607 uint64_t b) 608 { 609 return libcrux_sha3_simd_portable_rotate_left_58(a ^ b); 610 } 611 612 /** 613 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 614 */ 615 /** 616 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 617 with const generics 618 - LEFT= 44 619 - RIGHT= 20 620 */ 621 KRML_MUSTINLINE uint64_t 622 libcrux_sha3_simd_portable_xor_and_rotate_d2_58(uint64_t a, uint64_t b) 623 { 624 return libcrux_sha3_simd_portable__vxarq_u64_58(a, b); 625 } 626 627 /** 628 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 629 with const generics 630 - LEFT= 10 631 - RIGHT= 54 632 */ 633 KRML_MUSTINLINE uint64_t 634 libcrux_sha3_simd_portable_rotate_left_e0(uint64_t x) 635 { 636 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)10); 637 } 638 639 /** 640 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 641 with const generics 642 - LEFT= 10 643 - RIGHT= 54 644 */ 645 KRML_MUSTINLINE uint64_t 646 libcrux_sha3_simd_portable__vxarq_u64_e0(uint64_t a, 647 uint64_t b) 648 { 649 return libcrux_sha3_simd_portable_rotate_left_e0(a ^ b); 650 } 651 652 /** 653 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 654 */ 655 /** 656 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 657 with const generics 658 - LEFT= 10 659 - RIGHT= 54 660 */ 661 KRML_MUSTINLINE uint64_t 662 libcrux_sha3_simd_portable_xor_and_rotate_d2_e0(uint64_t a, uint64_t b) 663 { 664 return libcrux_sha3_simd_portable__vxarq_u64_e0(a, b); 665 } 666 667 /** 668 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 669 with const generics 670 - LEFT= 45 671 - RIGHT= 19 672 */ 673 KRML_MUSTINLINE uint64_t 674 libcrux_sha3_simd_portable_rotate_left_63(uint64_t x) 675 { 676 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)45); 677 } 678 679 /** 680 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 681 with const generics 682 - LEFT= 45 683 - RIGHT= 19 684 */ 685 KRML_MUSTINLINE uint64_t 686 libcrux_sha3_simd_portable__vxarq_u64_63(uint64_t a, 687 uint64_t b) 688 { 689 return libcrux_sha3_simd_portable_rotate_left_63(a ^ b); 690 } 691 692 /** 693 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 694 */ 695 /** 696 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 697 with const generics 698 - LEFT= 45 699 - RIGHT= 19 700 */ 701 KRML_MUSTINLINE uint64_t 702 libcrux_sha3_simd_portable_xor_and_rotate_d2_63(uint64_t a, uint64_t b) 703 { 704 return libcrux_sha3_simd_portable__vxarq_u64_63(a, b); 705 } 706 707 /** 708 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 709 with const generics 710 - LEFT= 2 711 - RIGHT= 62 712 */ 713 KRML_MUSTINLINE uint64_t 714 libcrux_sha3_simd_portable_rotate_left_6a(uint64_t x) 715 { 716 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)2); 717 } 718 719 /** 720 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 721 with const generics 722 - LEFT= 2 723 - RIGHT= 62 724 */ 725 KRML_MUSTINLINE uint64_t 726 libcrux_sha3_simd_portable__vxarq_u64_6a(uint64_t a, 727 uint64_t b) 728 { 729 return libcrux_sha3_simd_portable_rotate_left_6a(a ^ b); 730 } 731 732 /** 733 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 734 */ 735 /** 736 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 737 with const generics 738 - LEFT= 2 739 - RIGHT= 62 740 */ 741 KRML_MUSTINLINE uint64_t 742 libcrux_sha3_simd_portable_xor_and_rotate_d2_6a(uint64_t a, uint64_t b) 743 { 744 return libcrux_sha3_simd_portable__vxarq_u64_6a(a, b); 745 } 746 747 /** 748 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 749 with const generics 750 - LEFT= 62 751 - RIGHT= 2 752 */ 753 KRML_MUSTINLINE uint64_t 754 libcrux_sha3_simd_portable_rotate_left_ab(uint64_t x) 755 { 756 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)62); 757 } 758 759 /** 760 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 761 with const generics 762 - LEFT= 62 763 - RIGHT= 2 764 */ 765 KRML_MUSTINLINE uint64_t 766 libcrux_sha3_simd_portable__vxarq_u64_ab(uint64_t a, 767 uint64_t b) 768 { 769 return libcrux_sha3_simd_portable_rotate_left_ab(a ^ b); 770 } 771 772 /** 773 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 774 */ 775 /** 776 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 777 with const generics 778 - LEFT= 62 779 - RIGHT= 2 780 */ 781 KRML_MUSTINLINE uint64_t 782 libcrux_sha3_simd_portable_xor_and_rotate_d2_ab(uint64_t a, uint64_t b) 783 { 784 return libcrux_sha3_simd_portable__vxarq_u64_ab(a, b); 785 } 786 787 /** 788 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 789 with const generics 790 - LEFT= 6 791 - RIGHT= 58 792 */ 793 KRML_MUSTINLINE uint64_t 794 libcrux_sha3_simd_portable_rotate_left_5b(uint64_t x) 795 { 796 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)6); 797 } 798 799 /** 800 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 801 with const generics 802 - LEFT= 6 803 - RIGHT= 58 804 */ 805 KRML_MUSTINLINE uint64_t 806 libcrux_sha3_simd_portable__vxarq_u64_5b(uint64_t a, 807 uint64_t b) 808 { 809 return libcrux_sha3_simd_portable_rotate_left_5b(a ^ b); 810 } 811 812 /** 813 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 814 */ 815 /** 816 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 817 with const generics 818 - LEFT= 6 819 - RIGHT= 58 820 */ 821 KRML_MUSTINLINE uint64_t 822 libcrux_sha3_simd_portable_xor_and_rotate_d2_5b(uint64_t a, uint64_t b) 823 { 824 return libcrux_sha3_simd_portable__vxarq_u64_5b(a, b); 825 } 826 827 /** 828 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 829 with const generics 830 - LEFT= 43 831 - RIGHT= 21 832 */ 833 KRML_MUSTINLINE uint64_t 834 libcrux_sha3_simd_portable_rotate_left_6f(uint64_t x) 835 { 836 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)43); 837 } 838 839 /** 840 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 841 with const generics 842 - LEFT= 43 843 - RIGHT= 21 844 */ 845 KRML_MUSTINLINE uint64_t 846 libcrux_sha3_simd_portable__vxarq_u64_6f(uint64_t a, 847 uint64_t b) 848 { 849 return libcrux_sha3_simd_portable_rotate_left_6f(a ^ b); 850 } 851 852 /** 853 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 854 */ 855 /** 856 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 857 with const generics 858 - LEFT= 43 859 - RIGHT= 21 860 */ 861 KRML_MUSTINLINE uint64_t 862 libcrux_sha3_simd_portable_xor_and_rotate_d2_6f(uint64_t a, uint64_t b) 863 { 864 return libcrux_sha3_simd_portable__vxarq_u64_6f(a, b); 865 } 866 867 /** 868 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 869 with const generics 870 - LEFT= 15 871 - RIGHT= 49 872 */ 873 KRML_MUSTINLINE uint64_t 874 libcrux_sha3_simd_portable_rotate_left_62(uint64_t x) 875 { 876 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)15); 877 } 878 879 /** 880 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 881 with const generics 882 - LEFT= 15 883 - RIGHT= 49 884 */ 885 KRML_MUSTINLINE uint64_t 886 libcrux_sha3_simd_portable__vxarq_u64_62(uint64_t a, 887 uint64_t b) 888 { 889 return libcrux_sha3_simd_portable_rotate_left_62(a ^ b); 890 } 891 892 /** 893 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 894 */ 895 /** 896 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 897 with const generics 898 - LEFT= 15 899 - RIGHT= 49 900 */ 901 KRML_MUSTINLINE uint64_t 902 libcrux_sha3_simd_portable_xor_and_rotate_d2_62(uint64_t a, uint64_t b) 903 { 904 return libcrux_sha3_simd_portable__vxarq_u64_62(a, b); 905 } 906 907 /** 908 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 909 with const generics 910 - LEFT= 61 911 - RIGHT= 3 912 */ 913 KRML_MUSTINLINE uint64_t 914 libcrux_sha3_simd_portable_rotate_left_23(uint64_t x) 915 { 916 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)61); 917 } 918 919 /** 920 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 921 with const generics 922 - LEFT= 61 923 - RIGHT= 3 924 */ 925 KRML_MUSTINLINE uint64_t 926 libcrux_sha3_simd_portable__vxarq_u64_23(uint64_t a, 927 uint64_t b) 928 { 929 return libcrux_sha3_simd_portable_rotate_left_23(a ^ b); 930 } 931 932 /** 933 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 934 */ 935 /** 936 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 937 with const generics 938 - LEFT= 61 939 - RIGHT= 3 940 */ 941 KRML_MUSTINLINE uint64_t 942 libcrux_sha3_simd_portable_xor_and_rotate_d2_23(uint64_t a, uint64_t b) 943 { 944 return libcrux_sha3_simd_portable__vxarq_u64_23(a, b); 945 } 946 947 /** 948 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 949 with const generics 950 - LEFT= 28 951 - RIGHT= 36 952 */ 953 KRML_MUSTINLINE uint64_t 954 libcrux_sha3_simd_portable_rotate_left_37(uint64_t x) 955 { 956 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)28); 957 } 958 959 /** 960 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 961 with const generics 962 - LEFT= 28 963 - RIGHT= 36 964 */ 965 KRML_MUSTINLINE uint64_t 966 libcrux_sha3_simd_portable__vxarq_u64_37(uint64_t a, 967 uint64_t b) 968 { 969 return libcrux_sha3_simd_portable_rotate_left_37(a ^ b); 970 } 971 972 /** 973 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 974 */ 975 /** 976 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 977 with const generics 978 - LEFT= 28 979 - RIGHT= 36 980 */ 981 KRML_MUSTINLINE uint64_t 982 libcrux_sha3_simd_portable_xor_and_rotate_d2_37(uint64_t a, uint64_t b) 983 { 984 return libcrux_sha3_simd_portable__vxarq_u64_37(a, b); 985 } 986 987 /** 988 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 989 with const generics 990 - LEFT= 55 991 - RIGHT= 9 992 */ 993 KRML_MUSTINLINE uint64_t 994 libcrux_sha3_simd_portable_rotate_left_bb(uint64_t x) 995 { 996 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)55); 997 } 998 999 /** 1000 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1001 with const generics 1002 - LEFT= 55 1003 - RIGHT= 9 1004 */ 1005 KRML_MUSTINLINE uint64_t 1006 libcrux_sha3_simd_portable__vxarq_u64_bb(uint64_t a, 1007 uint64_t b) 1008 { 1009 return libcrux_sha3_simd_portable_rotate_left_bb(a ^ b); 1010 } 1011 1012 /** 1013 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1014 */ 1015 /** 1016 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1017 with const generics 1018 - LEFT= 55 1019 - RIGHT= 9 1020 */ 1021 KRML_MUSTINLINE uint64_t 1022 libcrux_sha3_simd_portable_xor_and_rotate_d2_bb(uint64_t a, uint64_t b) 1023 { 1024 return libcrux_sha3_simd_portable__vxarq_u64_bb(a, b); 1025 } 1026 1027 /** 1028 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1029 with const generics 1030 - LEFT= 25 1031 - RIGHT= 39 1032 */ 1033 KRML_MUSTINLINE uint64_t 1034 libcrux_sha3_simd_portable_rotate_left_b9(uint64_t x) 1035 { 1036 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)25); 1037 } 1038 1039 /** 1040 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1041 with const generics 1042 - LEFT= 25 1043 - RIGHT= 39 1044 */ 1045 KRML_MUSTINLINE uint64_t 1046 libcrux_sha3_simd_portable__vxarq_u64_b9(uint64_t a, 1047 uint64_t b) 1048 { 1049 return libcrux_sha3_simd_portable_rotate_left_b9(a ^ b); 1050 } 1051 1052 /** 1053 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1054 */ 1055 /** 1056 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1057 with const generics 1058 - LEFT= 25 1059 - RIGHT= 39 1060 */ 1061 KRML_MUSTINLINE uint64_t 1062 libcrux_sha3_simd_portable_xor_and_rotate_d2_b9(uint64_t a, uint64_t b) 1063 { 1064 return libcrux_sha3_simd_portable__vxarq_u64_b9(a, b); 1065 } 1066 1067 /** 1068 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1069 with const generics 1070 - LEFT= 21 1071 - RIGHT= 43 1072 */ 1073 KRML_MUSTINLINE uint64_t 1074 libcrux_sha3_simd_portable_rotate_left_54(uint64_t x) 1075 { 1076 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)21); 1077 } 1078 1079 /** 1080 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1081 with const generics 1082 - LEFT= 21 1083 - RIGHT= 43 1084 */ 1085 KRML_MUSTINLINE uint64_t 1086 libcrux_sha3_simd_portable__vxarq_u64_54(uint64_t a, 1087 uint64_t b) 1088 { 1089 return libcrux_sha3_simd_portable_rotate_left_54(a ^ b); 1090 } 1091 1092 /** 1093 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1094 */ 1095 /** 1096 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1097 with const generics 1098 - LEFT= 21 1099 - RIGHT= 43 1100 */ 1101 KRML_MUSTINLINE uint64_t 1102 libcrux_sha3_simd_portable_xor_and_rotate_d2_54(uint64_t a, uint64_t b) 1103 { 1104 return libcrux_sha3_simd_portable__vxarq_u64_54(a, b); 1105 } 1106 1107 /** 1108 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1109 with const generics 1110 - LEFT= 56 1111 - RIGHT= 8 1112 */ 1113 KRML_MUSTINLINE uint64_t 1114 libcrux_sha3_simd_portable_rotate_left_4c(uint64_t x) 1115 { 1116 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)56); 1117 } 1118 1119 /** 1120 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1121 with const generics 1122 - LEFT= 56 1123 - RIGHT= 8 1124 */ 1125 KRML_MUSTINLINE uint64_t 1126 libcrux_sha3_simd_portable__vxarq_u64_4c(uint64_t a, 1127 uint64_t b) 1128 { 1129 return libcrux_sha3_simd_portable_rotate_left_4c(a ^ b); 1130 } 1131 1132 /** 1133 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1134 */ 1135 /** 1136 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1137 with const generics 1138 - LEFT= 56 1139 - RIGHT= 8 1140 */ 1141 KRML_MUSTINLINE uint64_t 1142 libcrux_sha3_simd_portable_xor_and_rotate_d2_4c(uint64_t a, uint64_t b) 1143 { 1144 return libcrux_sha3_simd_portable__vxarq_u64_4c(a, b); 1145 } 1146 1147 /** 1148 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1149 with const generics 1150 - LEFT= 27 1151 - RIGHT= 37 1152 */ 1153 KRML_MUSTINLINE uint64_t 1154 libcrux_sha3_simd_portable_rotate_left_ce(uint64_t x) 1155 { 1156 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)27); 1157 } 1158 1159 /** 1160 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1161 with const generics 1162 - LEFT= 27 1163 - RIGHT= 37 1164 */ 1165 KRML_MUSTINLINE uint64_t 1166 libcrux_sha3_simd_portable__vxarq_u64_ce(uint64_t a, 1167 uint64_t b) 1168 { 1169 return libcrux_sha3_simd_portable_rotate_left_ce(a ^ b); 1170 } 1171 1172 /** 1173 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1174 */ 1175 /** 1176 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1177 with const generics 1178 - LEFT= 27 1179 - RIGHT= 37 1180 */ 1181 KRML_MUSTINLINE uint64_t 1182 libcrux_sha3_simd_portable_xor_and_rotate_d2_ce(uint64_t a, uint64_t b) 1183 { 1184 return libcrux_sha3_simd_portable__vxarq_u64_ce(a, b); 1185 } 1186 1187 /** 1188 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1189 with const generics 1190 - LEFT= 20 1191 - RIGHT= 44 1192 */ 1193 KRML_MUSTINLINE uint64_t 1194 libcrux_sha3_simd_portable_rotate_left_77(uint64_t x) 1195 { 1196 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)20); 1197 } 1198 1199 /** 1200 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1201 with const generics 1202 - LEFT= 20 1203 - RIGHT= 44 1204 */ 1205 KRML_MUSTINLINE uint64_t 1206 libcrux_sha3_simd_portable__vxarq_u64_77(uint64_t a, 1207 uint64_t b) 1208 { 1209 return libcrux_sha3_simd_portable_rotate_left_77(a ^ b); 1210 } 1211 1212 /** 1213 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1214 */ 1215 /** 1216 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1217 with const generics 1218 - LEFT= 20 1219 - RIGHT= 44 1220 */ 1221 KRML_MUSTINLINE uint64_t 1222 libcrux_sha3_simd_portable_xor_and_rotate_d2_77(uint64_t a, uint64_t b) 1223 { 1224 return libcrux_sha3_simd_portable__vxarq_u64_77(a, b); 1225 } 1226 1227 /** 1228 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1229 with const generics 1230 - LEFT= 39 1231 - RIGHT= 25 1232 */ 1233 KRML_MUSTINLINE uint64_t 1234 libcrux_sha3_simd_portable_rotate_left_25(uint64_t x) 1235 { 1236 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)39); 1237 } 1238 1239 /** 1240 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1241 with const generics 1242 - LEFT= 39 1243 - RIGHT= 25 1244 */ 1245 KRML_MUSTINLINE uint64_t 1246 libcrux_sha3_simd_portable__vxarq_u64_25(uint64_t a, 1247 uint64_t b) 1248 { 1249 return libcrux_sha3_simd_portable_rotate_left_25(a ^ b); 1250 } 1251 1252 /** 1253 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1254 */ 1255 /** 1256 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1257 with const generics 1258 - LEFT= 39 1259 - RIGHT= 25 1260 */ 1261 KRML_MUSTINLINE uint64_t 1262 libcrux_sha3_simd_portable_xor_and_rotate_d2_25(uint64_t a, uint64_t b) 1263 { 1264 return libcrux_sha3_simd_portable__vxarq_u64_25(a, b); 1265 } 1266 1267 /** 1268 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1269 with const generics 1270 - LEFT= 8 1271 - RIGHT= 56 1272 */ 1273 KRML_MUSTINLINE uint64_t 1274 libcrux_sha3_simd_portable_rotate_left_af(uint64_t x) 1275 { 1276 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)8); 1277 } 1278 1279 /** 1280 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1281 with const generics 1282 - LEFT= 8 1283 - RIGHT= 56 1284 */ 1285 KRML_MUSTINLINE uint64_t 1286 libcrux_sha3_simd_portable__vxarq_u64_af(uint64_t a, 1287 uint64_t b) 1288 { 1289 return libcrux_sha3_simd_portable_rotate_left_af(a ^ b); 1290 } 1291 1292 /** 1293 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1294 */ 1295 /** 1296 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1297 with const generics 1298 - LEFT= 8 1299 - RIGHT= 56 1300 */ 1301 KRML_MUSTINLINE uint64_t 1302 libcrux_sha3_simd_portable_xor_and_rotate_d2_af(uint64_t a, uint64_t b) 1303 { 1304 return libcrux_sha3_simd_portable__vxarq_u64_af(a, b); 1305 } 1306 1307 /** 1308 A monomorphic instance of libcrux_sha3.simd.portable.rotate_left 1309 with const generics 1310 - LEFT= 14 1311 - RIGHT= 50 1312 */ 1313 KRML_MUSTINLINE uint64_t 1314 libcrux_sha3_simd_portable_rotate_left_fd(uint64_t x) 1315 { 1316 return core_num__u64__rotate_left(x, (uint32_t)(int32_t)14); 1317 } 1318 1319 /** 1320 A monomorphic instance of libcrux_sha3.simd.portable._vxarq_u64 1321 with const generics 1322 - LEFT= 14 1323 - RIGHT= 50 1324 */ 1325 KRML_MUSTINLINE uint64_t 1326 libcrux_sha3_simd_portable__vxarq_u64_fd(uint64_t a, 1327 uint64_t b) 1328 { 1329 return libcrux_sha3_simd_portable_rotate_left_fd(a ^ b); 1330 } 1331 1332 /** 1333 This function found in impl {libcrux_sha3::traits::KeccakItem<1usize> for u64} 1334 */ 1335 /** 1336 A monomorphic instance of libcrux_sha3.simd.portable.xor_and_rotate_d2 1337 with const generics 1338 - LEFT= 14 1339 - RIGHT= 50 1340 */ 1341 KRML_MUSTINLINE uint64_t 1342 libcrux_sha3_simd_portable_xor_and_rotate_d2_fd(uint64_t a, uint64_t b) 1343 { 1344 return libcrux_sha3_simd_portable__vxarq_u64_fd(a, b); 1345 } 1346 1347 /** 1348 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1349 N>[TraitClause@0, TraitClause@1]} 1350 */ 1351 /** 1352 A monomorphic instance of libcrux_sha3.generic_keccak.rho_80 1353 with types uint64_t 1354 with const generics 1355 - N= 1 1356 */ 1357 KRML_MUSTINLINE void 1358 libcrux_sha3_generic_keccak_rho_80_04( 1359 libcrux_sha3_generic_keccak_KeccakState_17 *self, uint64_t t[5U]) 1360 { 1361 libcrux_sha3_generic_keccak_set_80_04( 1362 self, (size_t)0U, (size_t)0U, 1363 libcrux_sha3_simd_portable_xor_d2( 1364 libcrux_sha3_generic_keccak_index_c2_04( 1365 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1366 .snd = (size_t)0U }))[0U], 1367 t[0U])); 1368 libcrux_sha3_generic_keccak_KeccakState_17 *uu____0 = self; 1369 libcrux_sha3_generic_keccak_set_80_04( 1370 uu____0, (size_t)1U, (size_t)0U, 1371 libcrux_sha3_simd_portable_xor_and_rotate_d2_02( 1372 libcrux_sha3_generic_keccak_index_c2_04( 1373 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1374 .snd = (size_t)0U }))[0U], 1375 t[0U])); 1376 libcrux_sha3_generic_keccak_KeccakState_17 *uu____1 = self; 1377 libcrux_sha3_generic_keccak_set_80_04( 1378 uu____1, (size_t)2U, (size_t)0U, 1379 libcrux_sha3_simd_portable_xor_and_rotate_d2_ac( 1380 libcrux_sha3_generic_keccak_index_c2_04( 1381 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1382 .snd = (size_t)0U }))[0U], 1383 t[0U])); 1384 libcrux_sha3_generic_keccak_KeccakState_17 *uu____2 = self; 1385 libcrux_sha3_generic_keccak_set_80_04( 1386 uu____2, (size_t)3U, (size_t)0U, 1387 libcrux_sha3_simd_portable_xor_and_rotate_d2_020( 1388 libcrux_sha3_generic_keccak_index_c2_04( 1389 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1390 .snd = (size_t)0U }))[0U], 1391 t[0U])); 1392 libcrux_sha3_generic_keccak_KeccakState_17 *uu____3 = self; 1393 libcrux_sha3_generic_keccak_set_80_04( 1394 uu____3, (size_t)4U, (size_t)0U, 1395 libcrux_sha3_simd_portable_xor_and_rotate_d2_a9( 1396 libcrux_sha3_generic_keccak_index_c2_04( 1397 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1398 .snd = (size_t)0U }))[0U], 1399 t[0U])); 1400 libcrux_sha3_generic_keccak_KeccakState_17 *uu____4 = self; 1401 libcrux_sha3_generic_keccak_set_80_04( 1402 uu____4, (size_t)0U, (size_t)1U, 1403 libcrux_sha3_simd_portable_xor_and_rotate_d2_76( 1404 libcrux_sha3_generic_keccak_index_c2_04( 1405 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1406 .snd = (size_t)1U }))[0U], 1407 t[1U])); 1408 libcrux_sha3_generic_keccak_KeccakState_17 *uu____5 = self; 1409 libcrux_sha3_generic_keccak_set_80_04( 1410 uu____5, (size_t)1U, (size_t)1U, 1411 libcrux_sha3_simd_portable_xor_and_rotate_d2_58( 1412 libcrux_sha3_generic_keccak_index_c2_04( 1413 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1414 .snd = (size_t)1U }))[0U], 1415 t[1U])); 1416 libcrux_sha3_generic_keccak_KeccakState_17 *uu____6 = self; 1417 libcrux_sha3_generic_keccak_set_80_04( 1418 uu____6, (size_t)2U, (size_t)1U, 1419 libcrux_sha3_simd_portable_xor_and_rotate_d2_e0( 1420 libcrux_sha3_generic_keccak_index_c2_04( 1421 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1422 .snd = (size_t)1U }))[0U], 1423 t[1U])); 1424 libcrux_sha3_generic_keccak_KeccakState_17 *uu____7 = self; 1425 libcrux_sha3_generic_keccak_set_80_04( 1426 uu____7, (size_t)3U, (size_t)1U, 1427 libcrux_sha3_simd_portable_xor_and_rotate_d2_63( 1428 libcrux_sha3_generic_keccak_index_c2_04( 1429 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1430 .snd = (size_t)1U }))[0U], 1431 t[1U])); 1432 libcrux_sha3_generic_keccak_KeccakState_17 *uu____8 = self; 1433 libcrux_sha3_generic_keccak_set_80_04( 1434 uu____8, (size_t)4U, (size_t)1U, 1435 libcrux_sha3_simd_portable_xor_and_rotate_d2_6a( 1436 libcrux_sha3_generic_keccak_index_c2_04( 1437 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1438 .snd = (size_t)1U }))[0U], 1439 t[1U])); 1440 libcrux_sha3_generic_keccak_KeccakState_17 *uu____9 = self; 1441 libcrux_sha3_generic_keccak_set_80_04( 1442 uu____9, (size_t)0U, (size_t)2U, 1443 libcrux_sha3_simd_portable_xor_and_rotate_d2_ab( 1444 libcrux_sha3_generic_keccak_index_c2_04( 1445 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1446 .snd = (size_t)2U }))[0U], 1447 t[2U])); 1448 libcrux_sha3_generic_keccak_KeccakState_17 *uu____10 = self; 1449 libcrux_sha3_generic_keccak_set_80_04( 1450 uu____10, (size_t)1U, (size_t)2U, 1451 libcrux_sha3_simd_portable_xor_and_rotate_d2_5b( 1452 libcrux_sha3_generic_keccak_index_c2_04( 1453 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1454 .snd = (size_t)2U }))[0U], 1455 t[2U])); 1456 libcrux_sha3_generic_keccak_KeccakState_17 *uu____11 = self; 1457 libcrux_sha3_generic_keccak_set_80_04( 1458 uu____11, (size_t)2U, (size_t)2U, 1459 libcrux_sha3_simd_portable_xor_and_rotate_d2_6f( 1460 libcrux_sha3_generic_keccak_index_c2_04( 1461 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1462 .snd = (size_t)2U }))[0U], 1463 t[2U])); 1464 libcrux_sha3_generic_keccak_KeccakState_17 *uu____12 = self; 1465 libcrux_sha3_generic_keccak_set_80_04( 1466 uu____12, (size_t)3U, (size_t)2U, 1467 libcrux_sha3_simd_portable_xor_and_rotate_d2_62( 1468 libcrux_sha3_generic_keccak_index_c2_04( 1469 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1470 .snd = (size_t)2U }))[0U], 1471 t[2U])); 1472 libcrux_sha3_generic_keccak_KeccakState_17 *uu____13 = self; 1473 libcrux_sha3_generic_keccak_set_80_04( 1474 uu____13, (size_t)4U, (size_t)2U, 1475 libcrux_sha3_simd_portable_xor_and_rotate_d2_23( 1476 libcrux_sha3_generic_keccak_index_c2_04( 1477 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1478 .snd = (size_t)2U }))[0U], 1479 t[2U])); 1480 libcrux_sha3_generic_keccak_KeccakState_17 *uu____14 = self; 1481 libcrux_sha3_generic_keccak_set_80_04( 1482 uu____14, (size_t)0U, (size_t)3U, 1483 libcrux_sha3_simd_portable_xor_and_rotate_d2_37( 1484 libcrux_sha3_generic_keccak_index_c2_04( 1485 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1486 .snd = (size_t)3U }))[0U], 1487 t[3U])); 1488 libcrux_sha3_generic_keccak_KeccakState_17 *uu____15 = self; 1489 libcrux_sha3_generic_keccak_set_80_04( 1490 uu____15, (size_t)1U, (size_t)3U, 1491 libcrux_sha3_simd_portable_xor_and_rotate_d2_bb( 1492 libcrux_sha3_generic_keccak_index_c2_04( 1493 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1494 .snd = (size_t)3U }))[0U], 1495 t[3U])); 1496 libcrux_sha3_generic_keccak_KeccakState_17 *uu____16 = self; 1497 libcrux_sha3_generic_keccak_set_80_04( 1498 uu____16, (size_t)2U, (size_t)3U, 1499 libcrux_sha3_simd_portable_xor_and_rotate_d2_b9( 1500 libcrux_sha3_generic_keccak_index_c2_04( 1501 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1502 .snd = (size_t)3U }))[0U], 1503 t[3U])); 1504 libcrux_sha3_generic_keccak_KeccakState_17 *uu____17 = self; 1505 libcrux_sha3_generic_keccak_set_80_04( 1506 uu____17, (size_t)3U, (size_t)3U, 1507 libcrux_sha3_simd_portable_xor_and_rotate_d2_54( 1508 libcrux_sha3_generic_keccak_index_c2_04( 1509 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1510 .snd = (size_t)3U }))[0U], 1511 t[3U])); 1512 libcrux_sha3_generic_keccak_KeccakState_17 *uu____18 = self; 1513 libcrux_sha3_generic_keccak_set_80_04( 1514 uu____18, (size_t)4U, (size_t)3U, 1515 libcrux_sha3_simd_portable_xor_and_rotate_d2_4c( 1516 libcrux_sha3_generic_keccak_index_c2_04( 1517 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1518 .snd = (size_t)3U }))[0U], 1519 t[3U])); 1520 libcrux_sha3_generic_keccak_KeccakState_17 *uu____19 = self; 1521 libcrux_sha3_generic_keccak_set_80_04( 1522 uu____19, (size_t)0U, (size_t)4U, 1523 libcrux_sha3_simd_portable_xor_and_rotate_d2_ce( 1524 libcrux_sha3_generic_keccak_index_c2_04( 1525 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1526 .snd = (size_t)4U }))[0U], 1527 t[4U])); 1528 libcrux_sha3_generic_keccak_KeccakState_17 *uu____20 = self; 1529 libcrux_sha3_generic_keccak_set_80_04( 1530 uu____20, (size_t)1U, (size_t)4U, 1531 libcrux_sha3_simd_portable_xor_and_rotate_d2_77( 1532 libcrux_sha3_generic_keccak_index_c2_04( 1533 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1534 .snd = (size_t)4U }))[0U], 1535 t[4U])); 1536 libcrux_sha3_generic_keccak_KeccakState_17 *uu____21 = self; 1537 libcrux_sha3_generic_keccak_set_80_04( 1538 uu____21, (size_t)2U, (size_t)4U, 1539 libcrux_sha3_simd_portable_xor_and_rotate_d2_25( 1540 libcrux_sha3_generic_keccak_index_c2_04( 1541 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1542 .snd = (size_t)4U }))[0U], 1543 t[4U])); 1544 libcrux_sha3_generic_keccak_KeccakState_17 *uu____22 = self; 1545 libcrux_sha3_generic_keccak_set_80_04( 1546 uu____22, (size_t)3U, (size_t)4U, 1547 libcrux_sha3_simd_portable_xor_and_rotate_d2_af( 1548 libcrux_sha3_generic_keccak_index_c2_04( 1549 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1550 .snd = (size_t)4U }))[0U], 1551 t[4U])); 1552 libcrux_sha3_generic_keccak_KeccakState_17 *uu____23 = self; 1553 libcrux_sha3_generic_keccak_set_80_04( 1554 uu____23, (size_t)4U, (size_t)4U, 1555 libcrux_sha3_simd_portable_xor_and_rotate_d2_fd( 1556 libcrux_sha3_generic_keccak_index_c2_04( 1557 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1558 .snd = (size_t)4U }))[0U], 1559 t[4U])); 1560 } 1561 1562 /** 1563 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1564 N>[TraitClause@0, TraitClause@1]} 1565 */ 1566 /** 1567 A monomorphic instance of libcrux_sha3.generic_keccak.pi_80 1568 with types uint64_t 1569 with const generics 1570 - N= 1 1571 */ 1572 KRML_MUSTINLINE void 1573 libcrux_sha3_generic_keccak_pi_80_04( 1574 libcrux_sha3_generic_keccak_KeccakState_17 *self) 1575 { 1576 libcrux_sha3_generic_keccak_KeccakState_17 old = self[0U]; 1577 libcrux_sha3_generic_keccak_set_80_04( 1578 self, (size_t)1U, (size_t)0U, 1579 libcrux_sha3_generic_keccak_index_c2_04( 1580 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1581 .snd = (size_t)3U }))[0U]); 1582 libcrux_sha3_generic_keccak_set_80_04( 1583 self, (size_t)2U, (size_t)0U, 1584 libcrux_sha3_generic_keccak_index_c2_04( 1585 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1586 .snd = (size_t)1U }))[0U]); 1587 libcrux_sha3_generic_keccak_set_80_04( 1588 self, (size_t)3U, (size_t)0U, 1589 libcrux_sha3_generic_keccak_index_c2_04( 1590 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1591 .snd = (size_t)4U }))[0U]); 1592 libcrux_sha3_generic_keccak_set_80_04( 1593 self, (size_t)4U, (size_t)0U, 1594 libcrux_sha3_generic_keccak_index_c2_04( 1595 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1596 .snd = (size_t)2U }))[0U]); 1597 libcrux_sha3_generic_keccak_set_80_04( 1598 self, (size_t)0U, (size_t)1U, 1599 libcrux_sha3_generic_keccak_index_c2_04( 1600 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1601 .snd = (size_t)1U }))[0U]); 1602 libcrux_sha3_generic_keccak_set_80_04( 1603 self, (size_t)1U, (size_t)1U, 1604 libcrux_sha3_generic_keccak_index_c2_04( 1605 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1606 .snd = (size_t)4U }))[0U]); 1607 libcrux_sha3_generic_keccak_set_80_04( 1608 self, (size_t)2U, (size_t)1U, 1609 libcrux_sha3_generic_keccak_index_c2_04( 1610 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1611 .snd = (size_t)2U }))[0U]); 1612 libcrux_sha3_generic_keccak_set_80_04( 1613 self, (size_t)3U, (size_t)1U, 1614 libcrux_sha3_generic_keccak_index_c2_04( 1615 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1616 .snd = (size_t)0U }))[0U]); 1617 libcrux_sha3_generic_keccak_set_80_04( 1618 self, (size_t)4U, (size_t)1U, 1619 libcrux_sha3_generic_keccak_index_c2_04( 1620 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)1U, 1621 .snd = (size_t)3U }))[0U]); 1622 libcrux_sha3_generic_keccak_set_80_04( 1623 self, (size_t)0U, (size_t)2U, 1624 libcrux_sha3_generic_keccak_index_c2_04( 1625 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1626 .snd = (size_t)2U }))[0U]); 1627 libcrux_sha3_generic_keccak_set_80_04( 1628 self, (size_t)1U, (size_t)2U, 1629 libcrux_sha3_generic_keccak_index_c2_04( 1630 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1631 .snd = (size_t)0U }))[0U]); 1632 libcrux_sha3_generic_keccak_set_80_04( 1633 self, (size_t)2U, (size_t)2U, 1634 libcrux_sha3_generic_keccak_index_c2_04( 1635 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1636 .snd = (size_t)3U }))[0U]); 1637 libcrux_sha3_generic_keccak_set_80_04( 1638 self, (size_t)3U, (size_t)2U, 1639 libcrux_sha3_generic_keccak_index_c2_04( 1640 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1641 .snd = (size_t)1U }))[0U]); 1642 libcrux_sha3_generic_keccak_set_80_04( 1643 self, (size_t)4U, (size_t)2U, 1644 libcrux_sha3_generic_keccak_index_c2_04( 1645 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)2U, 1646 .snd = (size_t)4U }))[0U]); 1647 libcrux_sha3_generic_keccak_set_80_04( 1648 self, (size_t)0U, (size_t)3U, 1649 libcrux_sha3_generic_keccak_index_c2_04( 1650 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1651 .snd = (size_t)3U }))[0U]); 1652 libcrux_sha3_generic_keccak_set_80_04( 1653 self, (size_t)1U, (size_t)3U, 1654 libcrux_sha3_generic_keccak_index_c2_04( 1655 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1656 .snd = (size_t)1U }))[0U]); 1657 libcrux_sha3_generic_keccak_set_80_04( 1658 self, (size_t)2U, (size_t)3U, 1659 libcrux_sha3_generic_keccak_index_c2_04( 1660 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1661 .snd = (size_t)4U }))[0U]); 1662 libcrux_sha3_generic_keccak_set_80_04( 1663 self, (size_t)3U, (size_t)3U, 1664 libcrux_sha3_generic_keccak_index_c2_04( 1665 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1666 .snd = (size_t)2U }))[0U]); 1667 libcrux_sha3_generic_keccak_set_80_04( 1668 self, (size_t)4U, (size_t)3U, 1669 libcrux_sha3_generic_keccak_index_c2_04( 1670 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)3U, 1671 .snd = (size_t)0U }))[0U]); 1672 libcrux_sha3_generic_keccak_set_80_04( 1673 self, (size_t)0U, (size_t)4U, 1674 libcrux_sha3_generic_keccak_index_c2_04( 1675 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1676 .snd = (size_t)4U }))[0U]); 1677 libcrux_sha3_generic_keccak_set_80_04( 1678 self, (size_t)1U, (size_t)4U, 1679 libcrux_sha3_generic_keccak_index_c2_04( 1680 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1681 .snd = (size_t)2U }))[0U]); 1682 libcrux_sha3_generic_keccak_set_80_04( 1683 self, (size_t)2U, (size_t)4U, 1684 libcrux_sha3_generic_keccak_index_c2_04( 1685 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1686 .snd = (size_t)0U }))[0U]); 1687 libcrux_sha3_generic_keccak_set_80_04( 1688 self, (size_t)3U, (size_t)4U, 1689 libcrux_sha3_generic_keccak_index_c2_04( 1690 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1691 .snd = (size_t)3U }))[0U]); 1692 libcrux_sha3_generic_keccak_set_80_04( 1693 self, (size_t)4U, (size_t)4U, 1694 libcrux_sha3_generic_keccak_index_c2_04( 1695 &old, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)4U, 1696 .snd = (size_t)1U }))[0U]); 1697 } 1698 1699 /** 1700 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1701 N>[TraitClause@0, TraitClause@1]} 1702 */ 1703 /** 1704 A monomorphic instance of libcrux_sha3.generic_keccak.chi_80 1705 with types uint64_t 1706 with const generics 1707 - N= 1 1708 */ 1709 KRML_MUSTINLINE void 1710 libcrux_sha3_generic_keccak_chi_80_04( 1711 libcrux_sha3_generic_keccak_KeccakState_17 *self) 1712 { 1713 libcrux_sha3_generic_keccak_KeccakState_17 old = self[0U]; 1714 KRML_MAYBE_FOR5( 1715 i0, (size_t)0U, (size_t)5U, (size_t)1U, size_t i1 = i0; KRML_MAYBE_FOR5( 1716 i, (size_t)0U, (size_t)5U, (size_t)1U, size_t j = i; 1717 libcrux_sha3_generic_keccak_set_80_04( 1718 self, i1, j, 1719 libcrux_sha3_simd_portable_and_not_xor_d2( 1720 libcrux_sha3_generic_keccak_index_c2_04( 1721 self, 1722 (KRML_CLITERAL(size_t_x2){ .fst = i1, .snd = j }))[0U], 1723 libcrux_sha3_generic_keccak_index_c2_04( 1724 &old, (KRML_CLITERAL(size_t_x2){ 1725 .fst = i1, 1726 .snd = (j + (size_t)2U) % (size_t)5U }))[0U], 1727 libcrux_sha3_generic_keccak_index_c2_04( 1728 &old, 1729 (KRML_CLITERAL(size_t_x2){ 1730 .fst = i1, 1731 .snd = (j + (size_t)1U) % (size_t)5U }))[0U])););); 1732 } 1733 1734 /** 1735 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1736 N>[TraitClause@0, TraitClause@1]} 1737 */ 1738 /** 1739 A monomorphic instance of libcrux_sha3.generic_keccak.iota_80 1740 with types uint64_t 1741 with const generics 1742 - N= 1 1743 */ 1744 KRML_MUSTINLINE void 1745 libcrux_sha3_generic_keccak_iota_80_04( 1746 libcrux_sha3_generic_keccak_KeccakState_17 *self, size_t i) 1747 { 1748 libcrux_sha3_generic_keccak_set_80_04( 1749 self, (size_t)0U, (size_t)0U, 1750 libcrux_sha3_simd_portable_xor_constant_d2( 1751 libcrux_sha3_generic_keccak_index_c2_04( 1752 self, (KRML_CLITERAL(size_t_x2){ .fst = (size_t)0U, 1753 .snd = (size_t)0U }))[0U], 1754 libcrux_sha3_generic_keccak_constants_ROUNDCONSTANTS[i])); 1755 } 1756 1757 /** 1758 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1759 N>[TraitClause@0, TraitClause@1]} 1760 */ 1761 /** 1762 A monomorphic instance of libcrux_sha3.generic_keccak.keccakf1600_80 1763 with types uint64_t 1764 with const generics 1765 - N= 1 1766 */ 1767 KRML_MUSTINLINE void 1768 libcrux_sha3_generic_keccak_keccakf1600_80_04( 1769 libcrux_sha3_generic_keccak_KeccakState_17 *self) 1770 { 1771 for (size_t i = (size_t)0U; i < (size_t)24U; i++) { 1772 size_t i0 = i; 1773 uint64_t t[5U]; 1774 libcrux_sha3_generic_keccak_theta_80_04(self, t); 1775 libcrux_sha3_generic_keccak_KeccakState_17 *uu____0 = self; 1776 uint64_t uu____1[5U]; 1777 memcpy(uu____1, t, (size_t)5U * sizeof(uint64_t)); 1778 libcrux_sha3_generic_keccak_rho_80_04(uu____0, uu____1); 1779 libcrux_sha3_generic_keccak_pi_80_04(self); 1780 libcrux_sha3_generic_keccak_chi_80_04(self); 1781 libcrux_sha3_generic_keccak_iota_80_04(self, i0); 1782 } 1783 } 1784 1785 /** 1786 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1787 N>[TraitClause@0, TraitClause@1]} 1788 */ 1789 /** 1790 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80 1791 with types uint64_t 1792 with const generics 1793 - N= 1 1794 - RATE= 72 1795 */ 1796 KRML_MUSTINLINE void 1797 libcrux_sha3_generic_keccak_absorb_block_80_c6( 1798 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *blocks, 1799 size_t start) 1800 { 1801 libcrux_sha3_simd_portable_load_block_a1_f8(self, blocks, start); 1802 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 1803 } 1804 1805 /** 1806 A monomorphic instance of libcrux_sha3.simd.portable.load_last 1807 with const generics 1808 - RATE= 72 1809 - DELIMITER= 6 1810 */ 1811 KRML_MUSTINLINE void 1812 libcrux_sha3_simd_portable_load_last_96( 1813 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 1814 { 1815 uint8_t buffer[72U] = { 0U }; 1816 Eurydice_slice_copy( 1817 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 1818 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 1819 buffer[len] = 6U; 1820 size_t uu____0 = (size_t)72U - (size_t)1U; 1821 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 1822 libcrux_sha3_simd_portable_load_block_f8( 1823 state, Eurydice_array_to_slice((size_t)72U, buffer, uint8_t), (size_t)0U); 1824 } 1825 1826 /** 1827 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 1828 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 1829 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 1830 u64}]} 1831 */ 1832 /** 1833 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 1834 with const generics 1835 - RATE= 72 1836 - DELIMITER= 6 1837 */ 1838 void 1839 libcrux_sha3_simd_portable_load_last_a1_96( 1840 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 1841 size_t start, size_t len) 1842 { 1843 libcrux_sha3_simd_portable_load_last_96(self->st, input[0U], start, len); 1844 } 1845 1846 /** 1847 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 1848 N>[TraitClause@0, TraitClause@1]} 1849 */ 1850 /** 1851 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 1852 with types uint64_t 1853 with const generics 1854 - N= 1 1855 - RATE= 72 1856 - DELIM= 6 1857 */ 1858 KRML_MUSTINLINE void 1859 libcrux_sha3_generic_keccak_absorb_final_80_9e( 1860 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 1861 size_t start, size_t len) 1862 { 1863 libcrux_sha3_simd_portable_load_last_a1_96(self, last, start, len); 1864 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 1865 } 1866 1867 /** 1868 A monomorphic instance of libcrux_sha3.simd.portable.store_block 1869 with const generics 1870 - RATE= 72 1871 */ 1872 KRML_MUSTINLINE void 1873 libcrux_sha3_simd_portable_store_block_f8( 1874 uint64_t *s, Eurydice_slice out, size_t start, size_t len) 1875 { 1876 size_t octets = len / (size_t)8U; 1877 for (size_t i = (size_t)0U; i < octets; i++) { 1878 size_t i0 = i; 1879 Eurydice_slice uu____0 = Eurydice_slice_subslice3( 1880 out, start + (size_t)8U * i0, start + (size_t)8U * i0 + (size_t)8U, 1881 uint8_t *); 1882 uint8_t ret[8U]; 1883 core_num__u64__to_le_bytes( 1884 libcrux_sha3_traits_get_ij_04(s, i0 / (size_t)5U, i0 % (size_t)5U)[0U], 1885 ret); 1886 Eurydice_slice_copy( 1887 uu____0, Eurydice_array_to_slice((size_t)8U, ret, uint8_t), uint8_t); 1888 } 1889 size_t remaining = len % (size_t)8U; 1890 if (remaining > (size_t)0U) { 1891 Eurydice_slice uu____1 = Eurydice_slice_subslice3( 1892 out, start + len - remaining, start + len, uint8_t *); 1893 uint8_t ret[8U]; 1894 core_num__u64__to_le_bytes( 1895 libcrux_sha3_traits_get_ij_04(s, octets / (size_t)5U, 1896 octets % (size_t)5U)[0U], 1897 ret); 1898 Eurydice_slice_copy( 1899 uu____1, 1900 Eurydice_array_to_subslice3(ret, (size_t)0U, remaining, uint8_t *), 1901 uint8_t); 1902 } 1903 } 1904 1905 /** 1906 This function found in impl {libcrux_sha3::traits::Squeeze1<u64> for 1907 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 1908 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 1909 u64}]} 1910 */ 1911 /** 1912 A monomorphic instance of libcrux_sha3.simd.portable.squeeze_13 1913 with const generics 1914 - RATE= 72 1915 */ 1916 void 1917 libcrux_sha3_simd_portable_squeeze_13_f8( 1918 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 1919 size_t start, size_t len) 1920 { 1921 libcrux_sha3_simd_portable_store_block_f8(self->st, out, start, len); 1922 } 1923 1924 /** 1925 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 1926 with const generics 1927 - RATE= 72 1928 - DELIM= 6 1929 */ 1930 inline void 1931 libcrux_sha3_generic_keccak_portable_keccak1_96( 1932 Eurydice_slice data, Eurydice_slice out) 1933 { 1934 libcrux_sha3_generic_keccak_KeccakState_17 s = 1935 libcrux_sha3_generic_keccak_new_80_04(); 1936 size_t data_len = Eurydice_slice_len(data, uint8_t); 1937 for (size_t i = (size_t)0U; i < data_len / (size_t)72U; i++) { 1938 size_t i0 = i; 1939 Eurydice_slice buf[1U] = { data }; 1940 libcrux_sha3_generic_keccak_absorb_block_80_c6(&s, buf, i0 * (size_t)72U); 1941 } 1942 size_t rem = data_len % (size_t)72U; 1943 Eurydice_slice buf[1U] = { data }; 1944 libcrux_sha3_generic_keccak_absorb_final_80_9e(&s, buf, data_len - rem, rem); 1945 size_t outlen = Eurydice_slice_len(out, uint8_t); 1946 size_t blocks = outlen / (size_t)72U; 1947 size_t last = outlen - outlen % (size_t)72U; 1948 if (blocks == (size_t)0U) { 1949 libcrux_sha3_simd_portable_squeeze_13_f8(&s, out, (size_t)0U, outlen); 1950 } else { 1951 libcrux_sha3_simd_portable_squeeze_13_f8(&s, out, (size_t)0U, (size_t)72U); 1952 for (size_t i = (size_t)1U; i < blocks; i++) { 1953 size_t i0 = i; 1954 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 1955 libcrux_sha3_simd_portable_squeeze_13_f8(&s, out, i0 * (size_t)72U, 1956 (size_t)72U); 1957 } 1958 if (last < outlen) { 1959 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 1960 libcrux_sha3_simd_portable_squeeze_13_f8(&s, out, last, outlen - last); 1961 } 1962 } 1963 } 1964 1965 /** 1966 A portable SHA3 512 implementation. 1967 */ 1968 void 1969 libcrux_sha3_portable_sha512(Eurydice_slice digest, Eurydice_slice data) 1970 { 1971 libcrux_sha3_generic_keccak_portable_keccak1_96(data, digest); 1972 } 1973 1974 /** 1975 A monomorphic instance of libcrux_sha3.simd.portable.load_block 1976 with const generics 1977 - RATE= 136 1978 */ 1979 KRML_MUSTINLINE void 1980 libcrux_sha3_simd_portable_load_block_5b( 1981 uint64_t *state, Eurydice_slice blocks, size_t start) 1982 { 1983 uint64_t state_flat[25U] = { 0U }; 1984 for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)8U; i++) { 1985 size_t i0 = i; 1986 size_t offset = start + (size_t)8U * i0; 1987 uint8_t uu____0[8U]; 1988 core_result_Result_15 dst; 1989 Eurydice_slice_to_array2( 1990 &dst, 1991 Eurydice_slice_subslice3(blocks, offset, offset + (size_t)8U, 1992 uint8_t *), 1993 Eurydice_slice, uint8_t[8U], core_array_TryFromSliceError); 1994 core_result_unwrap_26_68(dst, uu____0); 1995 state_flat[i0] = core_num__u64__from_le_bytes(uu____0); 1996 } 1997 for (size_t i = (size_t)0U; i < (size_t)136U / (size_t)8U; i++) { 1998 size_t i0 = i; 1999 libcrux_sha3_traits_set_ij_04( 2000 state, i0 / (size_t)5U, i0 % (size_t)5U, 2001 libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, 2002 i0 % (size_t)5U)[0U] ^ 2003 state_flat[i0]); 2004 } 2005 } 2006 2007 /** 2008 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2009 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2010 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2011 u64}]} 2012 */ 2013 /** 2014 A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1 2015 with const generics 2016 - RATE= 136 2017 */ 2018 void 2019 libcrux_sha3_simd_portable_load_block_a1_5b( 2020 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2021 size_t start) 2022 { 2023 libcrux_sha3_simd_portable_load_block_5b(self->st, input[0U], start); 2024 } 2025 2026 /** 2027 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2028 N>[TraitClause@0, TraitClause@1]} 2029 */ 2030 /** 2031 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80 2032 with types uint64_t 2033 with const generics 2034 - N= 1 2035 - RATE= 136 2036 */ 2037 KRML_MUSTINLINE void 2038 libcrux_sha3_generic_keccak_absorb_block_80_c60( 2039 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *blocks, 2040 size_t start) 2041 { 2042 libcrux_sha3_simd_portable_load_block_a1_5b(self, blocks, start); 2043 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2044 } 2045 2046 /** 2047 A monomorphic instance of libcrux_sha3.simd.portable.load_last 2048 with const generics 2049 - RATE= 136 2050 - DELIMITER= 6 2051 */ 2052 KRML_MUSTINLINE void 2053 libcrux_sha3_simd_portable_load_last_ad( 2054 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 2055 { 2056 uint8_t buffer[136U] = { 0U }; 2057 Eurydice_slice_copy( 2058 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 2059 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 2060 buffer[len] = 6U; 2061 size_t uu____0 = (size_t)136U - (size_t)1U; 2062 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 2063 libcrux_sha3_simd_portable_load_block_5b( 2064 state, Eurydice_array_to_slice((size_t)136U, buffer, uint8_t), 2065 (size_t)0U); 2066 } 2067 2068 /** 2069 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2070 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2071 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2072 u64}]} 2073 */ 2074 /** 2075 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 2076 with const generics 2077 - RATE= 136 2078 - DELIMITER= 6 2079 */ 2080 void 2081 libcrux_sha3_simd_portable_load_last_a1_ad( 2082 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2083 size_t start, size_t len) 2084 { 2085 libcrux_sha3_simd_portable_load_last_ad(self->st, input[0U], start, len); 2086 } 2087 2088 /** 2089 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2090 N>[TraitClause@0, TraitClause@1]} 2091 */ 2092 /** 2093 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 2094 with types uint64_t 2095 with const generics 2096 - N= 1 2097 - RATE= 136 2098 - DELIM= 6 2099 */ 2100 KRML_MUSTINLINE void 2101 libcrux_sha3_generic_keccak_absorb_final_80_9e0( 2102 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 2103 size_t start, size_t len) 2104 { 2105 libcrux_sha3_simd_portable_load_last_a1_ad(self, last, start, len); 2106 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2107 } 2108 2109 /** 2110 A monomorphic instance of libcrux_sha3.simd.portable.store_block 2111 with const generics 2112 - RATE= 136 2113 */ 2114 KRML_MUSTINLINE void 2115 libcrux_sha3_simd_portable_store_block_5b( 2116 uint64_t *s, Eurydice_slice out, size_t start, size_t len) 2117 { 2118 size_t octets = len / (size_t)8U; 2119 for (size_t i = (size_t)0U; i < octets; i++) { 2120 size_t i0 = i; 2121 Eurydice_slice uu____0 = Eurydice_slice_subslice3( 2122 out, start + (size_t)8U * i0, start + (size_t)8U * i0 + (size_t)8U, 2123 uint8_t *); 2124 uint8_t ret[8U]; 2125 core_num__u64__to_le_bytes( 2126 libcrux_sha3_traits_get_ij_04(s, i0 / (size_t)5U, i0 % (size_t)5U)[0U], 2127 ret); 2128 Eurydice_slice_copy( 2129 uu____0, Eurydice_array_to_slice((size_t)8U, ret, uint8_t), uint8_t); 2130 } 2131 size_t remaining = len % (size_t)8U; 2132 if (remaining > (size_t)0U) { 2133 Eurydice_slice uu____1 = Eurydice_slice_subslice3( 2134 out, start + len - remaining, start + len, uint8_t *); 2135 uint8_t ret[8U]; 2136 core_num__u64__to_le_bytes( 2137 libcrux_sha3_traits_get_ij_04(s, octets / (size_t)5U, 2138 octets % (size_t)5U)[0U], 2139 ret); 2140 Eurydice_slice_copy( 2141 uu____1, 2142 Eurydice_array_to_subslice3(ret, (size_t)0U, remaining, uint8_t *), 2143 uint8_t); 2144 } 2145 } 2146 2147 /** 2148 This function found in impl {libcrux_sha3::traits::Squeeze1<u64> for 2149 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2150 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2151 u64}]} 2152 */ 2153 /** 2154 A monomorphic instance of libcrux_sha3.simd.portable.squeeze_13 2155 with const generics 2156 - RATE= 136 2157 */ 2158 void 2159 libcrux_sha3_simd_portable_squeeze_13_5b( 2160 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 2161 size_t start, size_t len) 2162 { 2163 libcrux_sha3_simd_portable_store_block_5b(self->st, out, start, len); 2164 } 2165 2166 /** 2167 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 2168 with const generics 2169 - RATE= 136 2170 - DELIM= 6 2171 */ 2172 inline void 2173 libcrux_sha3_generic_keccak_portable_keccak1_ad( 2174 Eurydice_slice data, Eurydice_slice out) 2175 { 2176 libcrux_sha3_generic_keccak_KeccakState_17 s = 2177 libcrux_sha3_generic_keccak_new_80_04(); 2178 size_t data_len = Eurydice_slice_len(data, uint8_t); 2179 for (size_t i = (size_t)0U; i < data_len / (size_t)136U; i++) { 2180 size_t i0 = i; 2181 Eurydice_slice buf[1U] = { data }; 2182 libcrux_sha3_generic_keccak_absorb_block_80_c60(&s, buf, i0 * (size_t)136U); 2183 } 2184 size_t rem = data_len % (size_t)136U; 2185 Eurydice_slice buf[1U] = { data }; 2186 libcrux_sha3_generic_keccak_absorb_final_80_9e0(&s, buf, data_len - rem, rem); 2187 size_t outlen = Eurydice_slice_len(out, uint8_t); 2188 size_t blocks = outlen / (size_t)136U; 2189 size_t last = outlen - outlen % (size_t)136U; 2190 if (blocks == (size_t)0U) { 2191 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, (size_t)0U, outlen); 2192 } else { 2193 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, (size_t)0U, (size_t)136U); 2194 for (size_t i = (size_t)1U; i < blocks; i++) { 2195 size_t i0 = i; 2196 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2197 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, i0 * (size_t)136U, 2198 (size_t)136U); 2199 } 2200 if (last < outlen) { 2201 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2202 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, last, outlen - last); 2203 } 2204 } 2205 } 2206 2207 /** 2208 A portable SHA3 256 implementation. 2209 */ 2210 void 2211 libcrux_sha3_portable_sha256(Eurydice_slice digest, Eurydice_slice data) 2212 { 2213 libcrux_sha3_generic_keccak_portable_keccak1_ad(data, digest); 2214 } 2215 2216 /** 2217 A monomorphic instance of libcrux_sha3.simd.portable.load_last 2218 with const generics 2219 - RATE= 136 2220 - DELIMITER= 31 2221 */ 2222 KRML_MUSTINLINE void 2223 libcrux_sha3_simd_portable_load_last_ad0( 2224 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 2225 { 2226 uint8_t buffer[136U] = { 0U }; 2227 Eurydice_slice_copy( 2228 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 2229 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 2230 buffer[len] = 31U; 2231 size_t uu____0 = (size_t)136U - (size_t)1U; 2232 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 2233 libcrux_sha3_simd_portable_load_block_5b( 2234 state, Eurydice_array_to_slice((size_t)136U, buffer, uint8_t), 2235 (size_t)0U); 2236 } 2237 2238 /** 2239 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2240 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2241 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2242 u64}]} 2243 */ 2244 /** 2245 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 2246 with const generics 2247 - RATE= 136 2248 - DELIMITER= 31 2249 */ 2250 void 2251 libcrux_sha3_simd_portable_load_last_a1_ad0( 2252 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2253 size_t start, size_t len) 2254 { 2255 libcrux_sha3_simd_portable_load_last_ad0(self->st, input[0U], start, len); 2256 } 2257 2258 /** 2259 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2260 N>[TraitClause@0, TraitClause@1]} 2261 */ 2262 /** 2263 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 2264 with types uint64_t 2265 with const generics 2266 - N= 1 2267 - RATE= 136 2268 - DELIM= 31 2269 */ 2270 KRML_MUSTINLINE void 2271 libcrux_sha3_generic_keccak_absorb_final_80_9e1( 2272 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 2273 size_t start, size_t len) 2274 { 2275 libcrux_sha3_simd_portable_load_last_a1_ad0(self, last, start, len); 2276 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2277 } 2278 2279 /** 2280 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 2281 with const generics 2282 - RATE= 136 2283 - DELIM= 31 2284 */ 2285 inline void 2286 libcrux_sha3_generic_keccak_portable_keccak1_ad0( 2287 Eurydice_slice data, Eurydice_slice out) 2288 { 2289 libcrux_sha3_generic_keccak_KeccakState_17 s = 2290 libcrux_sha3_generic_keccak_new_80_04(); 2291 size_t data_len = Eurydice_slice_len(data, uint8_t); 2292 for (size_t i = (size_t)0U; i < data_len / (size_t)136U; i++) { 2293 size_t i0 = i; 2294 Eurydice_slice buf[1U] = { data }; 2295 libcrux_sha3_generic_keccak_absorb_block_80_c60(&s, buf, i0 * (size_t)136U); 2296 } 2297 size_t rem = data_len % (size_t)136U; 2298 Eurydice_slice buf[1U] = { data }; 2299 libcrux_sha3_generic_keccak_absorb_final_80_9e1(&s, buf, data_len - rem, rem); 2300 size_t outlen = Eurydice_slice_len(out, uint8_t); 2301 size_t blocks = outlen / (size_t)136U; 2302 size_t last = outlen - outlen % (size_t)136U; 2303 if (blocks == (size_t)0U) { 2304 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, (size_t)0U, outlen); 2305 } else { 2306 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, (size_t)0U, (size_t)136U); 2307 for (size_t i = (size_t)1U; i < blocks; i++) { 2308 size_t i0 = i; 2309 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2310 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, i0 * (size_t)136U, 2311 (size_t)136U); 2312 } 2313 if (last < outlen) { 2314 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2315 libcrux_sha3_simd_portable_squeeze_13_5b(&s, out, last, outlen - last); 2316 } 2317 } 2318 } 2319 2320 /** 2321 A portable SHAKE256 implementation. 2322 */ 2323 void 2324 libcrux_sha3_portable_shake256(Eurydice_slice digest, 2325 Eurydice_slice data) 2326 { 2327 libcrux_sha3_generic_keccak_portable_keccak1_ad0(data, digest); 2328 } 2329 2330 /** 2331 Create a new SHAKE-128 state object. 2332 */ 2333 libcrux_sha3_generic_keccak_KeccakState_17 2334 libcrux_sha3_portable_incremental_shake128_init(void) 2335 { 2336 return libcrux_sha3_generic_keccak_new_80_04(); 2337 } 2338 2339 /** 2340 A monomorphic instance of libcrux_sha3.simd.portable.load_block 2341 with const generics 2342 - RATE= 168 2343 */ 2344 KRML_MUSTINLINE void 2345 libcrux_sha3_simd_portable_load_block_3a( 2346 uint64_t *state, Eurydice_slice blocks, size_t start) 2347 { 2348 uint64_t state_flat[25U] = { 0U }; 2349 for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)8U; i++) { 2350 size_t i0 = i; 2351 size_t offset = start + (size_t)8U * i0; 2352 uint8_t uu____0[8U]; 2353 core_result_Result_15 dst; 2354 Eurydice_slice_to_array2( 2355 &dst, 2356 Eurydice_slice_subslice3(blocks, offset, offset + (size_t)8U, 2357 uint8_t *), 2358 Eurydice_slice, uint8_t[8U], core_array_TryFromSliceError); 2359 core_result_unwrap_26_68(dst, uu____0); 2360 state_flat[i0] = core_num__u64__from_le_bytes(uu____0); 2361 } 2362 for (size_t i = (size_t)0U; i < (size_t)168U / (size_t)8U; i++) { 2363 size_t i0 = i; 2364 libcrux_sha3_traits_set_ij_04( 2365 state, i0 / (size_t)5U, i0 % (size_t)5U, 2366 libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, 2367 i0 % (size_t)5U)[0U] ^ 2368 state_flat[i0]); 2369 } 2370 } 2371 2372 /** 2373 A monomorphic instance of libcrux_sha3.simd.portable.load_last 2374 with const generics 2375 - RATE= 168 2376 - DELIMITER= 31 2377 */ 2378 KRML_MUSTINLINE void 2379 libcrux_sha3_simd_portable_load_last_c6( 2380 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 2381 { 2382 uint8_t buffer[168U] = { 0U }; 2383 Eurydice_slice_copy( 2384 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 2385 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 2386 buffer[len] = 31U; 2387 size_t uu____0 = (size_t)168U - (size_t)1U; 2388 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 2389 libcrux_sha3_simd_portable_load_block_3a( 2390 state, Eurydice_array_to_slice((size_t)168U, buffer, uint8_t), 2391 (size_t)0U); 2392 } 2393 2394 /** 2395 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2396 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2397 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2398 u64}]} 2399 */ 2400 /** 2401 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 2402 with const generics 2403 - RATE= 168 2404 - DELIMITER= 31 2405 */ 2406 void 2407 libcrux_sha3_simd_portable_load_last_a1_c6( 2408 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2409 size_t start, size_t len) 2410 { 2411 libcrux_sha3_simd_portable_load_last_c6(self->st, input[0U], start, len); 2412 } 2413 2414 /** 2415 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2416 N>[TraitClause@0, TraitClause@1]} 2417 */ 2418 /** 2419 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 2420 with types uint64_t 2421 with const generics 2422 - N= 1 2423 - RATE= 168 2424 - DELIM= 31 2425 */ 2426 KRML_MUSTINLINE void 2427 libcrux_sha3_generic_keccak_absorb_final_80_9e2( 2428 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 2429 size_t start, size_t len) 2430 { 2431 libcrux_sha3_simd_portable_load_last_a1_c6(self, last, start, len); 2432 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2433 } 2434 2435 /** 2436 Absorb 2437 */ 2438 void 2439 libcrux_sha3_portable_incremental_shake128_absorb_final( 2440 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice data0) 2441 { 2442 libcrux_sha3_generic_keccak_KeccakState_17 *uu____0 = s; 2443 Eurydice_slice uu____1[1U] = { data0 }; 2444 libcrux_sha3_generic_keccak_absorb_final_80_9e2( 2445 uu____0, uu____1, (size_t)0U, Eurydice_slice_len(data0, uint8_t)); 2446 } 2447 2448 /** 2449 A monomorphic instance of libcrux_sha3.simd.portable.store_block 2450 with const generics 2451 - RATE= 168 2452 */ 2453 KRML_MUSTINLINE void 2454 libcrux_sha3_simd_portable_store_block_3a( 2455 uint64_t *s, Eurydice_slice out, size_t start, size_t len) 2456 { 2457 size_t octets = len / (size_t)8U; 2458 for (size_t i = (size_t)0U; i < octets; i++) { 2459 size_t i0 = i; 2460 Eurydice_slice uu____0 = Eurydice_slice_subslice3( 2461 out, start + (size_t)8U * i0, start + (size_t)8U * i0 + (size_t)8U, 2462 uint8_t *); 2463 uint8_t ret[8U]; 2464 core_num__u64__to_le_bytes( 2465 libcrux_sha3_traits_get_ij_04(s, i0 / (size_t)5U, i0 % (size_t)5U)[0U], 2466 ret); 2467 Eurydice_slice_copy( 2468 uu____0, Eurydice_array_to_slice((size_t)8U, ret, uint8_t), uint8_t); 2469 } 2470 size_t remaining = len % (size_t)8U; 2471 if (remaining > (size_t)0U) { 2472 Eurydice_slice uu____1 = Eurydice_slice_subslice3( 2473 out, start + len - remaining, start + len, uint8_t *); 2474 uint8_t ret[8U]; 2475 core_num__u64__to_le_bytes( 2476 libcrux_sha3_traits_get_ij_04(s, octets / (size_t)5U, 2477 octets % (size_t)5U)[0U], 2478 ret); 2479 Eurydice_slice_copy( 2480 uu____1, 2481 Eurydice_array_to_subslice3(ret, (size_t)0U, remaining, uint8_t *), 2482 uint8_t); 2483 } 2484 } 2485 2486 /** 2487 This function found in impl {libcrux_sha3::traits::Squeeze1<u64> for 2488 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2489 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2490 u64}]} 2491 */ 2492 /** 2493 A monomorphic instance of libcrux_sha3.simd.portable.squeeze_13 2494 with const generics 2495 - RATE= 168 2496 */ 2497 void 2498 libcrux_sha3_simd_portable_squeeze_13_3a( 2499 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 2500 size_t start, size_t len) 2501 { 2502 libcrux_sha3_simd_portable_store_block_3a(self->st, out, start, len); 2503 } 2504 2505 /** 2506 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 2507 1usize>[core::marker::Sized<u64>, 2508 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2509 u64}]} 2510 */ 2511 /** 2512 A monomorphic instance of 2513 libcrux_sha3.generic_keccak.portable.squeeze_first_three_blocks_b4 with const 2514 generics 2515 - RATE= 168 2516 */ 2517 KRML_MUSTINLINE void 2518 libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_3a( 2519 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out) 2520 { 2521 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)0U, (size_t)168U); 2522 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2523 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)168U, 2524 (size_t)168U); 2525 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2526 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)2U * (size_t)168U, 2527 (size_t)168U); 2528 } 2529 2530 /** 2531 Squeeze three blocks 2532 */ 2533 void 2534 libcrux_sha3_portable_incremental_shake128_squeeze_first_three_blocks( 2535 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice out0) 2536 { 2537 libcrux_sha3_generic_keccak_portable_squeeze_first_three_blocks_b4_3a(s, 2538 out0); 2539 } 2540 2541 /** 2542 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 2543 1usize>[core::marker::Sized<u64>, 2544 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2545 u64}]} 2546 */ 2547 /** 2548 A monomorphic instance of 2549 libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4 with const generics 2550 - RATE= 168 2551 */ 2552 KRML_MUSTINLINE void 2553 libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_3a( 2554 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 2555 size_t start) 2556 { 2557 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2558 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, start, (size_t)168U); 2559 } 2560 2561 /** 2562 Squeeze another block 2563 */ 2564 void 2565 libcrux_sha3_portable_incremental_shake128_squeeze_next_block( 2566 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice out0) 2567 { 2568 libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_3a(s, out0, 2569 (size_t)0U); 2570 } 2571 2572 /** 2573 Returns the output size of a digest. 2574 */ 2575 size_t 2576 libcrux_sha3_digest_size(libcrux_sha3_Algorithm mode) 2577 { 2578 switch (mode) { 2579 case libcrux_sha3_Algorithm_Sha224: { 2580 break; 2581 } 2582 case libcrux_sha3_Algorithm_Sha256: { 2583 return (size_t)32U; 2584 } 2585 case libcrux_sha3_Algorithm_Sha384: { 2586 return (size_t)48U; 2587 } 2588 case libcrux_sha3_Algorithm_Sha512: { 2589 return (size_t)64U; 2590 } 2591 default: { 2592 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, 2593 __LINE__); 2594 KRML_HOST_EXIT(253U); 2595 } 2596 } 2597 return (size_t)28U; 2598 } 2599 2600 /** 2601 A monomorphic instance of libcrux_sha3.simd.portable.load_block 2602 with const generics 2603 - RATE= 144 2604 */ 2605 KRML_MUSTINLINE void 2606 libcrux_sha3_simd_portable_load_block_2c( 2607 uint64_t *state, Eurydice_slice blocks, size_t start) 2608 { 2609 uint64_t state_flat[25U] = { 0U }; 2610 for (size_t i = (size_t)0U; i < (size_t)144U / (size_t)8U; i++) { 2611 size_t i0 = i; 2612 size_t offset = start + (size_t)8U * i0; 2613 uint8_t uu____0[8U]; 2614 core_result_Result_15 dst; 2615 Eurydice_slice_to_array2( 2616 &dst, 2617 Eurydice_slice_subslice3(blocks, offset, offset + (size_t)8U, 2618 uint8_t *), 2619 Eurydice_slice, uint8_t[8U], core_array_TryFromSliceError); 2620 core_result_unwrap_26_68(dst, uu____0); 2621 state_flat[i0] = core_num__u64__from_le_bytes(uu____0); 2622 } 2623 for (size_t i = (size_t)0U; i < (size_t)144U / (size_t)8U; i++) { 2624 size_t i0 = i; 2625 libcrux_sha3_traits_set_ij_04( 2626 state, i0 / (size_t)5U, i0 % (size_t)5U, 2627 libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, 2628 i0 % (size_t)5U)[0U] ^ 2629 state_flat[i0]); 2630 } 2631 } 2632 2633 /** 2634 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2635 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2636 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2637 u64}]} 2638 */ 2639 /** 2640 A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1 2641 with const generics 2642 - RATE= 144 2643 */ 2644 void 2645 libcrux_sha3_simd_portable_load_block_a1_2c( 2646 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2647 size_t start) 2648 { 2649 libcrux_sha3_simd_portable_load_block_2c(self->st, input[0U], start); 2650 } 2651 2652 /** 2653 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2654 N>[TraitClause@0, TraitClause@1]} 2655 */ 2656 /** 2657 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80 2658 with types uint64_t 2659 with const generics 2660 - N= 1 2661 - RATE= 144 2662 */ 2663 KRML_MUSTINLINE void 2664 libcrux_sha3_generic_keccak_absorb_block_80_c61( 2665 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *blocks, 2666 size_t start) 2667 { 2668 libcrux_sha3_simd_portable_load_block_a1_2c(self, blocks, start); 2669 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2670 } 2671 2672 /** 2673 A monomorphic instance of libcrux_sha3.simd.portable.load_last 2674 with const generics 2675 - RATE= 144 2676 - DELIMITER= 6 2677 */ 2678 KRML_MUSTINLINE void 2679 libcrux_sha3_simd_portable_load_last_1e( 2680 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 2681 { 2682 uint8_t buffer[144U] = { 0U }; 2683 Eurydice_slice_copy( 2684 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 2685 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 2686 buffer[len] = 6U; 2687 size_t uu____0 = (size_t)144U - (size_t)1U; 2688 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 2689 libcrux_sha3_simd_portable_load_block_2c( 2690 state, Eurydice_array_to_slice((size_t)144U, buffer, uint8_t), 2691 (size_t)0U); 2692 } 2693 2694 /** 2695 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2696 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2697 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2698 u64}]} 2699 */ 2700 /** 2701 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 2702 with const generics 2703 - RATE= 144 2704 - DELIMITER= 6 2705 */ 2706 void 2707 libcrux_sha3_simd_portable_load_last_a1_1e( 2708 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2709 size_t start, size_t len) 2710 { 2711 libcrux_sha3_simd_portable_load_last_1e(self->st, input[0U], start, len); 2712 } 2713 2714 /** 2715 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2716 N>[TraitClause@0, TraitClause@1]} 2717 */ 2718 /** 2719 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 2720 with types uint64_t 2721 with const generics 2722 - N= 1 2723 - RATE= 144 2724 - DELIM= 6 2725 */ 2726 KRML_MUSTINLINE void 2727 libcrux_sha3_generic_keccak_absorb_final_80_9e3( 2728 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 2729 size_t start, size_t len) 2730 { 2731 libcrux_sha3_simd_portable_load_last_a1_1e(self, last, start, len); 2732 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2733 } 2734 2735 /** 2736 A monomorphic instance of libcrux_sha3.simd.portable.store_block 2737 with const generics 2738 - RATE= 144 2739 */ 2740 KRML_MUSTINLINE void 2741 libcrux_sha3_simd_portable_store_block_2c( 2742 uint64_t *s, Eurydice_slice out, size_t start, size_t len) 2743 { 2744 size_t octets = len / (size_t)8U; 2745 for (size_t i = (size_t)0U; i < octets; i++) { 2746 size_t i0 = i; 2747 Eurydice_slice uu____0 = Eurydice_slice_subslice3( 2748 out, start + (size_t)8U * i0, start + (size_t)8U * i0 + (size_t)8U, 2749 uint8_t *); 2750 uint8_t ret[8U]; 2751 core_num__u64__to_le_bytes( 2752 libcrux_sha3_traits_get_ij_04(s, i0 / (size_t)5U, i0 % (size_t)5U)[0U], 2753 ret); 2754 Eurydice_slice_copy( 2755 uu____0, Eurydice_array_to_slice((size_t)8U, ret, uint8_t), uint8_t); 2756 } 2757 size_t remaining = len % (size_t)8U; 2758 if (remaining > (size_t)0U) { 2759 Eurydice_slice uu____1 = Eurydice_slice_subslice3( 2760 out, start + len - remaining, start + len, uint8_t *); 2761 uint8_t ret[8U]; 2762 core_num__u64__to_le_bytes( 2763 libcrux_sha3_traits_get_ij_04(s, octets / (size_t)5U, 2764 octets % (size_t)5U)[0U], 2765 ret); 2766 Eurydice_slice_copy( 2767 uu____1, 2768 Eurydice_array_to_subslice3(ret, (size_t)0U, remaining, uint8_t *), 2769 uint8_t); 2770 } 2771 } 2772 2773 /** 2774 This function found in impl {libcrux_sha3::traits::Squeeze1<u64> for 2775 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2776 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2777 u64}]} 2778 */ 2779 /** 2780 A monomorphic instance of libcrux_sha3.simd.portable.squeeze_13 2781 with const generics 2782 - RATE= 144 2783 */ 2784 void 2785 libcrux_sha3_simd_portable_squeeze_13_2c( 2786 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 2787 size_t start, size_t len) 2788 { 2789 libcrux_sha3_simd_portable_store_block_2c(self->st, out, start, len); 2790 } 2791 2792 /** 2793 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 2794 with const generics 2795 - RATE= 144 2796 - DELIM= 6 2797 */ 2798 inline void 2799 libcrux_sha3_generic_keccak_portable_keccak1_1e( 2800 Eurydice_slice data, Eurydice_slice out) 2801 { 2802 libcrux_sha3_generic_keccak_KeccakState_17 s = 2803 libcrux_sha3_generic_keccak_new_80_04(); 2804 size_t data_len = Eurydice_slice_len(data, uint8_t); 2805 for (size_t i = (size_t)0U; i < data_len / (size_t)144U; i++) { 2806 size_t i0 = i; 2807 Eurydice_slice buf[1U] = { data }; 2808 libcrux_sha3_generic_keccak_absorb_block_80_c61(&s, buf, i0 * (size_t)144U); 2809 } 2810 size_t rem = data_len % (size_t)144U; 2811 Eurydice_slice buf[1U] = { data }; 2812 libcrux_sha3_generic_keccak_absorb_final_80_9e3(&s, buf, data_len - rem, rem); 2813 size_t outlen = Eurydice_slice_len(out, uint8_t); 2814 size_t blocks = outlen / (size_t)144U; 2815 size_t last = outlen - outlen % (size_t)144U; 2816 if (blocks == (size_t)0U) { 2817 libcrux_sha3_simd_portable_squeeze_13_2c(&s, out, (size_t)0U, outlen); 2818 } else { 2819 libcrux_sha3_simd_portable_squeeze_13_2c(&s, out, (size_t)0U, (size_t)144U); 2820 for (size_t i = (size_t)1U; i < blocks; i++) { 2821 size_t i0 = i; 2822 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2823 libcrux_sha3_simd_portable_squeeze_13_2c(&s, out, i0 * (size_t)144U, 2824 (size_t)144U); 2825 } 2826 if (last < outlen) { 2827 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 2828 libcrux_sha3_simd_portable_squeeze_13_2c(&s, out, last, outlen - last); 2829 } 2830 } 2831 } 2832 2833 /** 2834 A portable SHA3 224 implementation. 2835 */ 2836 KRML_MUSTINLINE void 2837 libcrux_sha3_portable_sha224(Eurydice_slice digest, 2838 Eurydice_slice data) 2839 { 2840 libcrux_sha3_generic_keccak_portable_keccak1_1e(data, digest); 2841 } 2842 2843 /** 2844 A monomorphic instance of libcrux_sha3.simd.portable.load_block 2845 with const generics 2846 - RATE= 104 2847 */ 2848 KRML_MUSTINLINE void 2849 libcrux_sha3_simd_portable_load_block_7a( 2850 uint64_t *state, Eurydice_slice blocks, size_t start) 2851 { 2852 uint64_t state_flat[25U] = { 0U }; 2853 for (size_t i = (size_t)0U; i < (size_t)104U / (size_t)8U; i++) { 2854 size_t i0 = i; 2855 size_t offset = start + (size_t)8U * i0; 2856 uint8_t uu____0[8U]; 2857 core_result_Result_15 dst; 2858 Eurydice_slice_to_array2( 2859 &dst, 2860 Eurydice_slice_subslice3(blocks, offset, offset + (size_t)8U, 2861 uint8_t *), 2862 Eurydice_slice, uint8_t[8U], core_array_TryFromSliceError); 2863 core_result_unwrap_26_68(dst, uu____0); 2864 state_flat[i0] = core_num__u64__from_le_bytes(uu____0); 2865 } 2866 for (size_t i = (size_t)0U; i < (size_t)104U / (size_t)8U; i++) { 2867 size_t i0 = i; 2868 libcrux_sha3_traits_set_ij_04( 2869 state, i0 / (size_t)5U, i0 % (size_t)5U, 2870 libcrux_sha3_traits_get_ij_04(state, i0 / (size_t)5U, 2871 i0 % (size_t)5U)[0U] ^ 2872 state_flat[i0]); 2873 } 2874 } 2875 2876 /** 2877 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2878 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2879 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2880 u64}]} 2881 */ 2882 /** 2883 A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1 2884 with const generics 2885 - RATE= 104 2886 */ 2887 void 2888 libcrux_sha3_simd_portable_load_block_a1_7a( 2889 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2890 size_t start) 2891 { 2892 libcrux_sha3_simd_portable_load_block_7a(self->st, input[0U], start); 2893 } 2894 2895 /** 2896 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2897 N>[TraitClause@0, TraitClause@1]} 2898 */ 2899 /** 2900 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80 2901 with types uint64_t 2902 with const generics 2903 - N= 1 2904 - RATE= 104 2905 */ 2906 KRML_MUSTINLINE void 2907 libcrux_sha3_generic_keccak_absorb_block_80_c62( 2908 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *blocks, 2909 size_t start) 2910 { 2911 libcrux_sha3_simd_portable_load_block_a1_7a(self, blocks, start); 2912 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2913 } 2914 2915 /** 2916 A monomorphic instance of libcrux_sha3.simd.portable.load_last 2917 with const generics 2918 - RATE= 104 2919 - DELIMITER= 6 2920 */ 2921 KRML_MUSTINLINE void 2922 libcrux_sha3_simd_portable_load_last_7c( 2923 uint64_t *state, Eurydice_slice blocks, size_t start, size_t len) 2924 { 2925 uint8_t buffer[104U] = { 0U }; 2926 Eurydice_slice_copy( 2927 Eurydice_array_to_subslice3(buffer, (size_t)0U, len, uint8_t *), 2928 Eurydice_slice_subslice3(blocks, start, start + len, uint8_t *), uint8_t); 2929 buffer[len] = 6U; 2930 size_t uu____0 = (size_t)104U - (size_t)1U; 2931 buffer[uu____0] = (uint32_t)buffer[uu____0] | 128U; 2932 libcrux_sha3_simd_portable_load_block_7a( 2933 state, Eurydice_array_to_slice((size_t)104U, buffer, uint8_t), 2934 (size_t)0U); 2935 } 2936 2937 /** 2938 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 2939 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 2940 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 2941 u64}]} 2942 */ 2943 /** 2944 A monomorphic instance of libcrux_sha3.simd.portable.load_last_a1 2945 with const generics 2946 - RATE= 104 2947 - DELIMITER= 6 2948 */ 2949 void 2950 libcrux_sha3_simd_portable_load_last_a1_7c( 2951 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 2952 size_t start, size_t len) 2953 { 2954 libcrux_sha3_simd_portable_load_last_7c(self->st, input[0U], start, len); 2955 } 2956 2957 /** 2958 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 2959 N>[TraitClause@0, TraitClause@1]} 2960 */ 2961 /** 2962 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_final_80 2963 with types uint64_t 2964 with const generics 2965 - N= 1 2966 - RATE= 104 2967 - DELIM= 6 2968 */ 2969 KRML_MUSTINLINE void 2970 libcrux_sha3_generic_keccak_absorb_final_80_9e4( 2971 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *last, 2972 size_t start, size_t len) 2973 { 2974 libcrux_sha3_simd_portable_load_last_a1_7c(self, last, start, len); 2975 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 2976 } 2977 2978 /** 2979 A monomorphic instance of libcrux_sha3.simd.portable.store_block 2980 with const generics 2981 - RATE= 104 2982 */ 2983 KRML_MUSTINLINE void 2984 libcrux_sha3_simd_portable_store_block_7a( 2985 uint64_t *s, Eurydice_slice out, size_t start, size_t len) 2986 { 2987 size_t octets = len / (size_t)8U; 2988 for (size_t i = (size_t)0U; i < octets; i++) { 2989 size_t i0 = i; 2990 Eurydice_slice uu____0 = Eurydice_slice_subslice3( 2991 out, start + (size_t)8U * i0, start + (size_t)8U * i0 + (size_t)8U, 2992 uint8_t *); 2993 uint8_t ret[8U]; 2994 core_num__u64__to_le_bytes( 2995 libcrux_sha3_traits_get_ij_04(s, i0 / (size_t)5U, i0 % (size_t)5U)[0U], 2996 ret); 2997 Eurydice_slice_copy( 2998 uu____0, Eurydice_array_to_slice((size_t)8U, ret, uint8_t), uint8_t); 2999 } 3000 size_t remaining = len % (size_t)8U; 3001 if (remaining > (size_t)0U) { 3002 Eurydice_slice uu____1 = Eurydice_slice_subslice3( 3003 out, start + len - remaining, start + len, uint8_t *); 3004 uint8_t ret[8U]; 3005 core_num__u64__to_le_bytes( 3006 libcrux_sha3_traits_get_ij_04(s, octets / (size_t)5U, 3007 octets % (size_t)5U)[0U], 3008 ret); 3009 Eurydice_slice_copy( 3010 uu____1, 3011 Eurydice_array_to_subslice3(ret, (size_t)0U, remaining, uint8_t *), 3012 uint8_t); 3013 } 3014 } 3015 3016 /** 3017 This function found in impl {libcrux_sha3::traits::Squeeze1<u64> for 3018 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 3019 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 3020 u64}]} 3021 */ 3022 /** 3023 A monomorphic instance of libcrux_sha3.simd.portable.squeeze_13 3024 with const generics 3025 - RATE= 104 3026 */ 3027 void 3028 libcrux_sha3_simd_portable_squeeze_13_7a( 3029 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 3030 size_t start, size_t len) 3031 { 3032 libcrux_sha3_simd_portable_store_block_7a(self->st, out, start, len); 3033 } 3034 3035 /** 3036 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 3037 with const generics 3038 - RATE= 104 3039 - DELIM= 6 3040 */ 3041 inline void 3042 libcrux_sha3_generic_keccak_portable_keccak1_7c( 3043 Eurydice_slice data, Eurydice_slice out) 3044 { 3045 libcrux_sha3_generic_keccak_KeccakState_17 s = 3046 libcrux_sha3_generic_keccak_new_80_04(); 3047 size_t data_len = Eurydice_slice_len(data, uint8_t); 3048 for (size_t i = (size_t)0U; i < data_len / (size_t)104U; i++) { 3049 size_t i0 = i; 3050 Eurydice_slice buf[1U] = { data }; 3051 libcrux_sha3_generic_keccak_absorb_block_80_c62(&s, buf, i0 * (size_t)104U); 3052 } 3053 size_t rem = data_len % (size_t)104U; 3054 Eurydice_slice buf[1U] = { data }; 3055 libcrux_sha3_generic_keccak_absorb_final_80_9e4(&s, buf, data_len - rem, rem); 3056 size_t outlen = Eurydice_slice_len(out, uint8_t); 3057 size_t blocks = outlen / (size_t)104U; 3058 size_t last = outlen - outlen % (size_t)104U; 3059 if (blocks == (size_t)0U) { 3060 libcrux_sha3_simd_portable_squeeze_13_7a(&s, out, (size_t)0U, outlen); 3061 } else { 3062 libcrux_sha3_simd_portable_squeeze_13_7a(&s, out, (size_t)0U, (size_t)104U); 3063 for (size_t i = (size_t)1U; i < blocks; i++) { 3064 size_t i0 = i; 3065 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 3066 libcrux_sha3_simd_portable_squeeze_13_7a(&s, out, i0 * (size_t)104U, 3067 (size_t)104U); 3068 } 3069 if (last < outlen) { 3070 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 3071 libcrux_sha3_simd_portable_squeeze_13_7a(&s, out, last, outlen - last); 3072 } 3073 } 3074 } 3075 3076 /** 3077 A portable SHA3 384 implementation. 3078 */ 3079 KRML_MUSTINLINE void 3080 libcrux_sha3_portable_sha384(Eurydice_slice digest, 3081 Eurydice_slice data) 3082 { 3083 libcrux_sha3_generic_keccak_portable_keccak1_7c(data, digest); 3084 } 3085 3086 /** 3087 SHA3 224 3088 3089 Preconditions: 3090 - `digest.len() == 28` 3091 */ 3092 void 3093 libcrux_sha3_sha224_ema(Eurydice_slice digest, Eurydice_slice payload) 3094 { 3095 libcrux_sha3_portable_sha224(digest, payload); 3096 } 3097 3098 /** 3099 SHA3 224 3100 */ 3101 void 3102 libcrux_sha3_sha224(Eurydice_slice data, uint8_t ret[28U]) 3103 { 3104 uint8_t out[28U] = { 0U }; 3105 libcrux_sha3_sha224_ema(Eurydice_array_to_slice((size_t)28U, out, uint8_t), 3106 data); 3107 memcpy(ret, out, (size_t)28U * sizeof(uint8_t)); 3108 } 3109 3110 /** 3111 SHA3 256 3112 */ 3113 void 3114 libcrux_sha3_sha256_ema(Eurydice_slice digest, Eurydice_slice payload) 3115 { 3116 libcrux_sha3_portable_sha256(digest, payload); 3117 } 3118 3119 /** 3120 SHA3 256 3121 */ 3122 void 3123 libcrux_sha3_sha256(Eurydice_slice data, uint8_t ret[32U]) 3124 { 3125 uint8_t out[32U] = { 0U }; 3126 libcrux_sha3_sha256_ema(Eurydice_array_to_slice((size_t)32U, out, uint8_t), 3127 data); 3128 memcpy(ret, out, (size_t)32U * sizeof(uint8_t)); 3129 } 3130 3131 /** 3132 SHA3 384 3133 */ 3134 void 3135 libcrux_sha3_sha384_ema(Eurydice_slice digest, Eurydice_slice payload) 3136 { 3137 libcrux_sha3_portable_sha384(digest, payload); 3138 } 3139 3140 /** 3141 SHA3 384 3142 */ 3143 void 3144 libcrux_sha3_sha384(Eurydice_slice data, uint8_t ret[48U]) 3145 { 3146 uint8_t out[48U] = { 0U }; 3147 libcrux_sha3_sha384_ema(Eurydice_array_to_slice((size_t)48U, out, uint8_t), 3148 data); 3149 memcpy(ret, out, (size_t)48U * sizeof(uint8_t)); 3150 } 3151 3152 /** 3153 SHA3 512 3154 */ 3155 void 3156 libcrux_sha3_sha512_ema(Eurydice_slice digest, Eurydice_slice payload) 3157 { 3158 libcrux_sha3_portable_sha512(digest, payload); 3159 } 3160 3161 /** 3162 SHA3 512 3163 */ 3164 void 3165 libcrux_sha3_sha512(Eurydice_slice data, uint8_t ret[64U]) 3166 { 3167 uint8_t out[64U] = { 0U }; 3168 libcrux_sha3_sha512_ema(Eurydice_array_to_slice((size_t)64U, out, uint8_t), 3169 data); 3170 memcpy(ret, out, (size_t)64U * sizeof(uint8_t)); 3171 } 3172 3173 /** 3174 This function found in impl {libcrux_sha3::traits::Absorb<1usize> for 3175 libcrux_sha3::generic_keccak::KeccakState<u64, 1usize>[core::marker::Sized<u64>, 3176 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 3177 u64}]} 3178 */ 3179 /** 3180 A monomorphic instance of libcrux_sha3.simd.portable.load_block_a1 3181 with const generics 3182 - RATE= 168 3183 */ 3184 void 3185 libcrux_sha3_simd_portable_load_block_a1_3a( 3186 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *input, 3187 size_t start) 3188 { 3189 libcrux_sha3_simd_portable_load_block_3a(self->st, input[0U], start); 3190 } 3191 3192 /** 3193 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<T, 3194 N>[TraitClause@0, TraitClause@1]} 3195 */ 3196 /** 3197 A monomorphic instance of libcrux_sha3.generic_keccak.absorb_block_80 3198 with types uint64_t 3199 with const generics 3200 - N= 1 3201 - RATE= 168 3202 */ 3203 KRML_MUSTINLINE void 3204 libcrux_sha3_generic_keccak_absorb_block_80_c63( 3205 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice *blocks, 3206 size_t start) 3207 { 3208 libcrux_sha3_simd_portable_load_block_a1_3a(self, blocks, start); 3209 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3210 } 3211 3212 /** 3213 A monomorphic instance of libcrux_sha3.generic_keccak.portable.keccak1 3214 with const generics 3215 - RATE= 168 3216 - DELIM= 31 3217 */ 3218 inline void 3219 libcrux_sha3_generic_keccak_portable_keccak1_c6( 3220 Eurydice_slice data, Eurydice_slice out) 3221 { 3222 libcrux_sha3_generic_keccak_KeccakState_17 s = 3223 libcrux_sha3_generic_keccak_new_80_04(); 3224 size_t data_len = Eurydice_slice_len(data, uint8_t); 3225 for (size_t i = (size_t)0U; i < data_len / (size_t)168U; i++) { 3226 size_t i0 = i; 3227 Eurydice_slice buf[1U] = { data }; 3228 libcrux_sha3_generic_keccak_absorb_block_80_c63(&s, buf, i0 * (size_t)168U); 3229 } 3230 size_t rem = data_len % (size_t)168U; 3231 Eurydice_slice buf[1U] = { data }; 3232 libcrux_sha3_generic_keccak_absorb_final_80_9e2(&s, buf, data_len - rem, rem); 3233 size_t outlen = Eurydice_slice_len(out, uint8_t); 3234 size_t blocks = outlen / (size_t)168U; 3235 size_t last = outlen - outlen % (size_t)168U; 3236 if (blocks == (size_t)0U) { 3237 libcrux_sha3_simd_portable_squeeze_13_3a(&s, out, (size_t)0U, outlen); 3238 } else { 3239 libcrux_sha3_simd_portable_squeeze_13_3a(&s, out, (size_t)0U, (size_t)168U); 3240 for (size_t i = (size_t)1U; i < blocks; i++) { 3241 size_t i0 = i; 3242 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 3243 libcrux_sha3_simd_portable_squeeze_13_3a(&s, out, i0 * (size_t)168U, 3244 (size_t)168U); 3245 } 3246 if (last < outlen) { 3247 libcrux_sha3_generic_keccak_keccakf1600_80_04(&s); 3248 libcrux_sha3_simd_portable_squeeze_13_3a(&s, out, last, outlen - last); 3249 } 3250 } 3251 } 3252 3253 /** 3254 A portable SHAKE128 implementation. 3255 */ 3256 KRML_MUSTINLINE void 3257 libcrux_sha3_portable_shake128(Eurydice_slice digest, 3258 Eurydice_slice data) 3259 { 3260 libcrux_sha3_generic_keccak_portable_keccak1_c6(data, digest); 3261 } 3262 3263 /** 3264 SHAKE 128 3265 3266 Writes `out.len()` bytes. 3267 */ 3268 void 3269 libcrux_sha3_shake128_ema(Eurydice_slice out, Eurydice_slice data) 3270 { 3271 libcrux_sha3_portable_shake128(out, data); 3272 } 3273 3274 /** 3275 SHAKE 256 3276 3277 Writes `out.len()` bytes. 3278 */ 3279 void 3280 libcrux_sha3_shake256_ema(Eurydice_slice out, Eurydice_slice data) 3281 { 3282 libcrux_sha3_portable_shake256(out, data); 3283 } 3284 3285 /** 3286 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 3287 1usize>[core::marker::Sized<u64>, 3288 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 3289 u64}]} 3290 */ 3291 /** 3292 A monomorphic instance of 3293 libcrux_sha3.generic_keccak.portable.squeeze_first_five_blocks_b4 with const 3294 generics 3295 - RATE= 168 3296 */ 3297 KRML_MUSTINLINE void 3298 libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_3a( 3299 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out) 3300 { 3301 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)0U, (size_t)168U); 3302 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3303 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)168U, 3304 (size_t)168U); 3305 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3306 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)2U * (size_t)168U, 3307 (size_t)168U); 3308 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3309 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)3U * (size_t)168U, 3310 (size_t)168U); 3311 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3312 libcrux_sha3_simd_portable_squeeze_13_3a(self, out, (size_t)4U * (size_t)168U, 3313 (size_t)168U); 3314 } 3315 3316 /** 3317 Squeeze five blocks 3318 */ 3319 KRML_MUSTINLINE void 3320 libcrux_sha3_portable_incremental_shake128_squeeze_first_five_blocks( 3321 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice out0) 3322 { 3323 libcrux_sha3_generic_keccak_portable_squeeze_first_five_blocks_b4_3a(s, out0); 3324 } 3325 3326 /** 3327 Absorb some data for SHAKE-256 for the last time 3328 */ 3329 KRML_MUSTINLINE void 3330 libcrux_sha3_portable_incremental_shake256_absorb_final( 3331 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice data) 3332 { 3333 libcrux_sha3_generic_keccak_KeccakState_17 *uu____0 = s; 3334 Eurydice_slice uu____1[1U] = { data }; 3335 libcrux_sha3_generic_keccak_absorb_final_80_9e1( 3336 uu____0, uu____1, (size_t)0U, Eurydice_slice_len(data, uint8_t)); 3337 } 3338 3339 /** 3340 Create a new SHAKE-256 state object. 3341 */ 3342 KRML_MUSTINLINE libcrux_sha3_generic_keccak_KeccakState_17 3343 libcrux_sha3_portable_incremental_shake256_init(void) 3344 { 3345 return libcrux_sha3_generic_keccak_new_80_04(); 3346 } 3347 3348 /** 3349 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 3350 1usize>[core::marker::Sized<u64>, 3351 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 3352 u64}]} 3353 */ 3354 /** 3355 A monomorphic instance of 3356 libcrux_sha3.generic_keccak.portable.squeeze_first_block_b4 with const generics 3357 - RATE= 136 3358 */ 3359 KRML_MUSTINLINE void 3360 libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_5b( 3361 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out) 3362 { 3363 libcrux_sha3_simd_portable_squeeze_13_5b(self, out, (size_t)0U, (size_t)136U); 3364 } 3365 3366 /** 3367 Squeeze the first SHAKE-256 block 3368 */ 3369 KRML_MUSTINLINE void 3370 libcrux_sha3_portable_incremental_shake256_squeeze_first_block( 3371 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice out) 3372 { 3373 libcrux_sha3_generic_keccak_portable_squeeze_first_block_b4_5b(s, out); 3374 } 3375 3376 /** 3377 This function found in impl {libcrux_sha3::generic_keccak::KeccakState<u64, 3378 1usize>[core::marker::Sized<u64>, 3379 libcrux_sha3::simd::portable::{libcrux_sha3::traits::KeccakItem<1usize> for 3380 u64}]} 3381 */ 3382 /** 3383 A monomorphic instance of 3384 libcrux_sha3.generic_keccak.portable.squeeze_next_block_b4 with const generics 3385 - RATE= 136 3386 */ 3387 KRML_MUSTINLINE void 3388 libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_5b( 3389 libcrux_sha3_generic_keccak_KeccakState_17 *self, Eurydice_slice out, 3390 size_t start) 3391 { 3392 libcrux_sha3_generic_keccak_keccakf1600_80_04(self); 3393 libcrux_sha3_simd_portable_squeeze_13_5b(self, out, start, (size_t)136U); 3394 } 3395 3396 /** 3397 Squeeze the next SHAKE-256 block 3398 */ 3399 KRML_MUSTINLINE void 3400 libcrux_sha3_portable_incremental_shake256_squeeze_next_block( 3401 libcrux_sha3_generic_keccak_KeccakState_17 *s, Eurydice_slice out) 3402 { 3403 libcrux_sha3_generic_keccak_portable_squeeze_next_block_b4_5b(s, out, 3404 (size_t)0U); 3405 } 3406 3407 /** 3408 This function found in impl 3409 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3410 RATE>[TraitClause@0, TraitClause@1]} 3411 */ 3412 /** 3413 A monomorphic instance of libcrux_sha3.generic_keccak.xof.fill_buffer_35 3414 with types uint64_t 3415 with const generics 3416 - PARALLEL_LANES= 1 3417 - RATE= 136 3418 */ 3419 size_t 3420 libcrux_sha3_generic_keccak_xof_fill_buffer_35_c6( 3421 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3422 Eurydice_slice *inputs) 3423 { 3424 size_t input_len = Eurydice_slice_len(inputs[0U], uint8_t); 3425 size_t consumed = (size_t)0U; 3426 if (self->buf_len > (size_t)0U) { 3427 if (self->buf_len + input_len >= (size_t)136U) { 3428 consumed = (size_t)136U - self->buf_len; 3429 { 3430 size_t i = (size_t)0U; 3431 Eurydice_slice uu____0 = Eurydice_array_to_subslice_from( 3432 (size_t)136U, self->buf[i], self->buf_len, uint8_t, size_t, 3433 uint8_t[]); 3434 Eurydice_slice_copy( 3435 uu____0, 3436 Eurydice_slice_subslice_to(inputs[i], consumed, uint8_t, size_t, 3437 uint8_t[]), 3438 uint8_t); 3439 } 3440 self->buf_len = self->buf_len + consumed; 3441 } 3442 } 3443 return consumed; 3444 } 3445 3446 /** 3447 This function found in impl 3448 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3449 RATE>[TraitClause@0, TraitClause@1]} 3450 */ 3451 /** 3452 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_full_35 3453 with types uint64_t 3454 with const generics 3455 - PARALLEL_LANES= 1 3456 - RATE= 136 3457 */ 3458 size_t 3459 libcrux_sha3_generic_keccak_xof_absorb_full_35_c6( 3460 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3461 Eurydice_slice *inputs) 3462 { 3463 size_t input_consumed = 3464 libcrux_sha3_generic_keccak_xof_fill_buffer_35_c6(self, inputs); 3465 if (input_consumed > (size_t)0U) { 3466 Eurydice_slice borrowed[1U]; 3467 { 3468 uint8_t buf[136U] = { 0U }; 3469 borrowed[0U] = core_array___Array_T__N___as_slice( 3470 (size_t)136U, buf, uint8_t, Eurydice_slice); 3471 } 3472 { 3473 size_t i = (size_t)0U; 3474 borrowed[i] = 3475 Eurydice_array_to_slice((size_t)136U, self->buf[i], uint8_t); 3476 } 3477 libcrux_sha3_simd_portable_load_block_a1_5b(&self->inner, borrowed, 3478 (size_t)0U); 3479 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3480 self->buf_len = (size_t)0U; 3481 } 3482 size_t input_to_consume = 3483 Eurydice_slice_len(inputs[0U], uint8_t) - input_consumed; 3484 size_t num_blocks = input_to_consume / (size_t)136U; 3485 size_t remainder = input_to_consume % (size_t)136U; 3486 for (size_t i = (size_t)0U; i < num_blocks; i++) { 3487 size_t i0 = i; 3488 libcrux_sha3_simd_portable_load_block_a1_5b( 3489 &self->inner, inputs, input_consumed + i0 * (size_t)136U); 3490 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3491 } 3492 return remainder; 3493 } 3494 3495 /** 3496 This function found in impl 3497 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3498 RATE>[TraitClause@0, TraitClause@1]} 3499 */ 3500 /** 3501 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_35 3502 with types uint64_t 3503 with const generics 3504 - PARALLEL_LANES= 1 3505 - RATE= 136 3506 */ 3507 KRML_MUSTINLINE void 3508 libcrux_sha3_generic_keccak_xof_absorb_35_c6( 3509 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3510 Eurydice_slice *inputs) 3511 { 3512 size_t input_remainder_len = 3513 libcrux_sha3_generic_keccak_xof_absorb_full_35_c6(self, inputs); 3514 if (input_remainder_len > (size_t)0U) { 3515 size_t input_len = Eurydice_slice_len(inputs[0U], uint8_t); 3516 { 3517 size_t i = (size_t)0U; 3518 Eurydice_slice_copy(Eurydice_array_to_subslice3( 3519 self->buf[i], self->buf_len, 3520 self->buf_len + input_remainder_len, uint8_t *), 3521 Eurydice_slice_subslice_from( 3522 inputs[i], input_len - input_remainder_len, 3523 uint8_t, size_t, uint8_t[]), 3524 uint8_t); 3525 } 3526 self->buf_len = self->buf_len + input_remainder_len; 3527 } 3528 } 3529 3530 /** 3531 Shake256 absorb 3532 */ 3533 /** 3534 This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> 3535 for libcrux_sha3::portable::incremental::Shake256Xof} 3536 */ 3537 void 3538 libcrux_sha3_portable_incremental_absorb_42( 3539 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3540 Eurydice_slice input) 3541 { 3542 Eurydice_slice buf[1U] = { input }; 3543 libcrux_sha3_generic_keccak_xof_absorb_35_c6(self, buf); 3544 } 3545 3546 /** 3547 This function found in impl 3548 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3549 RATE>[TraitClause@0, TraitClause@1]} 3550 */ 3551 /** 3552 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_final_35 3553 with types uint64_t 3554 with const generics 3555 - PARALLEL_LANES= 1 3556 - RATE= 136 3557 - DELIMITER= 31 3558 */ 3559 KRML_MUSTINLINE void 3560 libcrux_sha3_generic_keccak_xof_absorb_final_35_9e( 3561 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3562 Eurydice_slice *inputs) 3563 { 3564 libcrux_sha3_generic_keccak_xof_absorb_35_c6(self, inputs); 3565 Eurydice_slice borrowed[1U]; 3566 { 3567 uint8_t buf[136U] = { 0U }; 3568 borrowed[0U] = core_array___Array_T__N___as_slice((size_t)136U, buf, 3569 uint8_t, Eurydice_slice); 3570 } 3571 { 3572 size_t i = (size_t)0U; 3573 borrowed[i] = Eurydice_array_to_slice((size_t)136U, self->buf[i], uint8_t); 3574 } 3575 libcrux_sha3_simd_portable_load_last_a1_ad0(&self->inner, borrowed, 3576 (size_t)0U, self->buf_len); 3577 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3578 } 3579 3580 /** 3581 Shake256 absorb final 3582 */ 3583 /** 3584 This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> 3585 for libcrux_sha3::portable::incremental::Shake256Xof} 3586 */ 3587 void 3588 libcrux_sha3_portable_incremental_absorb_final_42( 3589 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3590 Eurydice_slice input) 3591 { 3592 Eurydice_slice buf[1U] = { input }; 3593 libcrux_sha3_generic_keccak_xof_absorb_final_35_9e(self, buf); 3594 } 3595 3596 /** 3597 This function found in impl 3598 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3599 RATE>[TraitClause@0, TraitClause@1]} 3600 */ 3601 /** 3602 A monomorphic instance of libcrux_sha3.generic_keccak.xof.zero_block_35 3603 with types uint64_t 3604 with const generics 3605 - PARALLEL_LANES= 1 3606 - RATE= 136 3607 */ 3608 void 3609 libcrux_sha3_generic_keccak_xof_zero_block_35_c6(uint8_t ret[136U]) 3610 { 3611 memset(ret, 0U, 136U * sizeof(uint8_t)); 3612 } 3613 3614 /** 3615 This function found in impl 3616 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3617 RATE>[TraitClause@0, TraitClause@1]} 3618 */ 3619 /** 3620 A monomorphic instance of libcrux_sha3.generic_keccak.xof.new_35 3621 with types uint64_t 3622 with const generics 3623 - PARALLEL_LANES= 1 3624 - RATE= 136 3625 */ 3626 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 3627 libcrux_sha3_generic_keccak_xof_new_35_c6(void) 3628 { 3629 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 lit; 3630 lit.inner = libcrux_sha3_generic_keccak_new_80_04(); 3631 uint8_t repeat_expression[1U][136U]; 3632 { 3633 libcrux_sha3_generic_keccak_xof_zero_block_35_c6(repeat_expression[0U]); 3634 } 3635 memcpy(lit.buf, repeat_expression, (size_t)1U * sizeof(uint8_t[136U])); 3636 lit.buf_len = (size_t)0U; 3637 lit.sponge = false; 3638 return lit; 3639 } 3640 3641 /** 3642 Shake256 new state 3643 */ 3644 /** 3645 This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> 3646 for libcrux_sha3::portable::incremental::Shake256Xof} 3647 */ 3648 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 3649 libcrux_sha3_portable_incremental_new_42(void) 3650 { 3651 return libcrux_sha3_generic_keccak_xof_new_35_c6(); 3652 } 3653 3654 /** 3655 Squeeze `N` x `LEN` bytes. Only `N = 1` for now. 3656 */ 3657 /** 3658 This function found in impl 3659 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, 1usize, 3660 RATE>[TraitClause@0, TraitClause@1]} 3661 */ 3662 /** 3663 A monomorphic instance of libcrux_sha3.generic_keccak.xof.squeeze_85 3664 with types uint64_t 3665 with const generics 3666 - RATE= 136 3667 */ 3668 KRML_MUSTINLINE void 3669 libcrux_sha3_generic_keccak_xof_squeeze_85_c7( 3670 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3671 Eurydice_slice out) 3672 { 3673 if (self->sponge) { 3674 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3675 } 3676 size_t out_len = Eurydice_slice_len(out, uint8_t); 3677 if (out_len > (size_t)0U) { 3678 if (out_len <= (size_t)136U) { 3679 libcrux_sha3_simd_portable_squeeze_13_5b(&self->inner, out, (size_t)0U, 3680 out_len); 3681 } else { 3682 size_t blocks = out_len / (size_t)136U; 3683 for (size_t i = (size_t)0U; i < blocks; i++) { 3684 size_t i0 = i; 3685 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3686 libcrux_sha3_simd_portable_squeeze_13_5b( 3687 &self->inner, out, i0 * (size_t)136U, (size_t)136U); 3688 } 3689 size_t remaining = out_len % (size_t)136U; 3690 if (remaining > (size_t)0U) { 3691 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3692 libcrux_sha3_simd_portable_squeeze_13_5b( 3693 &self->inner, out, blocks * (size_t)136U, remaining); 3694 } 3695 } 3696 self->sponge = true; 3697 } 3698 } 3699 3700 /** 3701 Shake256 squeeze 3702 */ 3703 /** 3704 This function found in impl {libcrux_sha3::portable::incremental::Xof<136usize> 3705 for libcrux_sha3::portable::incremental::Shake256Xof} 3706 */ 3707 void 3708 libcrux_sha3_portable_incremental_squeeze_42( 3709 libcrux_sha3_generic_keccak_xof_KeccakXofState_e2 *self, 3710 Eurydice_slice out) 3711 { 3712 libcrux_sha3_generic_keccak_xof_squeeze_85_c7(self, out); 3713 } 3714 3715 /** 3716 This function found in impl 3717 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3718 RATE>[TraitClause@0, TraitClause@1]} 3719 */ 3720 /** 3721 A monomorphic instance of libcrux_sha3.generic_keccak.xof.fill_buffer_35 3722 with types uint64_t 3723 with const generics 3724 - PARALLEL_LANES= 1 3725 - RATE= 168 3726 */ 3727 size_t 3728 libcrux_sha3_generic_keccak_xof_fill_buffer_35_c60( 3729 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3730 Eurydice_slice *inputs) 3731 { 3732 size_t input_len = Eurydice_slice_len(inputs[0U], uint8_t); 3733 size_t consumed = (size_t)0U; 3734 if (self->buf_len > (size_t)0U) { 3735 if (self->buf_len + input_len >= (size_t)168U) { 3736 consumed = (size_t)168U - self->buf_len; 3737 { 3738 size_t i = (size_t)0U; 3739 Eurydice_slice uu____0 = Eurydice_array_to_subslice_from( 3740 (size_t)168U, self->buf[i], self->buf_len, uint8_t, size_t, 3741 uint8_t[]); 3742 Eurydice_slice_copy( 3743 uu____0, 3744 Eurydice_slice_subslice_to(inputs[i], consumed, uint8_t, size_t, 3745 uint8_t[]), 3746 uint8_t); 3747 } 3748 self->buf_len = self->buf_len + consumed; 3749 } 3750 } 3751 return consumed; 3752 } 3753 3754 /** 3755 This function found in impl 3756 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3757 RATE>[TraitClause@0, TraitClause@1]} 3758 */ 3759 /** 3760 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_full_35 3761 with types uint64_t 3762 with const generics 3763 - PARALLEL_LANES= 1 3764 - RATE= 168 3765 */ 3766 size_t 3767 libcrux_sha3_generic_keccak_xof_absorb_full_35_c60( 3768 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3769 Eurydice_slice *inputs) 3770 { 3771 size_t input_consumed = 3772 libcrux_sha3_generic_keccak_xof_fill_buffer_35_c60(self, inputs); 3773 if (input_consumed > (size_t)0U) { 3774 Eurydice_slice borrowed[1U]; 3775 { 3776 uint8_t buf[168U] = { 0U }; 3777 borrowed[0U] = core_array___Array_T__N___as_slice( 3778 (size_t)168U, buf, uint8_t, Eurydice_slice); 3779 } 3780 { 3781 size_t i = (size_t)0U; 3782 borrowed[i] = 3783 Eurydice_array_to_slice((size_t)168U, self->buf[i], uint8_t); 3784 } 3785 libcrux_sha3_simd_portable_load_block_a1_3a(&self->inner, borrowed, 3786 (size_t)0U); 3787 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3788 self->buf_len = (size_t)0U; 3789 } 3790 size_t input_to_consume = 3791 Eurydice_slice_len(inputs[0U], uint8_t) - input_consumed; 3792 size_t num_blocks = input_to_consume / (size_t)168U; 3793 size_t remainder = input_to_consume % (size_t)168U; 3794 for (size_t i = (size_t)0U; i < num_blocks; i++) { 3795 size_t i0 = i; 3796 libcrux_sha3_simd_portable_load_block_a1_3a( 3797 &self->inner, inputs, input_consumed + i0 * (size_t)168U); 3798 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3799 } 3800 return remainder; 3801 } 3802 3803 /** 3804 This function found in impl 3805 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3806 RATE>[TraitClause@0, TraitClause@1]} 3807 */ 3808 /** 3809 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_35 3810 with types uint64_t 3811 with const generics 3812 - PARALLEL_LANES= 1 3813 - RATE= 168 3814 */ 3815 KRML_MUSTINLINE void 3816 libcrux_sha3_generic_keccak_xof_absorb_35_c60( 3817 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3818 Eurydice_slice *inputs) 3819 { 3820 size_t input_remainder_len = 3821 libcrux_sha3_generic_keccak_xof_absorb_full_35_c60(self, inputs); 3822 if (input_remainder_len > (size_t)0U) { 3823 size_t input_len = Eurydice_slice_len(inputs[0U], uint8_t); 3824 { 3825 size_t i = (size_t)0U; 3826 Eurydice_slice_copy(Eurydice_array_to_subslice3( 3827 self->buf[i], self->buf_len, 3828 self->buf_len + input_remainder_len, uint8_t *), 3829 Eurydice_slice_subslice_from( 3830 inputs[i], input_len - input_remainder_len, 3831 uint8_t, size_t, uint8_t[]), 3832 uint8_t); 3833 } 3834 self->buf_len = self->buf_len + input_remainder_len; 3835 } 3836 } 3837 3838 /** 3839 This function found in impl {libcrux_sha3::portable::incremental::Xof<168usize> 3840 for libcrux_sha3::portable::incremental::Shake128Xof} 3841 */ 3842 void 3843 libcrux_sha3_portable_incremental_absorb_26( 3844 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3845 Eurydice_slice input) 3846 { 3847 Eurydice_slice buf[1U] = { input }; 3848 libcrux_sha3_generic_keccak_xof_absorb_35_c60(self, buf); 3849 } 3850 3851 /** 3852 This function found in impl 3853 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3854 RATE>[TraitClause@0, TraitClause@1]} 3855 */ 3856 /** 3857 A monomorphic instance of libcrux_sha3.generic_keccak.xof.absorb_final_35 3858 with types uint64_t 3859 with const generics 3860 - PARALLEL_LANES= 1 3861 - RATE= 168 3862 - DELIMITER= 31 3863 */ 3864 KRML_MUSTINLINE void 3865 libcrux_sha3_generic_keccak_xof_absorb_final_35_9e0( 3866 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3867 Eurydice_slice *inputs) 3868 { 3869 libcrux_sha3_generic_keccak_xof_absorb_35_c60(self, inputs); 3870 Eurydice_slice borrowed[1U]; 3871 { 3872 uint8_t buf[168U] = { 0U }; 3873 borrowed[0U] = core_array___Array_T__N___as_slice((size_t)168U, buf, 3874 uint8_t, Eurydice_slice); 3875 } 3876 { 3877 size_t i = (size_t)0U; 3878 borrowed[i] = Eurydice_array_to_slice((size_t)168U, self->buf[i], uint8_t); 3879 } 3880 libcrux_sha3_simd_portable_load_last_a1_c6(&self->inner, borrowed, (size_t)0U, 3881 self->buf_len); 3882 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3883 } 3884 3885 /** 3886 This function found in impl {libcrux_sha3::portable::incremental::Xof<168usize> 3887 for libcrux_sha3::portable::incremental::Shake128Xof} 3888 */ 3889 void 3890 libcrux_sha3_portable_incremental_absorb_final_26( 3891 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3892 Eurydice_slice input) 3893 { 3894 Eurydice_slice buf[1U] = { input }; 3895 libcrux_sha3_generic_keccak_xof_absorb_final_35_9e0(self, buf); 3896 } 3897 3898 /** 3899 This function found in impl 3900 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3901 RATE>[TraitClause@0, TraitClause@1]} 3902 */ 3903 /** 3904 A monomorphic instance of libcrux_sha3.generic_keccak.xof.zero_block_35 3905 with types uint64_t 3906 with const generics 3907 - PARALLEL_LANES= 1 3908 - RATE= 168 3909 */ 3910 void 3911 libcrux_sha3_generic_keccak_xof_zero_block_35_c60(uint8_t ret[168U]) 3912 { 3913 memset(ret, 0U, 168U * sizeof(uint8_t)); 3914 } 3915 3916 /** 3917 This function found in impl 3918 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, PARALLEL_LANES, 3919 RATE>[TraitClause@0, TraitClause@1]} 3920 */ 3921 /** 3922 A monomorphic instance of libcrux_sha3.generic_keccak.xof.new_35 3923 with types uint64_t 3924 with const generics 3925 - PARALLEL_LANES= 1 3926 - RATE= 168 3927 */ 3928 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 3929 libcrux_sha3_generic_keccak_xof_new_35_c60(void) 3930 { 3931 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 lit; 3932 lit.inner = libcrux_sha3_generic_keccak_new_80_04(); 3933 uint8_t repeat_expression[1U][168U]; 3934 { 3935 libcrux_sha3_generic_keccak_xof_zero_block_35_c60(repeat_expression[0U]); 3936 } 3937 memcpy(lit.buf, repeat_expression, (size_t)1U * sizeof(uint8_t[168U])); 3938 lit.buf_len = (size_t)0U; 3939 lit.sponge = false; 3940 return lit; 3941 } 3942 3943 /** 3944 This function found in impl {libcrux_sha3::portable::incremental::Xof<168usize> 3945 for libcrux_sha3::portable::incremental::Shake128Xof} 3946 */ 3947 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 3948 libcrux_sha3_portable_incremental_new_26(void) 3949 { 3950 return libcrux_sha3_generic_keccak_xof_new_35_c60(); 3951 } 3952 3953 /** 3954 Squeeze `N` x `LEN` bytes. Only `N = 1` for now. 3955 */ 3956 /** 3957 This function found in impl 3958 {libcrux_sha3::generic_keccak::xof::KeccakXofState<STATE, 1usize, 3959 RATE>[TraitClause@0, TraitClause@1]} 3960 */ 3961 /** 3962 A monomorphic instance of libcrux_sha3.generic_keccak.xof.squeeze_85 3963 with types uint64_t 3964 with const generics 3965 - RATE= 168 3966 */ 3967 KRML_MUSTINLINE void 3968 libcrux_sha3_generic_keccak_xof_squeeze_85_13( 3969 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 3970 Eurydice_slice out) 3971 { 3972 if (self->sponge) { 3973 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3974 } 3975 size_t out_len = Eurydice_slice_len(out, uint8_t); 3976 if (out_len > (size_t)0U) { 3977 if (out_len <= (size_t)168U) { 3978 libcrux_sha3_simd_portable_squeeze_13_3a(&self->inner, out, (size_t)0U, 3979 out_len); 3980 } else { 3981 size_t blocks = out_len / (size_t)168U; 3982 for (size_t i = (size_t)0U; i < blocks; i++) { 3983 size_t i0 = i; 3984 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3985 libcrux_sha3_simd_portable_squeeze_13_3a( 3986 &self->inner, out, i0 * (size_t)168U, (size_t)168U); 3987 } 3988 size_t remaining = out_len % (size_t)168U; 3989 if (remaining > (size_t)0U) { 3990 libcrux_sha3_generic_keccak_keccakf1600_80_04(&self->inner); 3991 libcrux_sha3_simd_portable_squeeze_13_3a( 3992 &self->inner, out, blocks * (size_t)168U, remaining); 3993 } 3994 } 3995 self->sponge = true; 3996 } 3997 } 3998 3999 /** 4000 Shake128 squeeze 4001 */ 4002 /** 4003 This function found in impl {libcrux_sha3::portable::incremental::Xof<168usize> 4004 for libcrux_sha3::portable::incremental::Shake128Xof} 4005 */ 4006 void 4007 libcrux_sha3_portable_incremental_squeeze_26( 4008 libcrux_sha3_generic_keccak_xof_KeccakXofState_97 *self, 4009 Eurydice_slice out) 4010 { 4011 libcrux_sha3_generic_keccak_xof_squeeze_85_13(self, out); 4012 } 4013 4014 /** 4015 This function found in impl {core::clone::Clone for 4016 libcrux_sha3::portable::KeccakState} 4017 */ 4018 inline libcrux_sha3_generic_keccak_KeccakState_17 4019 libcrux_sha3_portable_clone_fe( 4020 libcrux_sha3_generic_keccak_KeccakState_17 *self) 4021 { 4022 return self[0U]; 4023 } 4024 4025 /** 4026 This function found in impl {core::convert::From<libcrux_sha3::Algorithm> for 4027 u32} 4028 */ 4029 uint32_t 4030 libcrux_sha3_from_6c(libcrux_sha3_Algorithm v) 4031 { 4032 switch (v) { 4033 case libcrux_sha3_Algorithm_Sha224: { 4034 break; 4035 } 4036 case libcrux_sha3_Algorithm_Sha256: { 4037 return 2U; 4038 } 4039 case libcrux_sha3_Algorithm_Sha384: { 4040 return 3U; 4041 } 4042 case libcrux_sha3_Algorithm_Sha512: { 4043 return 4U; 4044 } 4045 default: { 4046 KRML_HOST_EPRINTF("KaRaMeL incomplete match at %s:%d\n", __FILE__, 4047 __LINE__); 4048 KRML_HOST_EXIT(253U); 4049 } 4050 } 4051 return 1U; 4052 } 4053 4054 /** 4055 This function found in impl {core::convert::From<u32> for 4056 libcrux_sha3::Algorithm} 4057 */ 4058 libcrux_sha3_Algorithm 4059 libcrux_sha3_from_29(uint32_t v) 4060 { 4061 switch (v) { 4062 case 1U: { 4063 break; 4064 } 4065 case 2U: { 4066 return libcrux_sha3_Algorithm_Sha256; 4067 } 4068 case 3U: { 4069 return libcrux_sha3_Algorithm_Sha384; 4070 } 4071 case 4U: { 4072 return libcrux_sha3_Algorithm_Sha512; 4073 } 4074 default: { 4075 KRML_HOST_EPRINTF("KaRaMeL abort at %s:%d\n%s\n", __FILE__, __LINE__, 4076 "panic!"); 4077 KRML_HOST_EXIT(255U); 4078 } 4079 } 4080 return libcrux_sha3_Algorithm_Sha224; 4081 }