LCOV - code coverage report
Current view: top level - Modules/_hacl - Hacl_Hash_MD5.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 0 992 0.0 %
Date: 2023-03-20 08:15:36 Functions: 0 14 0.0 %
Branches: 0 54 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* MIT License
       2                 :            :  *
       3                 :            :  * Copyright (c) 2016-2022 INRIA, CMU and Microsoft Corporation
       4                 :            :  * Copyright (c) 2022-2023 HACL* Contributors
       5                 :            :  *
       6                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a copy
       7                 :            :  * of this software and associated documentation files (the "Software"), to deal
       8                 :            :  * in the Software without restriction, including without limitation the rights
       9                 :            :  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
      10                 :            :  * copies of the Software, and to permit persons to whom the Software is
      11                 :            :  * furnished to do so, subject to the following conditions:
      12                 :            :  *
      13                 :            :  * The above copyright notice and this permission notice shall be included in all
      14                 :            :  * copies or substantial portions of the Software.
      15                 :            :  *
      16                 :            :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      17                 :            :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      18                 :            :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
      19                 :            :  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      20                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
      21                 :            :  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
      22                 :            :  * SOFTWARE.
      23                 :            :  */
      24                 :            : 
      25                 :            : 
      26                 :            : #include "internal/Hacl_Hash_MD5.h"
      27                 :            : 
      28                 :            : static uint32_t
      29                 :            : _h0[4U] =
      30                 :            :   { (uint32_t)0x67452301U, (uint32_t)0xefcdab89U, (uint32_t)0x98badcfeU, (uint32_t)0x10325476U };
      31                 :            : 
      32                 :            : static uint32_t
      33                 :            : _t[64U] =
      34                 :            :   {
      35                 :            :     (uint32_t)0xd76aa478U, (uint32_t)0xe8c7b756U, (uint32_t)0x242070dbU, (uint32_t)0xc1bdceeeU,
      36                 :            :     (uint32_t)0xf57c0fafU, (uint32_t)0x4787c62aU, (uint32_t)0xa8304613U, (uint32_t)0xfd469501U,
      37                 :            :     (uint32_t)0x698098d8U, (uint32_t)0x8b44f7afU, (uint32_t)0xffff5bb1U, (uint32_t)0x895cd7beU,
      38                 :            :     (uint32_t)0x6b901122U, (uint32_t)0xfd987193U, (uint32_t)0xa679438eU, (uint32_t)0x49b40821U,
      39                 :            :     (uint32_t)0xf61e2562U, (uint32_t)0xc040b340U, (uint32_t)0x265e5a51U, (uint32_t)0xe9b6c7aaU,
      40                 :            :     (uint32_t)0xd62f105dU, (uint32_t)0x02441453U, (uint32_t)0xd8a1e681U, (uint32_t)0xe7d3fbc8U,
      41                 :            :     (uint32_t)0x21e1cde6U, (uint32_t)0xc33707d6U, (uint32_t)0xf4d50d87U, (uint32_t)0x455a14edU,
      42                 :            :     (uint32_t)0xa9e3e905U, (uint32_t)0xfcefa3f8U, (uint32_t)0x676f02d9U, (uint32_t)0x8d2a4c8aU,
      43                 :            :     (uint32_t)0xfffa3942U, (uint32_t)0x8771f681U, (uint32_t)0x6d9d6122U, (uint32_t)0xfde5380cU,
      44                 :            :     (uint32_t)0xa4beea44U, (uint32_t)0x4bdecfa9U, (uint32_t)0xf6bb4b60U, (uint32_t)0xbebfbc70U,
      45                 :            :     (uint32_t)0x289b7ec6U, (uint32_t)0xeaa127faU, (uint32_t)0xd4ef3085U, (uint32_t)0x4881d05U,
      46                 :            :     (uint32_t)0xd9d4d039U, (uint32_t)0xe6db99e5U, (uint32_t)0x1fa27cf8U, (uint32_t)0xc4ac5665U,
      47                 :            :     (uint32_t)0xf4292244U, (uint32_t)0x432aff97U, (uint32_t)0xab9423a7U, (uint32_t)0xfc93a039U,
      48                 :            :     (uint32_t)0x655b59c3U, (uint32_t)0x8f0ccc92U, (uint32_t)0xffeff47dU, (uint32_t)0x85845dd1U,
      49                 :            :     (uint32_t)0x6fa87e4fU, (uint32_t)0xfe2ce6e0U, (uint32_t)0xa3014314U, (uint32_t)0x4e0811a1U,
      50                 :            :     (uint32_t)0xf7537e82U, (uint32_t)0xbd3af235U, (uint32_t)0x2ad7d2bbU, (uint32_t)0xeb86d391U
      51                 :            :   };
      52                 :            : 
      53                 :          0 : void Hacl_Hash_Core_MD5_legacy_init(uint32_t *s)
      54                 :            : {
      55                 :          0 :   KRML_MAYBE_FOR4(i, (uint32_t)0U, (uint32_t)4U, (uint32_t)1U, s[i] = _h0[i];);
      56                 :          0 : }
      57                 :            : 
      58                 :          0 : static void legacy_update(uint32_t *abcd, uint8_t *x)
      59                 :            : {
      60                 :          0 :   uint32_t aa = abcd[0U];
      61                 :          0 :   uint32_t bb = abcd[1U];
      62                 :          0 :   uint32_t cc = abcd[2U];
      63                 :          0 :   uint32_t dd = abcd[3U];
      64                 :          0 :   uint32_t va = abcd[0U];
      65                 :          0 :   uint32_t vb0 = abcd[1U];
      66                 :          0 :   uint32_t vc0 = abcd[2U];
      67                 :          0 :   uint32_t vd0 = abcd[3U];
      68                 :          0 :   uint8_t *b0 = x;
      69                 :          0 :   uint32_t u = load32_le(b0);
      70                 :          0 :   uint32_t xk = u;
      71                 :          0 :   uint32_t ti0 = _t[0U];
      72                 :            :   uint32_t
      73                 :          0 :   v =
      74                 :            :     vb0
      75                 :            :     +
      76                 :          0 :       ((va + ((vb0 & vc0) | (~vb0 & vd0)) + xk + ti0)
      77                 :            :       << (uint32_t)7U
      78                 :          0 :       | (va + ((vb0 & vc0) | (~vb0 & vd0)) + xk + ti0) >> (uint32_t)25U);
      79                 :          0 :   abcd[0U] = v;
      80                 :          0 :   uint32_t va0 = abcd[3U];
      81                 :          0 :   uint32_t vb1 = abcd[0U];
      82                 :          0 :   uint32_t vc1 = abcd[1U];
      83                 :          0 :   uint32_t vd1 = abcd[2U];
      84                 :          0 :   uint8_t *b1 = x + (uint32_t)4U;
      85                 :          0 :   uint32_t u0 = load32_le(b1);
      86                 :          0 :   uint32_t xk0 = u0;
      87                 :          0 :   uint32_t ti1 = _t[1U];
      88                 :            :   uint32_t
      89                 :          0 :   v0 =
      90                 :            :     vb1
      91                 :            :     +
      92                 :          0 :       ((va0 + ((vb1 & vc1) | (~vb1 & vd1)) + xk0 + ti1)
      93                 :            :       << (uint32_t)12U
      94                 :          0 :       | (va0 + ((vb1 & vc1) | (~vb1 & vd1)) + xk0 + ti1) >> (uint32_t)20U);
      95                 :          0 :   abcd[3U] = v0;
      96                 :          0 :   uint32_t va1 = abcd[2U];
      97                 :          0 :   uint32_t vb2 = abcd[3U];
      98                 :          0 :   uint32_t vc2 = abcd[0U];
      99                 :          0 :   uint32_t vd2 = abcd[1U];
     100                 :          0 :   uint8_t *b2 = x + (uint32_t)8U;
     101                 :          0 :   uint32_t u1 = load32_le(b2);
     102                 :          0 :   uint32_t xk1 = u1;
     103                 :          0 :   uint32_t ti2 = _t[2U];
     104                 :            :   uint32_t
     105                 :          0 :   v1 =
     106                 :            :     vb2
     107                 :            :     +
     108                 :          0 :       ((va1 + ((vb2 & vc2) | (~vb2 & vd2)) + xk1 + ti2)
     109                 :            :       << (uint32_t)17U
     110                 :          0 :       | (va1 + ((vb2 & vc2) | (~vb2 & vd2)) + xk1 + ti2) >> (uint32_t)15U);
     111                 :          0 :   abcd[2U] = v1;
     112                 :          0 :   uint32_t va2 = abcd[1U];
     113                 :          0 :   uint32_t vb3 = abcd[2U];
     114                 :          0 :   uint32_t vc3 = abcd[3U];
     115                 :          0 :   uint32_t vd3 = abcd[0U];
     116                 :          0 :   uint8_t *b3 = x + (uint32_t)12U;
     117                 :          0 :   uint32_t u2 = load32_le(b3);
     118                 :          0 :   uint32_t xk2 = u2;
     119                 :          0 :   uint32_t ti3 = _t[3U];
     120                 :            :   uint32_t
     121                 :          0 :   v2 =
     122                 :            :     vb3
     123                 :            :     +
     124                 :          0 :       ((va2 + ((vb3 & vc3) | (~vb3 & vd3)) + xk2 + ti3)
     125                 :            :       << (uint32_t)22U
     126                 :          0 :       | (va2 + ((vb3 & vc3) | (~vb3 & vd3)) + xk2 + ti3) >> (uint32_t)10U);
     127                 :          0 :   abcd[1U] = v2;
     128                 :          0 :   uint32_t va3 = abcd[0U];
     129                 :          0 :   uint32_t vb4 = abcd[1U];
     130                 :          0 :   uint32_t vc4 = abcd[2U];
     131                 :          0 :   uint32_t vd4 = abcd[3U];
     132                 :          0 :   uint8_t *b4 = x + (uint32_t)16U;
     133                 :          0 :   uint32_t u3 = load32_le(b4);
     134                 :          0 :   uint32_t xk3 = u3;
     135                 :          0 :   uint32_t ti4 = _t[4U];
     136                 :            :   uint32_t
     137                 :          0 :   v3 =
     138                 :            :     vb4
     139                 :            :     +
     140                 :          0 :       ((va3 + ((vb4 & vc4) | (~vb4 & vd4)) + xk3 + ti4)
     141                 :            :       << (uint32_t)7U
     142                 :          0 :       | (va3 + ((vb4 & vc4) | (~vb4 & vd4)) + xk3 + ti4) >> (uint32_t)25U);
     143                 :          0 :   abcd[0U] = v3;
     144                 :          0 :   uint32_t va4 = abcd[3U];
     145                 :          0 :   uint32_t vb5 = abcd[0U];
     146                 :          0 :   uint32_t vc5 = abcd[1U];
     147                 :          0 :   uint32_t vd5 = abcd[2U];
     148                 :          0 :   uint8_t *b5 = x + (uint32_t)20U;
     149                 :          0 :   uint32_t u4 = load32_le(b5);
     150                 :          0 :   uint32_t xk4 = u4;
     151                 :          0 :   uint32_t ti5 = _t[5U];
     152                 :            :   uint32_t
     153                 :          0 :   v4 =
     154                 :            :     vb5
     155                 :            :     +
     156                 :          0 :       ((va4 + ((vb5 & vc5) | (~vb5 & vd5)) + xk4 + ti5)
     157                 :            :       << (uint32_t)12U
     158                 :          0 :       | (va4 + ((vb5 & vc5) | (~vb5 & vd5)) + xk4 + ti5) >> (uint32_t)20U);
     159                 :          0 :   abcd[3U] = v4;
     160                 :          0 :   uint32_t va5 = abcd[2U];
     161                 :          0 :   uint32_t vb6 = abcd[3U];
     162                 :          0 :   uint32_t vc6 = abcd[0U];
     163                 :          0 :   uint32_t vd6 = abcd[1U];
     164                 :          0 :   uint8_t *b6 = x + (uint32_t)24U;
     165                 :          0 :   uint32_t u5 = load32_le(b6);
     166                 :          0 :   uint32_t xk5 = u5;
     167                 :          0 :   uint32_t ti6 = _t[6U];
     168                 :            :   uint32_t
     169                 :          0 :   v5 =
     170                 :            :     vb6
     171                 :            :     +
     172                 :          0 :       ((va5 + ((vb6 & vc6) | (~vb6 & vd6)) + xk5 + ti6)
     173                 :            :       << (uint32_t)17U
     174                 :          0 :       | (va5 + ((vb6 & vc6) | (~vb6 & vd6)) + xk5 + ti6) >> (uint32_t)15U);
     175                 :          0 :   abcd[2U] = v5;
     176                 :          0 :   uint32_t va6 = abcd[1U];
     177                 :          0 :   uint32_t vb7 = abcd[2U];
     178                 :          0 :   uint32_t vc7 = abcd[3U];
     179                 :          0 :   uint32_t vd7 = abcd[0U];
     180                 :          0 :   uint8_t *b7 = x + (uint32_t)28U;
     181                 :          0 :   uint32_t u6 = load32_le(b7);
     182                 :          0 :   uint32_t xk6 = u6;
     183                 :          0 :   uint32_t ti7 = _t[7U];
     184                 :            :   uint32_t
     185                 :          0 :   v6 =
     186                 :            :     vb7
     187                 :            :     +
     188                 :          0 :       ((va6 + ((vb7 & vc7) | (~vb7 & vd7)) + xk6 + ti7)
     189                 :            :       << (uint32_t)22U
     190                 :          0 :       | (va6 + ((vb7 & vc7) | (~vb7 & vd7)) + xk6 + ti7) >> (uint32_t)10U);
     191                 :          0 :   abcd[1U] = v6;
     192                 :          0 :   uint32_t va7 = abcd[0U];
     193                 :          0 :   uint32_t vb8 = abcd[1U];
     194                 :          0 :   uint32_t vc8 = abcd[2U];
     195                 :          0 :   uint32_t vd8 = abcd[3U];
     196                 :          0 :   uint8_t *b8 = x + (uint32_t)32U;
     197                 :          0 :   uint32_t u7 = load32_le(b8);
     198                 :          0 :   uint32_t xk7 = u7;
     199                 :          0 :   uint32_t ti8 = _t[8U];
     200                 :            :   uint32_t
     201                 :          0 :   v7 =
     202                 :            :     vb8
     203                 :            :     +
     204                 :          0 :       ((va7 + ((vb8 & vc8) | (~vb8 & vd8)) + xk7 + ti8)
     205                 :            :       << (uint32_t)7U
     206                 :          0 :       | (va7 + ((vb8 & vc8) | (~vb8 & vd8)) + xk7 + ti8) >> (uint32_t)25U);
     207                 :          0 :   abcd[0U] = v7;
     208                 :          0 :   uint32_t va8 = abcd[3U];
     209                 :          0 :   uint32_t vb9 = abcd[0U];
     210                 :          0 :   uint32_t vc9 = abcd[1U];
     211                 :          0 :   uint32_t vd9 = abcd[2U];
     212                 :          0 :   uint8_t *b9 = x + (uint32_t)36U;
     213                 :          0 :   uint32_t u8 = load32_le(b9);
     214                 :          0 :   uint32_t xk8 = u8;
     215                 :          0 :   uint32_t ti9 = _t[9U];
     216                 :            :   uint32_t
     217                 :          0 :   v8 =
     218                 :            :     vb9
     219                 :            :     +
     220                 :          0 :       ((va8 + ((vb9 & vc9) | (~vb9 & vd9)) + xk8 + ti9)
     221                 :            :       << (uint32_t)12U
     222                 :          0 :       | (va8 + ((vb9 & vc9) | (~vb9 & vd9)) + xk8 + ti9) >> (uint32_t)20U);
     223                 :          0 :   abcd[3U] = v8;
     224                 :          0 :   uint32_t va9 = abcd[2U];
     225                 :          0 :   uint32_t vb10 = abcd[3U];
     226                 :          0 :   uint32_t vc10 = abcd[0U];
     227                 :          0 :   uint32_t vd10 = abcd[1U];
     228                 :          0 :   uint8_t *b10 = x + (uint32_t)40U;
     229                 :          0 :   uint32_t u9 = load32_le(b10);
     230                 :          0 :   uint32_t xk9 = u9;
     231                 :          0 :   uint32_t ti10 = _t[10U];
     232                 :            :   uint32_t
     233                 :          0 :   v9 =
     234                 :            :     vb10
     235                 :            :     +
     236                 :          0 :       ((va9 + ((vb10 & vc10) | (~vb10 & vd10)) + xk9 + ti10)
     237                 :            :       << (uint32_t)17U
     238                 :          0 :       | (va9 + ((vb10 & vc10) | (~vb10 & vd10)) + xk9 + ti10) >> (uint32_t)15U);
     239                 :          0 :   abcd[2U] = v9;
     240                 :          0 :   uint32_t va10 = abcd[1U];
     241                 :          0 :   uint32_t vb11 = abcd[2U];
     242                 :          0 :   uint32_t vc11 = abcd[3U];
     243                 :          0 :   uint32_t vd11 = abcd[0U];
     244                 :          0 :   uint8_t *b11 = x + (uint32_t)44U;
     245                 :          0 :   uint32_t u10 = load32_le(b11);
     246                 :          0 :   uint32_t xk10 = u10;
     247                 :          0 :   uint32_t ti11 = _t[11U];
     248                 :            :   uint32_t
     249                 :          0 :   v10 =
     250                 :            :     vb11
     251                 :            :     +
     252                 :          0 :       ((va10 + ((vb11 & vc11) | (~vb11 & vd11)) + xk10 + ti11)
     253                 :            :       << (uint32_t)22U
     254                 :          0 :       | (va10 + ((vb11 & vc11) | (~vb11 & vd11)) + xk10 + ti11) >> (uint32_t)10U);
     255                 :          0 :   abcd[1U] = v10;
     256                 :          0 :   uint32_t va11 = abcd[0U];
     257                 :          0 :   uint32_t vb12 = abcd[1U];
     258                 :          0 :   uint32_t vc12 = abcd[2U];
     259                 :          0 :   uint32_t vd12 = abcd[3U];
     260                 :          0 :   uint8_t *b12 = x + (uint32_t)48U;
     261                 :          0 :   uint32_t u11 = load32_le(b12);
     262                 :          0 :   uint32_t xk11 = u11;
     263                 :          0 :   uint32_t ti12 = _t[12U];
     264                 :            :   uint32_t
     265                 :          0 :   v11 =
     266                 :            :     vb12
     267                 :            :     +
     268                 :          0 :       ((va11 + ((vb12 & vc12) | (~vb12 & vd12)) + xk11 + ti12)
     269                 :            :       << (uint32_t)7U
     270                 :          0 :       | (va11 + ((vb12 & vc12) | (~vb12 & vd12)) + xk11 + ti12) >> (uint32_t)25U);
     271                 :          0 :   abcd[0U] = v11;
     272                 :          0 :   uint32_t va12 = abcd[3U];
     273                 :          0 :   uint32_t vb13 = abcd[0U];
     274                 :          0 :   uint32_t vc13 = abcd[1U];
     275                 :          0 :   uint32_t vd13 = abcd[2U];
     276                 :          0 :   uint8_t *b13 = x + (uint32_t)52U;
     277                 :          0 :   uint32_t u12 = load32_le(b13);
     278                 :          0 :   uint32_t xk12 = u12;
     279                 :          0 :   uint32_t ti13 = _t[13U];
     280                 :            :   uint32_t
     281                 :          0 :   v12 =
     282                 :            :     vb13
     283                 :            :     +
     284                 :          0 :       ((va12 + ((vb13 & vc13) | (~vb13 & vd13)) + xk12 + ti13)
     285                 :            :       << (uint32_t)12U
     286                 :          0 :       | (va12 + ((vb13 & vc13) | (~vb13 & vd13)) + xk12 + ti13) >> (uint32_t)20U);
     287                 :          0 :   abcd[3U] = v12;
     288                 :          0 :   uint32_t va13 = abcd[2U];
     289                 :          0 :   uint32_t vb14 = abcd[3U];
     290                 :          0 :   uint32_t vc14 = abcd[0U];
     291                 :          0 :   uint32_t vd14 = abcd[1U];
     292                 :          0 :   uint8_t *b14 = x + (uint32_t)56U;
     293                 :          0 :   uint32_t u13 = load32_le(b14);
     294                 :          0 :   uint32_t xk13 = u13;
     295                 :          0 :   uint32_t ti14 = _t[14U];
     296                 :            :   uint32_t
     297                 :          0 :   v13 =
     298                 :            :     vb14
     299                 :            :     +
     300                 :          0 :       ((va13 + ((vb14 & vc14) | (~vb14 & vd14)) + xk13 + ti14)
     301                 :            :       << (uint32_t)17U
     302                 :          0 :       | (va13 + ((vb14 & vc14) | (~vb14 & vd14)) + xk13 + ti14) >> (uint32_t)15U);
     303                 :          0 :   abcd[2U] = v13;
     304                 :          0 :   uint32_t va14 = abcd[1U];
     305                 :          0 :   uint32_t vb15 = abcd[2U];
     306                 :          0 :   uint32_t vc15 = abcd[3U];
     307                 :          0 :   uint32_t vd15 = abcd[0U];
     308                 :          0 :   uint8_t *b15 = x + (uint32_t)60U;
     309                 :          0 :   uint32_t u14 = load32_le(b15);
     310                 :          0 :   uint32_t xk14 = u14;
     311                 :          0 :   uint32_t ti15 = _t[15U];
     312                 :            :   uint32_t
     313                 :          0 :   v14 =
     314                 :            :     vb15
     315                 :            :     +
     316                 :          0 :       ((va14 + ((vb15 & vc15) | (~vb15 & vd15)) + xk14 + ti15)
     317                 :            :       << (uint32_t)22U
     318                 :          0 :       | (va14 + ((vb15 & vc15) | (~vb15 & vd15)) + xk14 + ti15) >> (uint32_t)10U);
     319                 :          0 :   abcd[1U] = v14;
     320                 :          0 :   uint32_t va15 = abcd[0U];
     321                 :          0 :   uint32_t vb16 = abcd[1U];
     322                 :          0 :   uint32_t vc16 = abcd[2U];
     323                 :          0 :   uint32_t vd16 = abcd[3U];
     324                 :          0 :   uint8_t *b16 = x + (uint32_t)4U;
     325                 :          0 :   uint32_t u15 = load32_le(b16);
     326                 :          0 :   uint32_t xk15 = u15;
     327                 :          0 :   uint32_t ti16 = _t[16U];
     328                 :            :   uint32_t
     329                 :          0 :   v15 =
     330                 :            :     vb16
     331                 :            :     +
     332                 :          0 :       ((va15 + ((vb16 & vd16) | (vc16 & ~vd16)) + xk15 + ti16)
     333                 :            :       << (uint32_t)5U
     334                 :          0 :       | (va15 + ((vb16 & vd16) | (vc16 & ~vd16)) + xk15 + ti16) >> (uint32_t)27U);
     335                 :          0 :   abcd[0U] = v15;
     336                 :          0 :   uint32_t va16 = abcd[3U];
     337                 :          0 :   uint32_t vb17 = abcd[0U];
     338                 :          0 :   uint32_t vc17 = abcd[1U];
     339                 :          0 :   uint32_t vd17 = abcd[2U];
     340                 :          0 :   uint8_t *b17 = x + (uint32_t)24U;
     341                 :          0 :   uint32_t u16 = load32_le(b17);
     342                 :          0 :   uint32_t xk16 = u16;
     343                 :          0 :   uint32_t ti17 = _t[17U];
     344                 :            :   uint32_t
     345                 :          0 :   v16 =
     346                 :            :     vb17
     347                 :            :     +
     348                 :          0 :       ((va16 + ((vb17 & vd17) | (vc17 & ~vd17)) + xk16 + ti17)
     349                 :            :       << (uint32_t)9U
     350                 :          0 :       | (va16 + ((vb17 & vd17) | (vc17 & ~vd17)) + xk16 + ti17) >> (uint32_t)23U);
     351                 :          0 :   abcd[3U] = v16;
     352                 :          0 :   uint32_t va17 = abcd[2U];
     353                 :          0 :   uint32_t vb18 = abcd[3U];
     354                 :          0 :   uint32_t vc18 = abcd[0U];
     355                 :          0 :   uint32_t vd18 = abcd[1U];
     356                 :          0 :   uint8_t *b18 = x + (uint32_t)44U;
     357                 :          0 :   uint32_t u17 = load32_le(b18);
     358                 :          0 :   uint32_t xk17 = u17;
     359                 :          0 :   uint32_t ti18 = _t[18U];
     360                 :            :   uint32_t
     361                 :          0 :   v17 =
     362                 :            :     vb18
     363                 :            :     +
     364                 :          0 :       ((va17 + ((vb18 & vd18) | (vc18 & ~vd18)) + xk17 + ti18)
     365                 :            :       << (uint32_t)14U
     366                 :          0 :       | (va17 + ((vb18 & vd18) | (vc18 & ~vd18)) + xk17 + ti18) >> (uint32_t)18U);
     367                 :          0 :   abcd[2U] = v17;
     368                 :          0 :   uint32_t va18 = abcd[1U];
     369                 :          0 :   uint32_t vb19 = abcd[2U];
     370                 :          0 :   uint32_t vc19 = abcd[3U];
     371                 :          0 :   uint32_t vd19 = abcd[0U];
     372                 :          0 :   uint8_t *b19 = x;
     373                 :          0 :   uint32_t u18 = load32_le(b19);
     374                 :          0 :   uint32_t xk18 = u18;
     375                 :          0 :   uint32_t ti19 = _t[19U];
     376                 :            :   uint32_t
     377                 :          0 :   v18 =
     378                 :            :     vb19
     379                 :            :     +
     380                 :          0 :       ((va18 + ((vb19 & vd19) | (vc19 & ~vd19)) + xk18 + ti19)
     381                 :            :       << (uint32_t)20U
     382                 :          0 :       | (va18 + ((vb19 & vd19) | (vc19 & ~vd19)) + xk18 + ti19) >> (uint32_t)12U);
     383                 :          0 :   abcd[1U] = v18;
     384                 :          0 :   uint32_t va19 = abcd[0U];
     385                 :          0 :   uint32_t vb20 = abcd[1U];
     386                 :          0 :   uint32_t vc20 = abcd[2U];
     387                 :          0 :   uint32_t vd20 = abcd[3U];
     388                 :          0 :   uint8_t *b20 = x + (uint32_t)20U;
     389                 :          0 :   uint32_t u19 = load32_le(b20);
     390                 :          0 :   uint32_t xk19 = u19;
     391                 :          0 :   uint32_t ti20 = _t[20U];
     392                 :            :   uint32_t
     393                 :          0 :   v19 =
     394                 :            :     vb20
     395                 :            :     +
     396                 :          0 :       ((va19 + ((vb20 & vd20) | (vc20 & ~vd20)) + xk19 + ti20)
     397                 :            :       << (uint32_t)5U
     398                 :          0 :       | (va19 + ((vb20 & vd20) | (vc20 & ~vd20)) + xk19 + ti20) >> (uint32_t)27U);
     399                 :          0 :   abcd[0U] = v19;
     400                 :          0 :   uint32_t va20 = abcd[3U];
     401                 :          0 :   uint32_t vb21 = abcd[0U];
     402                 :          0 :   uint32_t vc21 = abcd[1U];
     403                 :          0 :   uint32_t vd21 = abcd[2U];
     404                 :          0 :   uint8_t *b21 = x + (uint32_t)40U;
     405                 :          0 :   uint32_t u20 = load32_le(b21);
     406                 :          0 :   uint32_t xk20 = u20;
     407                 :          0 :   uint32_t ti21 = _t[21U];
     408                 :            :   uint32_t
     409                 :          0 :   v20 =
     410                 :            :     vb21
     411                 :            :     +
     412                 :          0 :       ((va20 + ((vb21 & vd21) | (vc21 & ~vd21)) + xk20 + ti21)
     413                 :            :       << (uint32_t)9U
     414                 :          0 :       | (va20 + ((vb21 & vd21) | (vc21 & ~vd21)) + xk20 + ti21) >> (uint32_t)23U);
     415                 :          0 :   abcd[3U] = v20;
     416                 :          0 :   uint32_t va21 = abcd[2U];
     417                 :          0 :   uint32_t vb22 = abcd[3U];
     418                 :          0 :   uint32_t vc22 = abcd[0U];
     419                 :          0 :   uint32_t vd22 = abcd[1U];
     420                 :          0 :   uint8_t *b22 = x + (uint32_t)60U;
     421                 :          0 :   uint32_t u21 = load32_le(b22);
     422                 :          0 :   uint32_t xk21 = u21;
     423                 :          0 :   uint32_t ti22 = _t[22U];
     424                 :            :   uint32_t
     425                 :          0 :   v21 =
     426                 :            :     vb22
     427                 :            :     +
     428                 :          0 :       ((va21 + ((vb22 & vd22) | (vc22 & ~vd22)) + xk21 + ti22)
     429                 :            :       << (uint32_t)14U
     430                 :          0 :       | (va21 + ((vb22 & vd22) | (vc22 & ~vd22)) + xk21 + ti22) >> (uint32_t)18U);
     431                 :          0 :   abcd[2U] = v21;
     432                 :          0 :   uint32_t va22 = abcd[1U];
     433                 :          0 :   uint32_t vb23 = abcd[2U];
     434                 :          0 :   uint32_t vc23 = abcd[3U];
     435                 :          0 :   uint32_t vd23 = abcd[0U];
     436                 :          0 :   uint8_t *b23 = x + (uint32_t)16U;
     437                 :          0 :   uint32_t u22 = load32_le(b23);
     438                 :          0 :   uint32_t xk22 = u22;
     439                 :          0 :   uint32_t ti23 = _t[23U];
     440                 :            :   uint32_t
     441                 :          0 :   v22 =
     442                 :            :     vb23
     443                 :            :     +
     444                 :          0 :       ((va22 + ((vb23 & vd23) | (vc23 & ~vd23)) + xk22 + ti23)
     445                 :            :       << (uint32_t)20U
     446                 :          0 :       | (va22 + ((vb23 & vd23) | (vc23 & ~vd23)) + xk22 + ti23) >> (uint32_t)12U);
     447                 :          0 :   abcd[1U] = v22;
     448                 :          0 :   uint32_t va23 = abcd[0U];
     449                 :          0 :   uint32_t vb24 = abcd[1U];
     450                 :          0 :   uint32_t vc24 = abcd[2U];
     451                 :          0 :   uint32_t vd24 = abcd[3U];
     452                 :          0 :   uint8_t *b24 = x + (uint32_t)36U;
     453                 :          0 :   uint32_t u23 = load32_le(b24);
     454                 :          0 :   uint32_t xk23 = u23;
     455                 :          0 :   uint32_t ti24 = _t[24U];
     456                 :            :   uint32_t
     457                 :          0 :   v23 =
     458                 :            :     vb24
     459                 :            :     +
     460                 :          0 :       ((va23 + ((vb24 & vd24) | (vc24 & ~vd24)) + xk23 + ti24)
     461                 :            :       << (uint32_t)5U
     462                 :          0 :       | (va23 + ((vb24 & vd24) | (vc24 & ~vd24)) + xk23 + ti24) >> (uint32_t)27U);
     463                 :          0 :   abcd[0U] = v23;
     464                 :          0 :   uint32_t va24 = abcd[3U];
     465                 :          0 :   uint32_t vb25 = abcd[0U];
     466                 :          0 :   uint32_t vc25 = abcd[1U];
     467                 :          0 :   uint32_t vd25 = abcd[2U];
     468                 :          0 :   uint8_t *b25 = x + (uint32_t)56U;
     469                 :          0 :   uint32_t u24 = load32_le(b25);
     470                 :          0 :   uint32_t xk24 = u24;
     471                 :          0 :   uint32_t ti25 = _t[25U];
     472                 :            :   uint32_t
     473                 :          0 :   v24 =
     474                 :            :     vb25
     475                 :            :     +
     476                 :          0 :       ((va24 + ((vb25 & vd25) | (vc25 & ~vd25)) + xk24 + ti25)
     477                 :            :       << (uint32_t)9U
     478                 :          0 :       | (va24 + ((vb25 & vd25) | (vc25 & ~vd25)) + xk24 + ti25) >> (uint32_t)23U);
     479                 :          0 :   abcd[3U] = v24;
     480                 :          0 :   uint32_t va25 = abcd[2U];
     481                 :          0 :   uint32_t vb26 = abcd[3U];
     482                 :          0 :   uint32_t vc26 = abcd[0U];
     483                 :          0 :   uint32_t vd26 = abcd[1U];
     484                 :          0 :   uint8_t *b26 = x + (uint32_t)12U;
     485                 :          0 :   uint32_t u25 = load32_le(b26);
     486                 :          0 :   uint32_t xk25 = u25;
     487                 :          0 :   uint32_t ti26 = _t[26U];
     488                 :            :   uint32_t
     489                 :          0 :   v25 =
     490                 :            :     vb26
     491                 :            :     +
     492                 :          0 :       ((va25 + ((vb26 & vd26) | (vc26 & ~vd26)) + xk25 + ti26)
     493                 :            :       << (uint32_t)14U
     494                 :          0 :       | (va25 + ((vb26 & vd26) | (vc26 & ~vd26)) + xk25 + ti26) >> (uint32_t)18U);
     495                 :          0 :   abcd[2U] = v25;
     496                 :          0 :   uint32_t va26 = abcd[1U];
     497                 :          0 :   uint32_t vb27 = abcd[2U];
     498                 :          0 :   uint32_t vc27 = abcd[3U];
     499                 :          0 :   uint32_t vd27 = abcd[0U];
     500                 :          0 :   uint8_t *b27 = x + (uint32_t)32U;
     501                 :          0 :   uint32_t u26 = load32_le(b27);
     502                 :          0 :   uint32_t xk26 = u26;
     503                 :          0 :   uint32_t ti27 = _t[27U];
     504                 :            :   uint32_t
     505                 :          0 :   v26 =
     506                 :            :     vb27
     507                 :            :     +
     508                 :          0 :       ((va26 + ((vb27 & vd27) | (vc27 & ~vd27)) + xk26 + ti27)
     509                 :            :       << (uint32_t)20U
     510                 :          0 :       | (va26 + ((vb27 & vd27) | (vc27 & ~vd27)) + xk26 + ti27) >> (uint32_t)12U);
     511                 :          0 :   abcd[1U] = v26;
     512                 :          0 :   uint32_t va27 = abcd[0U];
     513                 :          0 :   uint32_t vb28 = abcd[1U];
     514                 :          0 :   uint32_t vc28 = abcd[2U];
     515                 :          0 :   uint32_t vd28 = abcd[3U];
     516                 :          0 :   uint8_t *b28 = x + (uint32_t)52U;
     517                 :          0 :   uint32_t u27 = load32_le(b28);
     518                 :          0 :   uint32_t xk27 = u27;
     519                 :          0 :   uint32_t ti28 = _t[28U];
     520                 :            :   uint32_t
     521                 :          0 :   v27 =
     522                 :            :     vb28
     523                 :            :     +
     524                 :          0 :       ((va27 + ((vb28 & vd28) | (vc28 & ~vd28)) + xk27 + ti28)
     525                 :            :       << (uint32_t)5U
     526                 :          0 :       | (va27 + ((vb28 & vd28) | (vc28 & ~vd28)) + xk27 + ti28) >> (uint32_t)27U);
     527                 :          0 :   abcd[0U] = v27;
     528                 :          0 :   uint32_t va28 = abcd[3U];
     529                 :          0 :   uint32_t vb29 = abcd[0U];
     530                 :          0 :   uint32_t vc29 = abcd[1U];
     531                 :          0 :   uint32_t vd29 = abcd[2U];
     532                 :          0 :   uint8_t *b29 = x + (uint32_t)8U;
     533                 :          0 :   uint32_t u28 = load32_le(b29);
     534                 :          0 :   uint32_t xk28 = u28;
     535                 :          0 :   uint32_t ti29 = _t[29U];
     536                 :            :   uint32_t
     537                 :          0 :   v28 =
     538                 :            :     vb29
     539                 :            :     +
     540                 :          0 :       ((va28 + ((vb29 & vd29) | (vc29 & ~vd29)) + xk28 + ti29)
     541                 :            :       << (uint32_t)9U
     542                 :          0 :       | (va28 + ((vb29 & vd29) | (vc29 & ~vd29)) + xk28 + ti29) >> (uint32_t)23U);
     543                 :          0 :   abcd[3U] = v28;
     544                 :          0 :   uint32_t va29 = abcd[2U];
     545                 :          0 :   uint32_t vb30 = abcd[3U];
     546                 :          0 :   uint32_t vc30 = abcd[0U];
     547                 :          0 :   uint32_t vd30 = abcd[1U];
     548                 :          0 :   uint8_t *b30 = x + (uint32_t)28U;
     549                 :          0 :   uint32_t u29 = load32_le(b30);
     550                 :          0 :   uint32_t xk29 = u29;
     551                 :          0 :   uint32_t ti30 = _t[30U];
     552                 :            :   uint32_t
     553                 :          0 :   v29 =
     554                 :            :     vb30
     555                 :            :     +
     556                 :          0 :       ((va29 + ((vb30 & vd30) | (vc30 & ~vd30)) + xk29 + ti30)
     557                 :            :       << (uint32_t)14U
     558                 :          0 :       | (va29 + ((vb30 & vd30) | (vc30 & ~vd30)) + xk29 + ti30) >> (uint32_t)18U);
     559                 :          0 :   abcd[2U] = v29;
     560                 :          0 :   uint32_t va30 = abcd[1U];
     561                 :          0 :   uint32_t vb31 = abcd[2U];
     562                 :          0 :   uint32_t vc31 = abcd[3U];
     563                 :          0 :   uint32_t vd31 = abcd[0U];
     564                 :          0 :   uint8_t *b31 = x + (uint32_t)48U;
     565                 :          0 :   uint32_t u30 = load32_le(b31);
     566                 :          0 :   uint32_t xk30 = u30;
     567                 :          0 :   uint32_t ti31 = _t[31U];
     568                 :            :   uint32_t
     569                 :          0 :   v30 =
     570                 :            :     vb31
     571                 :            :     +
     572                 :          0 :       ((va30 + ((vb31 & vd31) | (vc31 & ~vd31)) + xk30 + ti31)
     573                 :            :       << (uint32_t)20U
     574                 :          0 :       | (va30 + ((vb31 & vd31) | (vc31 & ~vd31)) + xk30 + ti31) >> (uint32_t)12U);
     575                 :          0 :   abcd[1U] = v30;
     576                 :          0 :   uint32_t va31 = abcd[0U];
     577                 :          0 :   uint32_t vb32 = abcd[1U];
     578                 :          0 :   uint32_t vc32 = abcd[2U];
     579                 :          0 :   uint32_t vd32 = abcd[3U];
     580                 :          0 :   uint8_t *b32 = x + (uint32_t)20U;
     581                 :          0 :   uint32_t u31 = load32_le(b32);
     582                 :          0 :   uint32_t xk31 = u31;
     583                 :          0 :   uint32_t ti32 = _t[32U];
     584                 :            :   uint32_t
     585                 :          0 :   v31 =
     586                 :            :     vb32
     587                 :            :     +
     588                 :          0 :       ((va31 + (vb32 ^ (vc32 ^ vd32)) + xk31 + ti32)
     589                 :            :       << (uint32_t)4U
     590                 :          0 :       | (va31 + (vb32 ^ (vc32 ^ vd32)) + xk31 + ti32) >> (uint32_t)28U);
     591                 :          0 :   abcd[0U] = v31;
     592                 :          0 :   uint32_t va32 = abcd[3U];
     593                 :          0 :   uint32_t vb33 = abcd[0U];
     594                 :          0 :   uint32_t vc33 = abcd[1U];
     595                 :          0 :   uint32_t vd33 = abcd[2U];
     596                 :          0 :   uint8_t *b33 = x + (uint32_t)32U;
     597                 :          0 :   uint32_t u32 = load32_le(b33);
     598                 :          0 :   uint32_t xk32 = u32;
     599                 :          0 :   uint32_t ti33 = _t[33U];
     600                 :            :   uint32_t
     601                 :          0 :   v32 =
     602                 :            :     vb33
     603                 :            :     +
     604                 :          0 :       ((va32 + (vb33 ^ (vc33 ^ vd33)) + xk32 + ti33)
     605                 :            :       << (uint32_t)11U
     606                 :          0 :       | (va32 + (vb33 ^ (vc33 ^ vd33)) + xk32 + ti33) >> (uint32_t)21U);
     607                 :          0 :   abcd[3U] = v32;
     608                 :          0 :   uint32_t va33 = abcd[2U];
     609                 :          0 :   uint32_t vb34 = abcd[3U];
     610                 :          0 :   uint32_t vc34 = abcd[0U];
     611                 :          0 :   uint32_t vd34 = abcd[1U];
     612                 :          0 :   uint8_t *b34 = x + (uint32_t)44U;
     613                 :          0 :   uint32_t u33 = load32_le(b34);
     614                 :          0 :   uint32_t xk33 = u33;
     615                 :          0 :   uint32_t ti34 = _t[34U];
     616                 :            :   uint32_t
     617                 :          0 :   v33 =
     618                 :            :     vb34
     619                 :            :     +
     620                 :          0 :       ((va33 + (vb34 ^ (vc34 ^ vd34)) + xk33 + ti34)
     621                 :            :       << (uint32_t)16U
     622                 :          0 :       | (va33 + (vb34 ^ (vc34 ^ vd34)) + xk33 + ti34) >> (uint32_t)16U);
     623                 :          0 :   abcd[2U] = v33;
     624                 :          0 :   uint32_t va34 = abcd[1U];
     625                 :          0 :   uint32_t vb35 = abcd[2U];
     626                 :          0 :   uint32_t vc35 = abcd[3U];
     627                 :          0 :   uint32_t vd35 = abcd[0U];
     628                 :          0 :   uint8_t *b35 = x + (uint32_t)56U;
     629                 :          0 :   uint32_t u34 = load32_le(b35);
     630                 :          0 :   uint32_t xk34 = u34;
     631                 :          0 :   uint32_t ti35 = _t[35U];
     632                 :            :   uint32_t
     633                 :          0 :   v34 =
     634                 :            :     vb35
     635                 :            :     +
     636                 :          0 :       ((va34 + (vb35 ^ (vc35 ^ vd35)) + xk34 + ti35)
     637                 :            :       << (uint32_t)23U
     638                 :          0 :       | (va34 + (vb35 ^ (vc35 ^ vd35)) + xk34 + ti35) >> (uint32_t)9U);
     639                 :          0 :   abcd[1U] = v34;
     640                 :          0 :   uint32_t va35 = abcd[0U];
     641                 :          0 :   uint32_t vb36 = abcd[1U];
     642                 :          0 :   uint32_t vc36 = abcd[2U];
     643                 :          0 :   uint32_t vd36 = abcd[3U];
     644                 :          0 :   uint8_t *b36 = x + (uint32_t)4U;
     645                 :          0 :   uint32_t u35 = load32_le(b36);
     646                 :          0 :   uint32_t xk35 = u35;
     647                 :          0 :   uint32_t ti36 = _t[36U];
     648                 :            :   uint32_t
     649                 :          0 :   v35 =
     650                 :            :     vb36
     651                 :            :     +
     652                 :          0 :       ((va35 + (vb36 ^ (vc36 ^ vd36)) + xk35 + ti36)
     653                 :            :       << (uint32_t)4U
     654                 :          0 :       | (va35 + (vb36 ^ (vc36 ^ vd36)) + xk35 + ti36) >> (uint32_t)28U);
     655                 :          0 :   abcd[0U] = v35;
     656                 :          0 :   uint32_t va36 = abcd[3U];
     657                 :          0 :   uint32_t vb37 = abcd[0U];
     658                 :          0 :   uint32_t vc37 = abcd[1U];
     659                 :          0 :   uint32_t vd37 = abcd[2U];
     660                 :          0 :   uint8_t *b37 = x + (uint32_t)16U;
     661                 :          0 :   uint32_t u36 = load32_le(b37);
     662                 :          0 :   uint32_t xk36 = u36;
     663                 :          0 :   uint32_t ti37 = _t[37U];
     664                 :            :   uint32_t
     665                 :          0 :   v36 =
     666                 :            :     vb37
     667                 :            :     +
     668                 :          0 :       ((va36 + (vb37 ^ (vc37 ^ vd37)) + xk36 + ti37)
     669                 :            :       << (uint32_t)11U
     670                 :          0 :       | (va36 + (vb37 ^ (vc37 ^ vd37)) + xk36 + ti37) >> (uint32_t)21U);
     671                 :          0 :   abcd[3U] = v36;
     672                 :          0 :   uint32_t va37 = abcd[2U];
     673                 :          0 :   uint32_t vb38 = abcd[3U];
     674                 :          0 :   uint32_t vc38 = abcd[0U];
     675                 :          0 :   uint32_t vd38 = abcd[1U];
     676                 :          0 :   uint8_t *b38 = x + (uint32_t)28U;
     677                 :          0 :   uint32_t u37 = load32_le(b38);
     678                 :          0 :   uint32_t xk37 = u37;
     679                 :          0 :   uint32_t ti38 = _t[38U];
     680                 :            :   uint32_t
     681                 :          0 :   v37 =
     682                 :            :     vb38
     683                 :            :     +
     684                 :          0 :       ((va37 + (vb38 ^ (vc38 ^ vd38)) + xk37 + ti38)
     685                 :            :       << (uint32_t)16U
     686                 :          0 :       | (va37 + (vb38 ^ (vc38 ^ vd38)) + xk37 + ti38) >> (uint32_t)16U);
     687                 :          0 :   abcd[2U] = v37;
     688                 :          0 :   uint32_t va38 = abcd[1U];
     689                 :          0 :   uint32_t vb39 = abcd[2U];
     690                 :          0 :   uint32_t vc39 = abcd[3U];
     691                 :          0 :   uint32_t vd39 = abcd[0U];
     692                 :          0 :   uint8_t *b39 = x + (uint32_t)40U;
     693                 :          0 :   uint32_t u38 = load32_le(b39);
     694                 :          0 :   uint32_t xk38 = u38;
     695                 :          0 :   uint32_t ti39 = _t[39U];
     696                 :            :   uint32_t
     697                 :          0 :   v38 =
     698                 :            :     vb39
     699                 :            :     +
     700                 :          0 :       ((va38 + (vb39 ^ (vc39 ^ vd39)) + xk38 + ti39)
     701                 :            :       << (uint32_t)23U
     702                 :          0 :       | (va38 + (vb39 ^ (vc39 ^ vd39)) + xk38 + ti39) >> (uint32_t)9U);
     703                 :          0 :   abcd[1U] = v38;
     704                 :          0 :   uint32_t va39 = abcd[0U];
     705                 :          0 :   uint32_t vb40 = abcd[1U];
     706                 :          0 :   uint32_t vc40 = abcd[2U];
     707                 :          0 :   uint32_t vd40 = abcd[3U];
     708                 :          0 :   uint8_t *b40 = x + (uint32_t)52U;
     709                 :          0 :   uint32_t u39 = load32_le(b40);
     710                 :          0 :   uint32_t xk39 = u39;
     711                 :          0 :   uint32_t ti40 = _t[40U];
     712                 :            :   uint32_t
     713                 :          0 :   v39 =
     714                 :            :     vb40
     715                 :            :     +
     716                 :          0 :       ((va39 + (vb40 ^ (vc40 ^ vd40)) + xk39 + ti40)
     717                 :            :       << (uint32_t)4U
     718                 :          0 :       | (va39 + (vb40 ^ (vc40 ^ vd40)) + xk39 + ti40) >> (uint32_t)28U);
     719                 :          0 :   abcd[0U] = v39;
     720                 :          0 :   uint32_t va40 = abcd[3U];
     721                 :          0 :   uint32_t vb41 = abcd[0U];
     722                 :          0 :   uint32_t vc41 = abcd[1U];
     723                 :          0 :   uint32_t vd41 = abcd[2U];
     724                 :          0 :   uint8_t *b41 = x;
     725                 :          0 :   uint32_t u40 = load32_le(b41);
     726                 :          0 :   uint32_t xk40 = u40;
     727                 :          0 :   uint32_t ti41 = _t[41U];
     728                 :            :   uint32_t
     729                 :          0 :   v40 =
     730                 :            :     vb41
     731                 :            :     +
     732                 :          0 :       ((va40 + (vb41 ^ (vc41 ^ vd41)) + xk40 + ti41)
     733                 :            :       << (uint32_t)11U
     734                 :          0 :       | (va40 + (vb41 ^ (vc41 ^ vd41)) + xk40 + ti41) >> (uint32_t)21U);
     735                 :          0 :   abcd[3U] = v40;
     736                 :          0 :   uint32_t va41 = abcd[2U];
     737                 :          0 :   uint32_t vb42 = abcd[3U];
     738                 :          0 :   uint32_t vc42 = abcd[0U];
     739                 :          0 :   uint32_t vd42 = abcd[1U];
     740                 :          0 :   uint8_t *b42 = x + (uint32_t)12U;
     741                 :          0 :   uint32_t u41 = load32_le(b42);
     742                 :          0 :   uint32_t xk41 = u41;
     743                 :          0 :   uint32_t ti42 = _t[42U];
     744                 :            :   uint32_t
     745                 :          0 :   v41 =
     746                 :            :     vb42
     747                 :            :     +
     748                 :          0 :       ((va41 + (vb42 ^ (vc42 ^ vd42)) + xk41 + ti42)
     749                 :            :       << (uint32_t)16U
     750                 :          0 :       | (va41 + (vb42 ^ (vc42 ^ vd42)) + xk41 + ti42) >> (uint32_t)16U);
     751                 :          0 :   abcd[2U] = v41;
     752                 :          0 :   uint32_t va42 = abcd[1U];
     753                 :          0 :   uint32_t vb43 = abcd[2U];
     754                 :          0 :   uint32_t vc43 = abcd[3U];
     755                 :          0 :   uint32_t vd43 = abcd[0U];
     756                 :          0 :   uint8_t *b43 = x + (uint32_t)24U;
     757                 :          0 :   uint32_t u42 = load32_le(b43);
     758                 :          0 :   uint32_t xk42 = u42;
     759                 :          0 :   uint32_t ti43 = _t[43U];
     760                 :            :   uint32_t
     761                 :          0 :   v42 =
     762                 :            :     vb43
     763                 :            :     +
     764                 :          0 :       ((va42 + (vb43 ^ (vc43 ^ vd43)) + xk42 + ti43)
     765                 :            :       << (uint32_t)23U
     766                 :          0 :       | (va42 + (vb43 ^ (vc43 ^ vd43)) + xk42 + ti43) >> (uint32_t)9U);
     767                 :          0 :   abcd[1U] = v42;
     768                 :          0 :   uint32_t va43 = abcd[0U];
     769                 :          0 :   uint32_t vb44 = abcd[1U];
     770                 :          0 :   uint32_t vc44 = abcd[2U];
     771                 :          0 :   uint32_t vd44 = abcd[3U];
     772                 :          0 :   uint8_t *b44 = x + (uint32_t)36U;
     773                 :          0 :   uint32_t u43 = load32_le(b44);
     774                 :          0 :   uint32_t xk43 = u43;
     775                 :          0 :   uint32_t ti44 = _t[44U];
     776                 :            :   uint32_t
     777                 :          0 :   v43 =
     778                 :            :     vb44
     779                 :            :     +
     780                 :          0 :       ((va43 + (vb44 ^ (vc44 ^ vd44)) + xk43 + ti44)
     781                 :            :       << (uint32_t)4U
     782                 :          0 :       | (va43 + (vb44 ^ (vc44 ^ vd44)) + xk43 + ti44) >> (uint32_t)28U);
     783                 :          0 :   abcd[0U] = v43;
     784                 :          0 :   uint32_t va44 = abcd[3U];
     785                 :          0 :   uint32_t vb45 = abcd[0U];
     786                 :          0 :   uint32_t vc45 = abcd[1U];
     787                 :          0 :   uint32_t vd45 = abcd[2U];
     788                 :          0 :   uint8_t *b45 = x + (uint32_t)48U;
     789                 :          0 :   uint32_t u44 = load32_le(b45);
     790                 :          0 :   uint32_t xk44 = u44;
     791                 :          0 :   uint32_t ti45 = _t[45U];
     792                 :            :   uint32_t
     793                 :          0 :   v44 =
     794                 :            :     vb45
     795                 :            :     +
     796                 :          0 :       ((va44 + (vb45 ^ (vc45 ^ vd45)) + xk44 + ti45)
     797                 :            :       << (uint32_t)11U
     798                 :          0 :       | (va44 + (vb45 ^ (vc45 ^ vd45)) + xk44 + ti45) >> (uint32_t)21U);
     799                 :          0 :   abcd[3U] = v44;
     800                 :          0 :   uint32_t va45 = abcd[2U];
     801                 :          0 :   uint32_t vb46 = abcd[3U];
     802                 :          0 :   uint32_t vc46 = abcd[0U];
     803                 :          0 :   uint32_t vd46 = abcd[1U];
     804                 :          0 :   uint8_t *b46 = x + (uint32_t)60U;
     805                 :          0 :   uint32_t u45 = load32_le(b46);
     806                 :          0 :   uint32_t xk45 = u45;
     807                 :          0 :   uint32_t ti46 = _t[46U];
     808                 :            :   uint32_t
     809                 :          0 :   v45 =
     810                 :            :     vb46
     811                 :            :     +
     812                 :          0 :       ((va45 + (vb46 ^ (vc46 ^ vd46)) + xk45 + ti46)
     813                 :            :       << (uint32_t)16U
     814                 :          0 :       | (va45 + (vb46 ^ (vc46 ^ vd46)) + xk45 + ti46) >> (uint32_t)16U);
     815                 :          0 :   abcd[2U] = v45;
     816                 :          0 :   uint32_t va46 = abcd[1U];
     817                 :          0 :   uint32_t vb47 = abcd[2U];
     818                 :          0 :   uint32_t vc47 = abcd[3U];
     819                 :          0 :   uint32_t vd47 = abcd[0U];
     820                 :          0 :   uint8_t *b47 = x + (uint32_t)8U;
     821                 :          0 :   uint32_t u46 = load32_le(b47);
     822                 :          0 :   uint32_t xk46 = u46;
     823                 :          0 :   uint32_t ti47 = _t[47U];
     824                 :            :   uint32_t
     825                 :          0 :   v46 =
     826                 :            :     vb47
     827                 :            :     +
     828                 :          0 :       ((va46 + (vb47 ^ (vc47 ^ vd47)) + xk46 + ti47)
     829                 :            :       << (uint32_t)23U
     830                 :          0 :       | (va46 + (vb47 ^ (vc47 ^ vd47)) + xk46 + ti47) >> (uint32_t)9U);
     831                 :          0 :   abcd[1U] = v46;
     832                 :          0 :   uint32_t va47 = abcd[0U];
     833                 :          0 :   uint32_t vb48 = abcd[1U];
     834                 :          0 :   uint32_t vc48 = abcd[2U];
     835                 :          0 :   uint32_t vd48 = abcd[3U];
     836                 :          0 :   uint8_t *b48 = x;
     837                 :          0 :   uint32_t u47 = load32_le(b48);
     838                 :          0 :   uint32_t xk47 = u47;
     839                 :          0 :   uint32_t ti48 = _t[48U];
     840                 :            :   uint32_t
     841                 :          0 :   v47 =
     842                 :            :     vb48
     843                 :            :     +
     844                 :          0 :       ((va47 + (vc48 ^ (vb48 | ~vd48)) + xk47 + ti48)
     845                 :            :       << (uint32_t)6U
     846                 :          0 :       | (va47 + (vc48 ^ (vb48 | ~vd48)) + xk47 + ti48) >> (uint32_t)26U);
     847                 :          0 :   abcd[0U] = v47;
     848                 :          0 :   uint32_t va48 = abcd[3U];
     849                 :          0 :   uint32_t vb49 = abcd[0U];
     850                 :          0 :   uint32_t vc49 = abcd[1U];
     851                 :          0 :   uint32_t vd49 = abcd[2U];
     852                 :          0 :   uint8_t *b49 = x + (uint32_t)28U;
     853                 :          0 :   uint32_t u48 = load32_le(b49);
     854                 :          0 :   uint32_t xk48 = u48;
     855                 :          0 :   uint32_t ti49 = _t[49U];
     856                 :            :   uint32_t
     857                 :          0 :   v48 =
     858                 :            :     vb49
     859                 :            :     +
     860                 :          0 :       ((va48 + (vc49 ^ (vb49 | ~vd49)) + xk48 + ti49)
     861                 :            :       << (uint32_t)10U
     862                 :          0 :       | (va48 + (vc49 ^ (vb49 | ~vd49)) + xk48 + ti49) >> (uint32_t)22U);
     863                 :          0 :   abcd[3U] = v48;
     864                 :          0 :   uint32_t va49 = abcd[2U];
     865                 :          0 :   uint32_t vb50 = abcd[3U];
     866                 :          0 :   uint32_t vc50 = abcd[0U];
     867                 :          0 :   uint32_t vd50 = abcd[1U];
     868                 :          0 :   uint8_t *b50 = x + (uint32_t)56U;
     869                 :          0 :   uint32_t u49 = load32_le(b50);
     870                 :          0 :   uint32_t xk49 = u49;
     871                 :          0 :   uint32_t ti50 = _t[50U];
     872                 :            :   uint32_t
     873                 :          0 :   v49 =
     874                 :            :     vb50
     875                 :            :     +
     876                 :          0 :       ((va49 + (vc50 ^ (vb50 | ~vd50)) + xk49 + ti50)
     877                 :            :       << (uint32_t)15U
     878                 :          0 :       | (va49 + (vc50 ^ (vb50 | ~vd50)) + xk49 + ti50) >> (uint32_t)17U);
     879                 :          0 :   abcd[2U] = v49;
     880                 :          0 :   uint32_t va50 = abcd[1U];
     881                 :          0 :   uint32_t vb51 = abcd[2U];
     882                 :          0 :   uint32_t vc51 = abcd[3U];
     883                 :          0 :   uint32_t vd51 = abcd[0U];
     884                 :          0 :   uint8_t *b51 = x + (uint32_t)20U;
     885                 :          0 :   uint32_t u50 = load32_le(b51);
     886                 :          0 :   uint32_t xk50 = u50;
     887                 :          0 :   uint32_t ti51 = _t[51U];
     888                 :            :   uint32_t
     889                 :          0 :   v50 =
     890                 :            :     vb51
     891                 :            :     +
     892                 :          0 :       ((va50 + (vc51 ^ (vb51 | ~vd51)) + xk50 + ti51)
     893                 :            :       << (uint32_t)21U
     894                 :          0 :       | (va50 + (vc51 ^ (vb51 | ~vd51)) + xk50 + ti51) >> (uint32_t)11U);
     895                 :          0 :   abcd[1U] = v50;
     896                 :          0 :   uint32_t va51 = abcd[0U];
     897                 :          0 :   uint32_t vb52 = abcd[1U];
     898                 :          0 :   uint32_t vc52 = abcd[2U];
     899                 :          0 :   uint32_t vd52 = abcd[3U];
     900                 :          0 :   uint8_t *b52 = x + (uint32_t)48U;
     901                 :          0 :   uint32_t u51 = load32_le(b52);
     902                 :          0 :   uint32_t xk51 = u51;
     903                 :          0 :   uint32_t ti52 = _t[52U];
     904                 :            :   uint32_t
     905                 :          0 :   v51 =
     906                 :            :     vb52
     907                 :            :     +
     908                 :          0 :       ((va51 + (vc52 ^ (vb52 | ~vd52)) + xk51 + ti52)
     909                 :            :       << (uint32_t)6U
     910                 :          0 :       | (va51 + (vc52 ^ (vb52 | ~vd52)) + xk51 + ti52) >> (uint32_t)26U);
     911                 :          0 :   abcd[0U] = v51;
     912                 :          0 :   uint32_t va52 = abcd[3U];
     913                 :          0 :   uint32_t vb53 = abcd[0U];
     914                 :          0 :   uint32_t vc53 = abcd[1U];
     915                 :          0 :   uint32_t vd53 = abcd[2U];
     916                 :          0 :   uint8_t *b53 = x + (uint32_t)12U;
     917                 :          0 :   uint32_t u52 = load32_le(b53);
     918                 :          0 :   uint32_t xk52 = u52;
     919                 :          0 :   uint32_t ti53 = _t[53U];
     920                 :            :   uint32_t
     921                 :          0 :   v52 =
     922                 :            :     vb53
     923                 :            :     +
     924                 :          0 :       ((va52 + (vc53 ^ (vb53 | ~vd53)) + xk52 + ti53)
     925                 :            :       << (uint32_t)10U
     926                 :          0 :       | (va52 + (vc53 ^ (vb53 | ~vd53)) + xk52 + ti53) >> (uint32_t)22U);
     927                 :          0 :   abcd[3U] = v52;
     928                 :          0 :   uint32_t va53 = abcd[2U];
     929                 :          0 :   uint32_t vb54 = abcd[3U];
     930                 :          0 :   uint32_t vc54 = abcd[0U];
     931                 :          0 :   uint32_t vd54 = abcd[1U];
     932                 :          0 :   uint8_t *b54 = x + (uint32_t)40U;
     933                 :          0 :   uint32_t u53 = load32_le(b54);
     934                 :          0 :   uint32_t xk53 = u53;
     935                 :          0 :   uint32_t ti54 = _t[54U];
     936                 :            :   uint32_t
     937                 :          0 :   v53 =
     938                 :            :     vb54
     939                 :            :     +
     940                 :          0 :       ((va53 + (vc54 ^ (vb54 | ~vd54)) + xk53 + ti54)
     941                 :            :       << (uint32_t)15U
     942                 :          0 :       | (va53 + (vc54 ^ (vb54 | ~vd54)) + xk53 + ti54) >> (uint32_t)17U);
     943                 :          0 :   abcd[2U] = v53;
     944                 :          0 :   uint32_t va54 = abcd[1U];
     945                 :          0 :   uint32_t vb55 = abcd[2U];
     946                 :          0 :   uint32_t vc55 = abcd[3U];
     947                 :          0 :   uint32_t vd55 = abcd[0U];
     948                 :          0 :   uint8_t *b55 = x + (uint32_t)4U;
     949                 :          0 :   uint32_t u54 = load32_le(b55);
     950                 :          0 :   uint32_t xk54 = u54;
     951                 :          0 :   uint32_t ti55 = _t[55U];
     952                 :            :   uint32_t
     953                 :          0 :   v54 =
     954                 :            :     vb55
     955                 :            :     +
     956                 :          0 :       ((va54 + (vc55 ^ (vb55 | ~vd55)) + xk54 + ti55)
     957                 :            :       << (uint32_t)21U
     958                 :          0 :       | (va54 + (vc55 ^ (vb55 | ~vd55)) + xk54 + ti55) >> (uint32_t)11U);
     959                 :          0 :   abcd[1U] = v54;
     960                 :          0 :   uint32_t va55 = abcd[0U];
     961                 :          0 :   uint32_t vb56 = abcd[1U];
     962                 :          0 :   uint32_t vc56 = abcd[2U];
     963                 :          0 :   uint32_t vd56 = abcd[3U];
     964                 :          0 :   uint8_t *b56 = x + (uint32_t)32U;
     965                 :          0 :   uint32_t u55 = load32_le(b56);
     966                 :          0 :   uint32_t xk55 = u55;
     967                 :          0 :   uint32_t ti56 = _t[56U];
     968                 :            :   uint32_t
     969                 :          0 :   v55 =
     970                 :            :     vb56
     971                 :            :     +
     972                 :          0 :       ((va55 + (vc56 ^ (vb56 | ~vd56)) + xk55 + ti56)
     973                 :            :       << (uint32_t)6U
     974                 :          0 :       | (va55 + (vc56 ^ (vb56 | ~vd56)) + xk55 + ti56) >> (uint32_t)26U);
     975                 :          0 :   abcd[0U] = v55;
     976                 :          0 :   uint32_t va56 = abcd[3U];
     977                 :          0 :   uint32_t vb57 = abcd[0U];
     978                 :          0 :   uint32_t vc57 = abcd[1U];
     979                 :          0 :   uint32_t vd57 = abcd[2U];
     980                 :          0 :   uint8_t *b57 = x + (uint32_t)60U;
     981                 :          0 :   uint32_t u56 = load32_le(b57);
     982                 :          0 :   uint32_t xk56 = u56;
     983                 :          0 :   uint32_t ti57 = _t[57U];
     984                 :            :   uint32_t
     985                 :          0 :   v56 =
     986                 :            :     vb57
     987                 :            :     +
     988                 :          0 :       ((va56 + (vc57 ^ (vb57 | ~vd57)) + xk56 + ti57)
     989                 :            :       << (uint32_t)10U
     990                 :          0 :       | (va56 + (vc57 ^ (vb57 | ~vd57)) + xk56 + ti57) >> (uint32_t)22U);
     991                 :          0 :   abcd[3U] = v56;
     992                 :          0 :   uint32_t va57 = abcd[2U];
     993                 :          0 :   uint32_t vb58 = abcd[3U];
     994                 :          0 :   uint32_t vc58 = abcd[0U];
     995                 :          0 :   uint32_t vd58 = abcd[1U];
     996                 :          0 :   uint8_t *b58 = x + (uint32_t)24U;
     997                 :          0 :   uint32_t u57 = load32_le(b58);
     998                 :          0 :   uint32_t xk57 = u57;
     999                 :          0 :   uint32_t ti58 = _t[58U];
    1000                 :            :   uint32_t
    1001                 :          0 :   v57 =
    1002                 :            :     vb58
    1003                 :            :     +
    1004                 :          0 :       ((va57 + (vc58 ^ (vb58 | ~vd58)) + xk57 + ti58)
    1005                 :            :       << (uint32_t)15U
    1006                 :          0 :       | (va57 + (vc58 ^ (vb58 | ~vd58)) + xk57 + ti58) >> (uint32_t)17U);
    1007                 :          0 :   abcd[2U] = v57;
    1008                 :          0 :   uint32_t va58 = abcd[1U];
    1009                 :          0 :   uint32_t vb59 = abcd[2U];
    1010                 :          0 :   uint32_t vc59 = abcd[3U];
    1011                 :          0 :   uint32_t vd59 = abcd[0U];
    1012                 :          0 :   uint8_t *b59 = x + (uint32_t)52U;
    1013                 :          0 :   uint32_t u58 = load32_le(b59);
    1014                 :          0 :   uint32_t xk58 = u58;
    1015                 :          0 :   uint32_t ti59 = _t[59U];
    1016                 :            :   uint32_t
    1017                 :          0 :   v58 =
    1018                 :            :     vb59
    1019                 :            :     +
    1020                 :          0 :       ((va58 + (vc59 ^ (vb59 | ~vd59)) + xk58 + ti59)
    1021                 :            :       << (uint32_t)21U
    1022                 :          0 :       | (va58 + (vc59 ^ (vb59 | ~vd59)) + xk58 + ti59) >> (uint32_t)11U);
    1023                 :          0 :   abcd[1U] = v58;
    1024                 :          0 :   uint32_t va59 = abcd[0U];
    1025                 :          0 :   uint32_t vb60 = abcd[1U];
    1026                 :          0 :   uint32_t vc60 = abcd[2U];
    1027                 :          0 :   uint32_t vd60 = abcd[3U];
    1028                 :          0 :   uint8_t *b60 = x + (uint32_t)16U;
    1029                 :          0 :   uint32_t u59 = load32_le(b60);
    1030                 :          0 :   uint32_t xk59 = u59;
    1031                 :          0 :   uint32_t ti60 = _t[60U];
    1032                 :            :   uint32_t
    1033                 :          0 :   v59 =
    1034                 :            :     vb60
    1035                 :            :     +
    1036                 :          0 :       ((va59 + (vc60 ^ (vb60 | ~vd60)) + xk59 + ti60)
    1037                 :            :       << (uint32_t)6U
    1038                 :          0 :       | (va59 + (vc60 ^ (vb60 | ~vd60)) + xk59 + ti60) >> (uint32_t)26U);
    1039                 :          0 :   abcd[0U] = v59;
    1040                 :          0 :   uint32_t va60 = abcd[3U];
    1041                 :          0 :   uint32_t vb61 = abcd[0U];
    1042                 :          0 :   uint32_t vc61 = abcd[1U];
    1043                 :          0 :   uint32_t vd61 = abcd[2U];
    1044                 :          0 :   uint8_t *b61 = x + (uint32_t)44U;
    1045                 :          0 :   uint32_t u60 = load32_le(b61);
    1046                 :          0 :   uint32_t xk60 = u60;
    1047                 :          0 :   uint32_t ti61 = _t[61U];
    1048                 :            :   uint32_t
    1049                 :          0 :   v60 =
    1050                 :            :     vb61
    1051                 :            :     +
    1052                 :          0 :       ((va60 + (vc61 ^ (vb61 | ~vd61)) + xk60 + ti61)
    1053                 :            :       << (uint32_t)10U
    1054                 :          0 :       | (va60 + (vc61 ^ (vb61 | ~vd61)) + xk60 + ti61) >> (uint32_t)22U);
    1055                 :          0 :   abcd[3U] = v60;
    1056                 :          0 :   uint32_t va61 = abcd[2U];
    1057                 :          0 :   uint32_t vb62 = abcd[3U];
    1058                 :          0 :   uint32_t vc62 = abcd[0U];
    1059                 :          0 :   uint32_t vd62 = abcd[1U];
    1060                 :          0 :   uint8_t *b62 = x + (uint32_t)8U;
    1061                 :          0 :   uint32_t u61 = load32_le(b62);
    1062                 :          0 :   uint32_t xk61 = u61;
    1063                 :          0 :   uint32_t ti62 = _t[62U];
    1064                 :            :   uint32_t
    1065                 :          0 :   v61 =
    1066                 :            :     vb62
    1067                 :            :     +
    1068                 :          0 :       ((va61 + (vc62 ^ (vb62 | ~vd62)) + xk61 + ti62)
    1069                 :            :       << (uint32_t)15U
    1070                 :          0 :       | (va61 + (vc62 ^ (vb62 | ~vd62)) + xk61 + ti62) >> (uint32_t)17U);
    1071                 :          0 :   abcd[2U] = v61;
    1072                 :          0 :   uint32_t va62 = abcd[1U];
    1073                 :          0 :   uint32_t vb = abcd[2U];
    1074                 :          0 :   uint32_t vc = abcd[3U];
    1075                 :          0 :   uint32_t vd = abcd[0U];
    1076                 :          0 :   uint8_t *b63 = x + (uint32_t)36U;
    1077                 :          0 :   uint32_t u62 = load32_le(b63);
    1078                 :          0 :   uint32_t xk62 = u62;
    1079                 :          0 :   uint32_t ti = _t[63U];
    1080                 :            :   uint32_t
    1081                 :          0 :   v62 =
    1082                 :            :     vb
    1083                 :            :     +
    1084                 :          0 :       ((va62 + (vc ^ (vb | ~vd)) + xk62 + ti)
    1085                 :            :       << (uint32_t)21U
    1086                 :          0 :       | (va62 + (vc ^ (vb | ~vd)) + xk62 + ti) >> (uint32_t)11U);
    1087                 :          0 :   abcd[1U] = v62;
    1088                 :          0 :   uint32_t a = abcd[0U];
    1089                 :          0 :   uint32_t b = abcd[1U];
    1090                 :          0 :   uint32_t c = abcd[2U];
    1091                 :          0 :   uint32_t d = abcd[3U];
    1092                 :          0 :   abcd[0U] = a + aa;
    1093                 :          0 :   abcd[1U] = b + bb;
    1094                 :          0 :   abcd[2U] = c + cc;
    1095                 :          0 :   abcd[3U] = d + dd;
    1096                 :          0 : }
    1097                 :            : 
    1098                 :          0 : static void legacy_pad(uint64_t len, uint8_t *dst)
    1099                 :            : {
    1100                 :          0 :   uint8_t *dst1 = dst;
    1101                 :          0 :   dst1[0U] = (uint8_t)0x80U;
    1102                 :          0 :   uint8_t *dst2 = dst + (uint32_t)1U;
    1103                 :          0 :   for
    1104                 :            :   (uint32_t
    1105                 :          0 :     i = (uint32_t)0U;
    1106                 :            :     i
    1107         [ #  # ]:          0 :     < ((uint32_t)128U - ((uint32_t)9U + (uint32_t)(len % (uint64_t)(uint32_t)64U))) % (uint32_t)64U;
    1108                 :          0 :     i++)
    1109                 :            :   {
    1110                 :          0 :     dst2[i] = (uint8_t)0U;
    1111                 :            :   }
    1112                 :            :   uint8_t
    1113                 :          0 :   *dst3 =
    1114                 :            :     dst
    1115                 :            :     +
    1116                 :            :       (uint32_t)1U
    1117                 :          0 :       +
    1118                 :          0 :         ((uint32_t)128U - ((uint32_t)9U + (uint32_t)(len % (uint64_t)(uint32_t)64U)))
    1119                 :          0 :         % (uint32_t)64U;
    1120                 :          0 :   store64_le(dst3, len << (uint32_t)3U);
    1121                 :          0 : }
    1122                 :            : 
    1123                 :          0 : void Hacl_Hash_Core_MD5_legacy_finish(uint32_t *s, uint8_t *dst)
    1124                 :            : {
    1125                 :          0 :   KRML_MAYBE_FOR4(i,
    1126                 :            :     (uint32_t)0U,
    1127                 :            :     (uint32_t)4U,
    1128                 :            :     (uint32_t)1U,
    1129                 :            :     store32_le(dst + i * (uint32_t)4U, s[i]););
    1130                 :          0 : }
    1131                 :            : 
    1132                 :          0 : void Hacl_Hash_MD5_legacy_update_multi(uint32_t *s, uint8_t *blocks, uint32_t n_blocks)
    1133                 :            : {
    1134         [ #  # ]:          0 :   for (uint32_t i = (uint32_t)0U; i < n_blocks; i++)
    1135                 :            :   {
    1136                 :          0 :     uint32_t sz = (uint32_t)64U;
    1137                 :          0 :     uint8_t *block = blocks + sz * i;
    1138                 :          0 :     legacy_update(s, block);
    1139                 :            :   }
    1140                 :          0 : }
    1141                 :            : 
    1142                 :            : void
    1143                 :          0 : Hacl_Hash_MD5_legacy_update_last(
    1144                 :            :   uint32_t *s,
    1145                 :            :   uint64_t prev_len,
    1146                 :            :   uint8_t *input,
    1147                 :            :   uint32_t input_len
    1148                 :            : )
    1149                 :            : {
    1150                 :          0 :   uint32_t blocks_n = input_len / (uint32_t)64U;
    1151                 :          0 :   uint32_t blocks_len = blocks_n * (uint32_t)64U;
    1152                 :          0 :   uint8_t *blocks = input;
    1153                 :          0 :   uint32_t rest_len = input_len - blocks_len;
    1154                 :          0 :   uint8_t *rest = input + blocks_len;
    1155                 :          0 :   Hacl_Hash_MD5_legacy_update_multi(s, blocks, blocks_n);
    1156                 :          0 :   uint64_t total_input_len = prev_len + (uint64_t)input_len;
    1157                 :            :   uint32_t
    1158                 :          0 :   pad_len =
    1159                 :            :     (uint32_t)1U
    1160                 :            :     +
    1161                 :          0 :       ((uint32_t)128U - ((uint32_t)9U + (uint32_t)(total_input_len % (uint64_t)(uint32_t)64U)))
    1162                 :          0 :       % (uint32_t)64U
    1163                 :            :     + (uint32_t)8U;
    1164                 :          0 :   uint32_t tmp_len = rest_len + pad_len;
    1165                 :          0 :   uint8_t tmp_twoblocks[128U] = { 0U };
    1166                 :          0 :   uint8_t *tmp = tmp_twoblocks;
    1167                 :          0 :   uint8_t *tmp_rest = tmp;
    1168                 :          0 :   uint8_t *tmp_pad = tmp + rest_len;
    1169                 :          0 :   memcpy(tmp_rest, rest, rest_len * sizeof (uint8_t));
    1170                 :          0 :   legacy_pad(total_input_len, tmp_pad);
    1171                 :          0 :   Hacl_Hash_MD5_legacy_update_multi(s, tmp, tmp_len / (uint32_t)64U);
    1172                 :          0 : }
    1173                 :            : 
    1174                 :          0 : void Hacl_Hash_MD5_legacy_hash(uint8_t *input, uint32_t input_len, uint8_t *dst)
    1175                 :            : {
    1176                 :            :   uint32_t
    1177                 :          0 :   s[4U] =
    1178                 :            :     { (uint32_t)0x67452301U, (uint32_t)0xefcdab89U, (uint32_t)0x98badcfeU, (uint32_t)0x10325476U };
    1179                 :          0 :   uint32_t blocks_n0 = input_len / (uint32_t)64U;
    1180                 :            :   uint32_t blocks_n1;
    1181   [ #  #  #  # ]:          0 :   if (input_len % (uint32_t)64U == (uint32_t)0U && blocks_n0 > (uint32_t)0U)
    1182                 :            :   {
    1183                 :          0 :     blocks_n1 = blocks_n0 - (uint32_t)1U;
    1184                 :            :   }
    1185                 :            :   else
    1186                 :            :   {
    1187                 :          0 :     blocks_n1 = blocks_n0;
    1188                 :            :   }
    1189                 :          0 :   uint32_t blocks_len0 = blocks_n1 * (uint32_t)64U;
    1190                 :          0 :   uint8_t *blocks0 = input;
    1191                 :          0 :   uint32_t rest_len0 = input_len - blocks_len0;
    1192                 :          0 :   uint8_t *rest0 = input + blocks_len0;
    1193                 :          0 :   uint32_t blocks_n = blocks_n1;
    1194                 :          0 :   uint32_t blocks_len = blocks_len0;
    1195                 :          0 :   uint8_t *blocks = blocks0;
    1196                 :          0 :   uint32_t rest_len = rest_len0;
    1197                 :          0 :   uint8_t *rest = rest0;
    1198                 :          0 :   Hacl_Hash_MD5_legacy_update_multi(s, blocks, blocks_n);
    1199                 :          0 :   Hacl_Hash_MD5_legacy_update_last(s, (uint64_t)blocks_len, rest, rest_len);
    1200                 :          0 :   Hacl_Hash_Core_MD5_legacy_finish(s, dst);
    1201                 :          0 : }
    1202                 :            : 
    1203                 :          0 : Hacl_Streaming_MD_state_32 *Hacl_Streaming_MD5_legacy_create_in(void)
    1204                 :            : {
    1205                 :          0 :   uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC((uint32_t)64U, sizeof (uint8_t));
    1206                 :          0 :   uint32_t *block_state = (uint32_t *)KRML_HOST_CALLOC((uint32_t)4U, sizeof (uint32_t));
    1207                 :            :   Hacl_Streaming_MD_state_32
    1208                 :          0 :   s = { .block_state = block_state, .buf = buf, .total_len = (uint64_t)(uint32_t)0U };
    1209                 :            :   Hacl_Streaming_MD_state_32
    1210                 :          0 :   *p = (Hacl_Streaming_MD_state_32 *)KRML_HOST_MALLOC(sizeof (Hacl_Streaming_MD_state_32));
    1211                 :          0 :   p[0U] = s;
    1212                 :          0 :   Hacl_Hash_Core_MD5_legacy_init(block_state);
    1213                 :          0 :   return p;
    1214                 :            : }
    1215                 :            : 
    1216                 :          0 : void Hacl_Streaming_MD5_legacy_init(Hacl_Streaming_MD_state_32 *s)
    1217                 :            : {
    1218                 :          0 :   Hacl_Streaming_MD_state_32 scrut = *s;
    1219                 :          0 :   uint8_t *buf = scrut.buf;
    1220                 :          0 :   uint32_t *block_state = scrut.block_state;
    1221                 :          0 :   Hacl_Hash_Core_MD5_legacy_init(block_state);
    1222                 :            :   Hacl_Streaming_MD_state_32
    1223                 :          0 :   tmp = { .block_state = block_state, .buf = buf, .total_len = (uint64_t)(uint32_t)0U };
    1224                 :          0 :   s[0U] = tmp;
    1225                 :          0 : }
    1226                 :            : 
    1227                 :            : /**
    1228                 :            : 0 = success, 1 = max length exceeded
    1229                 :            : */
    1230                 :            : uint32_t
    1231                 :          0 : Hacl_Streaming_MD5_legacy_update(Hacl_Streaming_MD_state_32 *p, uint8_t *data, uint32_t len)
    1232                 :            : {
    1233                 :          0 :   Hacl_Streaming_MD_state_32 s = *p;
    1234                 :          0 :   uint64_t total_len = s.total_len;
    1235         [ #  # ]:          0 :   if ((uint64_t)len > (uint64_t)2305843009213693951U - total_len)
    1236                 :            :   {
    1237                 :          0 :     return (uint32_t)1U;
    1238                 :            :   }
    1239                 :            :   uint32_t sz;
    1240   [ #  #  #  # ]:          0 :   if (total_len % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len > (uint64_t)0U)
    1241                 :            :   {
    1242                 :          0 :     sz = (uint32_t)64U;
    1243                 :            :   }
    1244                 :            :   else
    1245                 :            :   {
    1246                 :          0 :     sz = (uint32_t)(total_len % (uint64_t)(uint32_t)64U);
    1247                 :            :   }
    1248         [ #  # ]:          0 :   if (len <= (uint32_t)64U - sz)
    1249                 :            :   {
    1250                 :          0 :     Hacl_Streaming_MD_state_32 s1 = *p;
    1251                 :          0 :     uint32_t *block_state1 = s1.block_state;
    1252                 :          0 :     uint8_t *buf = s1.buf;
    1253                 :          0 :     uint64_t total_len1 = s1.total_len;
    1254                 :            :     uint32_t sz1;
    1255   [ #  #  #  # ]:          0 :     if (total_len1 % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len1 > (uint64_t)0U)
    1256                 :            :     {
    1257                 :          0 :       sz1 = (uint32_t)64U;
    1258                 :            :     }
    1259                 :            :     else
    1260                 :            :     {
    1261                 :          0 :       sz1 = (uint32_t)(total_len1 % (uint64_t)(uint32_t)64U);
    1262                 :            :     }
    1263                 :          0 :     uint8_t *buf2 = buf + sz1;
    1264                 :          0 :     memcpy(buf2, data, len * sizeof (uint8_t));
    1265                 :          0 :     uint64_t total_len2 = total_len1 + (uint64_t)len;
    1266                 :            :     *p
    1267                 :          0 :     =
    1268                 :            :       (
    1269                 :            :         (Hacl_Streaming_MD_state_32){
    1270                 :            :           .block_state = block_state1,
    1271                 :            :           .buf = buf,
    1272                 :            :           .total_len = total_len2
    1273                 :            :         }
    1274                 :            :       );
    1275                 :            :   }
    1276         [ #  # ]:          0 :   else if (sz == (uint32_t)0U)
    1277                 :            :   {
    1278                 :          0 :     Hacl_Streaming_MD_state_32 s1 = *p;
    1279                 :          0 :     uint32_t *block_state1 = s1.block_state;
    1280                 :          0 :     uint8_t *buf = s1.buf;
    1281                 :          0 :     uint64_t total_len1 = s1.total_len;
    1282                 :            :     uint32_t sz1;
    1283   [ #  #  #  # ]:          0 :     if (total_len1 % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len1 > (uint64_t)0U)
    1284                 :            :     {
    1285                 :          0 :       sz1 = (uint32_t)64U;
    1286                 :            :     }
    1287                 :            :     else
    1288                 :            :     {
    1289                 :          0 :       sz1 = (uint32_t)(total_len1 % (uint64_t)(uint32_t)64U);
    1290                 :            :     }
    1291         [ #  # ]:          0 :     if (!(sz1 == (uint32_t)0U))
    1292                 :            :     {
    1293                 :          0 :       Hacl_Hash_MD5_legacy_update_multi(block_state1, buf, (uint32_t)1U);
    1294                 :            :     }
    1295                 :            :     uint32_t ite;
    1296   [ #  #  #  # ]:          0 :     if ((uint64_t)len % (uint64_t)(uint32_t)64U == (uint64_t)0U && (uint64_t)len > (uint64_t)0U)
    1297                 :            :     {
    1298                 :          0 :       ite = (uint32_t)64U;
    1299                 :            :     }
    1300                 :            :     else
    1301                 :            :     {
    1302                 :          0 :       ite = (uint32_t)((uint64_t)len % (uint64_t)(uint32_t)64U);
    1303                 :            :     }
    1304                 :          0 :     uint32_t n_blocks = (len - ite) / (uint32_t)64U;
    1305                 :          0 :     uint32_t data1_len = n_blocks * (uint32_t)64U;
    1306                 :          0 :     uint32_t data2_len = len - data1_len;
    1307                 :          0 :     uint8_t *data1 = data;
    1308                 :          0 :     uint8_t *data2 = data + data1_len;
    1309                 :          0 :     Hacl_Hash_MD5_legacy_update_multi(block_state1, data1, data1_len / (uint32_t)64U);
    1310                 :          0 :     uint8_t *dst = buf;
    1311                 :          0 :     memcpy(dst, data2, data2_len * sizeof (uint8_t));
    1312                 :            :     *p
    1313                 :          0 :     =
    1314                 :            :       (
    1315                 :            :         (Hacl_Streaming_MD_state_32){
    1316                 :            :           .block_state = block_state1,
    1317                 :            :           .buf = buf,
    1318                 :          0 :           .total_len = total_len1 + (uint64_t)len
    1319                 :            :         }
    1320                 :            :       );
    1321                 :            :   }
    1322                 :            :   else
    1323                 :            :   {
    1324                 :          0 :     uint32_t diff = (uint32_t)64U - sz;
    1325                 :          0 :     uint8_t *data1 = data;
    1326                 :          0 :     uint8_t *data2 = data + diff;
    1327                 :          0 :     Hacl_Streaming_MD_state_32 s1 = *p;
    1328                 :          0 :     uint32_t *block_state10 = s1.block_state;
    1329                 :          0 :     uint8_t *buf0 = s1.buf;
    1330                 :          0 :     uint64_t total_len10 = s1.total_len;
    1331                 :            :     uint32_t sz10;
    1332   [ #  #  #  # ]:          0 :     if (total_len10 % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len10 > (uint64_t)0U)
    1333                 :            :     {
    1334                 :          0 :       sz10 = (uint32_t)64U;
    1335                 :            :     }
    1336                 :            :     else
    1337                 :            :     {
    1338                 :          0 :       sz10 = (uint32_t)(total_len10 % (uint64_t)(uint32_t)64U);
    1339                 :            :     }
    1340                 :          0 :     uint8_t *buf2 = buf0 + sz10;
    1341                 :          0 :     memcpy(buf2, data1, diff * sizeof (uint8_t));
    1342                 :          0 :     uint64_t total_len2 = total_len10 + (uint64_t)diff;
    1343                 :            :     *p
    1344                 :          0 :     =
    1345                 :            :       (
    1346                 :            :         (Hacl_Streaming_MD_state_32){
    1347                 :            :           .block_state = block_state10,
    1348                 :            :           .buf = buf0,
    1349                 :            :           .total_len = total_len2
    1350                 :            :         }
    1351                 :            :       );
    1352                 :          0 :     Hacl_Streaming_MD_state_32 s10 = *p;
    1353                 :          0 :     uint32_t *block_state1 = s10.block_state;
    1354                 :          0 :     uint8_t *buf = s10.buf;
    1355                 :          0 :     uint64_t total_len1 = s10.total_len;
    1356                 :            :     uint32_t sz1;
    1357   [ #  #  #  # ]:          0 :     if (total_len1 % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len1 > (uint64_t)0U)
    1358                 :            :     {
    1359                 :          0 :       sz1 = (uint32_t)64U;
    1360                 :            :     }
    1361                 :            :     else
    1362                 :            :     {
    1363                 :          0 :       sz1 = (uint32_t)(total_len1 % (uint64_t)(uint32_t)64U);
    1364                 :            :     }
    1365         [ #  # ]:          0 :     if (!(sz1 == (uint32_t)0U))
    1366                 :            :     {
    1367                 :          0 :       Hacl_Hash_MD5_legacy_update_multi(block_state1, buf, (uint32_t)1U);
    1368                 :            :     }
    1369                 :            :     uint32_t ite;
    1370                 :            :     if
    1371                 :          0 :     (
    1372                 :          0 :       (uint64_t)(len - diff)
    1373                 :            :       % (uint64_t)(uint32_t)64U
    1374         [ #  # ]:          0 :       == (uint64_t)0U
    1375         [ #  # ]:          0 :       && (uint64_t)(len - diff) > (uint64_t)0U
    1376                 :            :     )
    1377                 :            :     {
    1378                 :          0 :       ite = (uint32_t)64U;
    1379                 :            :     }
    1380                 :            :     else
    1381                 :            :     {
    1382                 :          0 :       ite = (uint32_t)((uint64_t)(len - diff) % (uint64_t)(uint32_t)64U);
    1383                 :            :     }
    1384                 :          0 :     uint32_t n_blocks = (len - diff - ite) / (uint32_t)64U;
    1385                 :          0 :     uint32_t data1_len = n_blocks * (uint32_t)64U;
    1386                 :          0 :     uint32_t data2_len = len - diff - data1_len;
    1387                 :          0 :     uint8_t *data11 = data2;
    1388                 :          0 :     uint8_t *data21 = data2 + data1_len;
    1389                 :          0 :     Hacl_Hash_MD5_legacy_update_multi(block_state1, data11, data1_len / (uint32_t)64U);
    1390                 :          0 :     uint8_t *dst = buf;
    1391                 :          0 :     memcpy(dst, data21, data2_len * sizeof (uint8_t));
    1392                 :            :     *p
    1393                 :          0 :     =
    1394                 :            :       (
    1395                 :            :         (Hacl_Streaming_MD_state_32){
    1396                 :            :           .block_state = block_state1,
    1397                 :            :           .buf = buf,
    1398                 :          0 :           .total_len = total_len1 + (uint64_t)(len - diff)
    1399                 :            :         }
    1400                 :            :       );
    1401                 :            :   }
    1402                 :          0 :   return (uint32_t)0U;
    1403                 :            : }
    1404                 :            : 
    1405                 :          0 : void Hacl_Streaming_MD5_legacy_finish(Hacl_Streaming_MD_state_32 *p, uint8_t *dst)
    1406                 :            : {
    1407                 :          0 :   Hacl_Streaming_MD_state_32 scrut = *p;
    1408                 :          0 :   uint32_t *block_state = scrut.block_state;
    1409                 :          0 :   uint8_t *buf_ = scrut.buf;
    1410                 :          0 :   uint64_t total_len = scrut.total_len;
    1411                 :            :   uint32_t r;
    1412   [ #  #  #  # ]:          0 :   if (total_len % (uint64_t)(uint32_t)64U == (uint64_t)0U && total_len > (uint64_t)0U)
    1413                 :            :   {
    1414                 :          0 :     r = (uint32_t)64U;
    1415                 :            :   }
    1416                 :            :   else
    1417                 :            :   {
    1418                 :          0 :     r = (uint32_t)(total_len % (uint64_t)(uint32_t)64U);
    1419                 :            :   }
    1420                 :          0 :   uint8_t *buf_1 = buf_;
    1421                 :          0 :   uint32_t tmp_block_state[4U] = { 0U };
    1422                 :          0 :   memcpy(tmp_block_state, block_state, (uint32_t)4U * sizeof (uint32_t));
    1423                 :            :   uint32_t ite;
    1424   [ #  #  #  # ]:          0 :   if (r % (uint32_t)64U == (uint32_t)0U && r > (uint32_t)0U)
    1425                 :            :   {
    1426                 :          0 :     ite = (uint32_t)64U;
    1427                 :            :   }
    1428                 :            :   else
    1429                 :            :   {
    1430                 :          0 :     ite = r % (uint32_t)64U;
    1431                 :            :   }
    1432                 :          0 :   uint8_t *buf_last = buf_1 + r - ite;
    1433                 :          0 :   uint8_t *buf_multi = buf_1;
    1434                 :          0 :   Hacl_Hash_MD5_legacy_update_multi(tmp_block_state, buf_multi, (uint32_t)0U);
    1435                 :          0 :   uint64_t prev_len_last = total_len - (uint64_t)r;
    1436                 :          0 :   Hacl_Hash_MD5_legacy_update_last(tmp_block_state, prev_len_last, buf_last, r);
    1437                 :          0 :   Hacl_Hash_Core_MD5_legacy_finish(tmp_block_state, dst);
    1438                 :          0 : }
    1439                 :            : 
    1440                 :          0 : void Hacl_Streaming_MD5_legacy_free(Hacl_Streaming_MD_state_32 *s)
    1441                 :            : {
    1442                 :          0 :   Hacl_Streaming_MD_state_32 scrut = *s;
    1443                 :          0 :   uint8_t *buf = scrut.buf;
    1444                 :          0 :   uint32_t *block_state = scrut.block_state;
    1445                 :          0 :   KRML_HOST_FREE(block_state);
    1446                 :          0 :   KRML_HOST_FREE(buf);
    1447                 :          0 :   KRML_HOST_FREE(s);
    1448                 :          0 : }
    1449                 :            : 
    1450                 :          0 : Hacl_Streaming_MD_state_32 *Hacl_Streaming_MD5_legacy_copy(Hacl_Streaming_MD_state_32 *s0)
    1451                 :            : {
    1452                 :          0 :   Hacl_Streaming_MD_state_32 scrut = *s0;
    1453                 :          0 :   uint32_t *block_state0 = scrut.block_state;
    1454                 :          0 :   uint8_t *buf0 = scrut.buf;
    1455                 :          0 :   uint64_t total_len0 = scrut.total_len;
    1456                 :          0 :   uint8_t *buf = (uint8_t *)KRML_HOST_CALLOC((uint32_t)64U, sizeof (uint8_t));
    1457                 :          0 :   memcpy(buf, buf0, (uint32_t)64U * sizeof (uint8_t));
    1458                 :          0 :   uint32_t *block_state = (uint32_t *)KRML_HOST_CALLOC((uint32_t)4U, sizeof (uint32_t));
    1459                 :          0 :   memcpy(block_state, block_state0, (uint32_t)4U * sizeof (uint32_t));
    1460                 :            :   Hacl_Streaming_MD_state_32
    1461                 :          0 :   s = { .block_state = block_state, .buf = buf, .total_len = total_len0 };
    1462                 :            :   Hacl_Streaming_MD_state_32
    1463                 :          0 :   *p = (Hacl_Streaming_MD_state_32 *)KRML_HOST_MALLOC(sizeof (Hacl_Streaming_MD_state_32));
    1464                 :          0 :   p[0U] = s;
    1465                 :          0 :   return p;
    1466                 :            : }
    1467                 :            : 
    1468                 :          0 : void Hacl_Streaming_MD5_legacy_hash(uint8_t *input, uint32_t input_len, uint8_t *dst)
    1469                 :            : {
    1470                 :          0 :   Hacl_Hash_MD5_legacy_hash(input, input_len, dst);
    1471                 :          0 : }
    1472                 :            : 

Generated by: LCOV version 1.14