OpenCL/m07400.cl

   1 /**
   2  * Author......: Jens Steube <jens.steube@gmail.com>
   3  * License.....: MIT
   4  */
   5
   6 #define _SHA256_
   7
   8 #include "include/constants.h"
   9 #include "include/kernel_vendor.h"
  10
  11 #define DGST_R0 0
  12 #define DGST_R1 1
  13 #define DGST_R2 2
  14 #define DGST_R3 3
  15
  16 #include "include/kernel_functions.c"
  17 #include "OpenCL/types_ocl.c"
  18 #include "OpenCL/common.c"
  19
  20 #define COMPARE_S "OpenCL/check_single_comp4.c"
  21 #define COMPARE_M "OpenCL/check_multi_comp4.c"
  22
  23 __constant u32 k_sha256[64] =
  24 {
  25   SHA256C00, SHA256C01, SHA256C02, SHA256C03,
  26   SHA256C04, SHA256C05, SHA256C06, SHA256C07,
  27   SHA256C08, SHA256C09, SHA256C0a, SHA256C0b,
  28   SHA256C0c, SHA256C0d, SHA256C0e, SHA256C0f,
  29   SHA256C10, SHA256C11, SHA256C12, SHA256C13,
  30   SHA256C14, SHA256C15, SHA256C16, SHA256C17,
  31   SHA256C18, SHA256C19, SHA256C1a, SHA256C1b,
  32   SHA256C1c, SHA256C1d, SHA256C1e, SHA256C1f,
  33   SHA256C20, SHA256C21, SHA256C22, SHA256C23,
  34   SHA256C24, SHA256C25, SHA256C26, SHA256C27,
  35   SHA256C28, SHA256C29, SHA256C2a, SHA256C2b,
  36   SHA256C2c, SHA256C2d, SHA256C2e, SHA256C2f,
  37   SHA256C30, SHA256C31, SHA256C32, SHA256C33,
  38   SHA256C34, SHA256C35, SHA256C36, SHA256C37,
  39   SHA256C38, SHA256C39, SHA256C3a, SHA256C3b,
  40   SHA256C3c, SHA256C3d, SHA256C3e, SHA256C3f,
  41 };
  42
  43 #ifdef IS_AMD
  44
  45 void sha256_transform (const u32 w[16], u32 digest[8])
  46 {
  47   u32 a = digest[0];
  48   u32 b = digest[1];
  49   u32 c = digest[2];
  50   u32 d = digest[3];
  51   u32 e = digest[4];
  52   u32 f = digest[5];
  53   u32 g = digest[6];
  54   u32 h = digest[7];
  55
  56   u32 w0_t = swap32 (w[ 0]);
  57   u32 w1_t = swap32 (w[ 1]);
  58   u32 w2_t = swap32 (w[ 2]);
  59   u32 w3_t = swap32 (w[ 3]);
  60   u32 w4_t = swap32 (w[ 4]);
  61   u32 w5_t = swap32 (w[ 5]);
  62   u32 w6_t = swap32 (w[ 6]);
  63   u32 w7_t = swap32 (w[ 7]);
  64   u32 w8_t = swap32 (w[ 8]);
  65   u32 w9_t = swap32 (w[ 9]);
  66   u32 wa_t = swap32 (w[10]);
  67   u32 wb_t = swap32 (w[11]);
  68   u32 wc_t = swap32 (w[12]);
  69   u32 wd_t = swap32 (w[13]);
  70   u32 we_t = swap32 (w[14]);
  71   u32 wf_t = swap32 (w[15]);
  72
  73   #define ROUND_EXPAND()                            \
  74   {                                                 \
  75     w0_t = SHA256_EXPAND (we_t, w9_t, w1_t, w0_t);  \
  76     w1_t = SHA256_EXPAND (wf_t, wa_t, w2_t, w1_t);  \
  77     w2_t = SHA256_EXPAND (w0_t, wb_t, w3_t, w2_t);  \
  78     w3_t = SHA256_EXPAND (w1_t, wc_t, w4_t, w3_t);  \
  79     w4_t = SHA256_EXPAND (w2_t, wd_t, w5_t, w4_t);  \
  80     w5_t = SHA256_EXPAND (w3_t, we_t, w6_t, w5_t);  \
  81     w6_t = SHA256_EXPAND (w4_t, wf_t, w7_t, w6_t);  \
  82     w7_t = SHA256_EXPAND (w5_t, w0_t, w8_t, w7_t);  \
  83     w8_t = SHA256_EXPAND (w6_t, w1_t, w9_t, w8_t);  \
  84     w9_t = SHA256_EXPAND (w7_t, w2_t, wa_t, w9_t);  \
  85     wa_t = SHA256_EXPAND (w8_t, w3_t, wb_t, wa_t);  \
  86     wb_t = SHA256_EXPAND (w9_t, w4_t, wc_t, wb_t);  \
  87     wc_t = SHA256_EXPAND (wa_t, w5_t, wd_t, wc_t);  \
  88     wd_t = SHA256_EXPAND (wb_t, w6_t, we_t, wd_t);  \
  89     we_t = SHA256_EXPAND (wc_t, w7_t, wf_t, we_t);  \
  90     wf_t = SHA256_EXPAND (wd_t, w8_t, w0_t, wf_t);  \
  91   }
  92
  93   #define ROUND_STEP(i)                                                                   \
  94   {                                                                                       \
  95     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, k_sha256[i +  0]); \
  96     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, k_sha256[i +  1]); \
  97     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, k_sha256[i +  2]); \
  98     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, k_sha256[i +  3]); \
  99     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, k_sha256[i +  4]); \
 100     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, k_sha256[i +  5]); \
 101     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, k_sha256[i +  6]); \
 102     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, k_sha256[i +  7]); \
 103     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, k_sha256[i +  8]); \
 104     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, k_sha256[i +  9]); \
 105     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, k_sha256[i + 10]); \
 106     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, k_sha256[i + 11]); \
 107     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, k_sha256[i + 12]); \
 108     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, k_sha256[i + 13]); \
 109     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, k_sha256[i + 14]); \
 110     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, k_sha256[i + 15]); \
 111   }
 112
 113   ROUND_STEP (0);
 114
 115   #pragma unroll
 116   for (int i = 16; i < 64; i += 16)
 117   {
 118     ROUND_EXPAND (); ROUND_STEP (i);
 119   }
 120
 121   digest[0] += a;
 122   digest[1] += b;
 123   digest[2] += c;
 124   digest[3] += d;
 125   digest[4] += e;
 126   digest[5] += f;
 127   digest[6] += g;
 128   digest[7] += h;
 129 }
 130
 131 void sha256_transform_no14 (const u32 w[16], u32 digest[8])
 132 {
 133   u32 w_t[16];
 134
 135   w_t[ 0] = w[ 0];
 136   w_t[ 1] = w[ 1];
 137   w_t[ 2] = w[ 2];
 138   w_t[ 3] = w[ 3];
 139   w_t[ 4] = w[ 4];
 140   w_t[ 5] = w[ 5];
 141   w_t[ 6] = w[ 6];
 142   w_t[ 7] = w[ 7];
 143   w_t[ 8] = w[ 8];
 144   w_t[ 9] = w[ 9];
 145   w_t[10] = w[10];
 146   w_t[11] = w[11];
 147   w_t[12] = w[12];
 148   w_t[13] = w[13];
 149   w_t[14] = 0;
 150   w_t[15] = w[15];
 151
 152   sha256_transform (w_t, digest);
 153 }
 154
 155 void init_ctx (u32 digest[8])
 156 {
 157   digest[0] = SHA256M_A;
 158   digest[1] = SHA256M_B;
 159   digest[2] = SHA256M_C;
 160   digest[3] = SHA256M_D;
 161   digest[4] = SHA256M_E;
 162   digest[5] = SHA256M_F;
 163   digest[6] = SHA256M_G;
 164   digest[7] = SHA256M_H;
 165 }
 166
 167 void bzero16 (u32 block[16])
 168 {
 169   block[ 0] = 0;
 170   block[ 1] = 0;
 171   block[ 2] = 0;
 172   block[ 3] = 0;
 173   block[ 4] = 0;
 174   block[ 5] = 0;
 175   block[ 6] = 0;
 176   block[ 7] = 0;
 177   block[ 8] = 0;
 178   block[ 9] = 0;
 179   block[10] = 0;
 180   block[11] = 0;
 181   block[12] = 0;
 182   block[13] = 0;
 183   block[14] = 0;
 184   block[15] = 0;
 185 }
 186
 187 void bswap8 (u32 block[16])
 188 {
 189   block[ 0] = swap32 (block[ 0]);
 190   block[ 1] = swap32 (block[ 1]);
 191   block[ 2] = swap32 (block[ 2]);
 192   block[ 3] = swap32 (block[ 3]);
 193   block[ 4] = swap32 (block[ 4]);
 194   block[ 5] = swap32 (block[ 5]);
 195   block[ 6] = swap32 (block[ 6]);
 196   block[ 7] = swap32 (block[ 7]);
 197 }
 198
 199 u32 memcat16 (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len)
 200 {
 201   const u32 mod = block_len & 3;
 202   const u32 div = block_len / 4;
 203
 204   u32 tmp0;
 205   u32 tmp1;
 206   u32 tmp2;
 207   u32 tmp3;
 208   u32 tmp4;
 209
 210   #if defined IS_AMD || defined IS_GENERIC
 211   const int offset_minus_4 = 4 - block_len;
 212
 213   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 214   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 215   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 216   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 217   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 218
 219   if (mod == 0)
 220   {
 221     tmp0 = tmp1;
 222     tmp1 = tmp2;
 223     tmp2 = tmp3;
 224     tmp3 = tmp4;
 225     tmp4 = 0;
 226   }
 227   #endif
 228
 229   #ifdef IS_NV
 230   const int offset_minus_4 = 4 - (block_len & 3);
 231
 232   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 233
 234   tmp0 = __byte_perm (        0, append[0], selector);
 235   tmp1 = __byte_perm (append[0], append[1], selector);
 236   tmp2 = __byte_perm (append[1], append[2], selector);
 237   tmp3 = __byte_perm (append[2], append[3], selector);
 238   tmp4 = __byte_perm (append[3],         0, selector);
 239   #endif
 240
 241   switch (div)
 242   {
 243     case  0:  block[ 0] |= tmp0;
 244               block[ 1]  = tmp1;
 245               block[ 2]  = tmp2;
 246               block[ 3]  = tmp3;
 247               block[ 4]  = tmp4;
 248               break;
 249     case  1:  block[ 1] |= tmp0;
 250               block[ 2]  = tmp1;
 251               block[ 3]  = tmp2;
 252               block[ 4]  = tmp3;
 253               block[ 5]  = tmp4;
 254               break;
 255     case  2:  block[ 2] |= tmp0;
 256               block[ 3]  = tmp1;
 257               block[ 4]  = tmp2;
 258               block[ 5]  = tmp3;
 259               block[ 6]  = tmp4;
 260               break;
 261     case  3:  block[ 3] |= tmp0;
 262               block[ 4]  = tmp1;
 263               block[ 5]  = tmp2;
 264               block[ 6]  = tmp3;
 265               block[ 7]  = tmp4;
 266               break;
 267     case  4:  block[ 4] |= tmp0;
 268               block[ 5]  = tmp1;
 269               block[ 6]  = tmp2;
 270               block[ 7]  = tmp3;
 271               block[ 8]  = tmp4;
 272               break;
 273     case  5:  block[ 5] |= tmp0;
 274               block[ 6]  = tmp1;
 275               block[ 7]  = tmp2;
 276               block[ 8]  = tmp3;
 277               block[ 9]  = tmp4;
 278               break;
 279     case  6:  block[ 6] |= tmp0;
 280               block[ 7]  = tmp1;
 281               block[ 8]  = tmp2;
 282               block[ 9]  = tmp3;
 283               block[10]  = tmp4;
 284               break;
 285     case  7:  block[ 7] |= tmp0;
 286               block[ 8]  = tmp1;
 287               block[ 9]  = tmp2;
 288               block[10]  = tmp3;
 289               block[11]  = tmp4;
 290               break;
 291     case  8:  block[ 8] |= tmp0;
 292               block[ 9]  = tmp1;
 293               block[10]  = tmp2;
 294               block[11]  = tmp3;
 295               block[12]  = tmp4;
 296               break;
 297     case  9:  block[ 9] |= tmp0;
 298               block[10]  = tmp1;
 299               block[11]  = tmp2;
 300               block[12]  = tmp3;
 301               block[13]  = tmp4;
 302               break;
 303     case 10:  block[10] |= tmp0;
 304               block[11]  = tmp1;
 305               block[12]  = tmp2;
 306               block[13]  = tmp3;
 307               block[14]  = tmp4;
 308               break;
 309     case 11:  block[11] |= tmp0;
 310               block[12]  = tmp1;
 311               block[13]  = tmp2;
 312               block[14]  = tmp3;
 313               block[15]  = tmp4;
 314               break;
 315     case 12:  block[12] |= tmp0;
 316               block[13]  = tmp1;
 317               block[14]  = tmp2;
 318               block[15]  = tmp3;
 319               break;
 320     case 13:  block[13] |= tmp0;
 321               block[14]  = tmp1;
 322               block[15]  = tmp2;
 323               break;
 324     case 14:  block[14] |= tmp0;
 325               block[15]  = tmp1;
 326               break;
 327     case 15:  block[15] |= tmp0;
 328               break;
 329   }
 330
 331   u32 new_len = block_len + append_len;
 332
 333   return new_len;
 334 }
 335
 336 u32 memcat16c (u32 block[16], const u32 block_len, const u32 append[4], const u32 append_len, u32 digest[8])
 337 {
 338   const u32 mod = block_len & 3;
 339   const u32 div = block_len / 4;
 340
 341   u32 tmp0;
 342   u32 tmp1;
 343   u32 tmp2;
 344   u32 tmp3;
 345   u32 tmp4;
 346
 347   #if defined IS_AMD || defined IS_GENERIC
 348   const int offset_minus_4 = 4 - block_len;
 349
 350   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 351   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 352   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 353   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 354   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 355
 356   if (mod == 0)
 357   {
 358     tmp0 = tmp1;
 359     tmp1 = tmp2;
 360     tmp2 = tmp3;
 361     tmp3 = tmp4;
 362     tmp4 = 0;
 363   }
 364   #endif
 365
 366   #ifdef IS_NV
 367   const int offset_minus_4 = 4 - (block_len & 3);
 368
 369   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 370
 371   tmp0 = __byte_perm (        0, append[0], selector);
 372   tmp1 = __byte_perm (append[0], append[1], selector);
 373   tmp2 = __byte_perm (append[1], append[2], selector);
 374   tmp3 = __byte_perm (append[2], append[3], selector);
 375   tmp4 = __byte_perm (append[3],         0, selector);
 376   #endif
 377
 378   u32 carry[4] = { 0, 0, 0, 0 };
 379
 380   switch (div)
 381   {
 382     case  0:  block[ 0] |= tmp0;
 383               block[ 1]  = tmp1;
 384               block[ 2]  = tmp2;
 385               block[ 3]  = tmp3;
 386               block[ 4]  = tmp4;
 387               break;
 388     case  1:  block[ 1] |= tmp0;
 389               block[ 2]  = tmp1;
 390               block[ 3]  = tmp2;
 391               block[ 4]  = tmp3;
 392               block[ 5]  = tmp4;
 393               break;
 394     case  2:  block[ 2] |= tmp0;
 395               block[ 3]  = tmp1;
 396               block[ 4]  = tmp2;
 397               block[ 5]  = tmp3;
 398               block[ 6]  = tmp4;
 399               break;
 400     case  3:  block[ 3] |= tmp0;
 401               block[ 4]  = tmp1;
 402               block[ 5]  = tmp2;
 403               block[ 6]  = tmp3;
 404               block[ 7]  = tmp4;
 405               break;
 406     case  4:  block[ 4] |= tmp0;
 407               block[ 5]  = tmp1;
 408               block[ 6]  = tmp2;
 409               block[ 7]  = tmp3;
 410               block[ 8]  = tmp4;
 411               break;
 412     case  5:  block[ 5] |= tmp0;
 413               block[ 6]  = tmp1;
 414               block[ 7]  = tmp2;
 415               block[ 8]  = tmp3;
 416               block[ 9]  = tmp4;
 417               break;
 418     case  6:  block[ 6] |= tmp0;
 419               block[ 7]  = tmp1;
 420               block[ 8]  = tmp2;
 421               block[ 9]  = tmp3;
 422               block[10]  = tmp4;
 423               break;
 424     case  7:  block[ 7] |= tmp0;
 425               block[ 8]  = tmp1;
 426               block[ 9]  = tmp2;
 427               block[10]  = tmp3;
 428               block[11]  = tmp4;
 429               break;
 430     case  8:  block[ 8] |= tmp0;
 431               block[ 9]  = tmp1;
 432               block[10]  = tmp2;
 433               block[11]  = tmp3;
 434               block[12]  = tmp4;
 435               break;
 436     case  9:  block[ 9] |= tmp0;
 437               block[10]  = tmp1;
 438               block[11]  = tmp2;
 439               block[12]  = tmp3;
 440               block[13]  = tmp4;
 441               break;
 442     case 10:  block[10] |= tmp0;
 443               block[11]  = tmp1;
 444               block[12]  = tmp2;
 445               block[13]  = tmp3;
 446               block[14]  = tmp4;
 447               break;
 448     case 11:  block[11] |= tmp0;
 449               block[12]  = tmp1;
 450               block[13]  = tmp2;
 451               block[14]  = tmp3;
 452               block[15]  = tmp4;
 453               break;
 454     case 12:  block[12] |= tmp0;
 455               block[13]  = tmp1;
 456               block[14]  = tmp2;
 457               block[15]  = tmp3;
 458               carry[ 0]  = tmp4;
 459               break;
 460     case 13:  block[13] |= tmp0;
 461               block[14]  = tmp1;
 462               block[15]  = tmp2;
 463               carry[ 0]  = tmp3;
 464               carry[ 1]  = tmp4;
 465               break;
 466     case 14:  block[14] |= tmp0;
 467               block[15]  = tmp1;
 468               carry[ 0]  = tmp2;
 469               carry[ 1]  = tmp3;
 470               carry[ 2]  = tmp4;
 471               break;
 472     case 15:  block[15] |= tmp0;
 473               carry[ 0]  = tmp1;
 474               carry[ 1]  = tmp2;
 475               carry[ 2]  = tmp3;
 476               carry[ 3]  = tmp4;
 477               break;
 478   }
 479
 480   u32 new_len = block_len + append_len;
 481
 482   if (new_len >= 64)
 483   {
 484     new_len -= 64;
 485
 486     sha256_transform (block, digest);
 487
 488     bzero16 (block);
 489
 490     block[0] = carry[0];
 491     block[1] = carry[1];
 492     block[2] = carry[2];
 493     block[3] = carry[3];
 494   }
 495
 496   return new_len;
 497 }
 498
 499 u32 memcat20 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 500 {
 501   const u32 mod = block_len & 3;
 502   const u32 div = block_len / 4;
 503
 504   u32 tmp0;
 505   u32 tmp1;
 506   u32 tmp2;
 507   u32 tmp3;
 508   u32 tmp4;
 509
 510   #if defined IS_AMD || defined IS_GENERIC
 511   const int offset_minus_4 = 4 - block_len;
 512
 513   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 514   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 515   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 516   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 517   tmp4 = amd_bytealign (        0, append[3], offset_minus_4);
 518
 519   if (mod == 0)
 520   {
 521     tmp0 = tmp1;
 522     tmp1 = tmp2;
 523     tmp2 = tmp3;
 524     tmp3 = tmp4;
 525     tmp4 = 0;
 526   }
 527   #endif
 528
 529   #ifdef IS_NV
 530   const int offset_minus_4 = 4 - (block_len & 3);
 531
 532   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 533
 534   tmp0 = __byte_perm (        0, append[0], selector);
 535   tmp1 = __byte_perm (append[0], append[1], selector);
 536   tmp2 = __byte_perm (append[1], append[2], selector);
 537   tmp3 = __byte_perm (append[2], append[3], selector);
 538   tmp4 = __byte_perm (append[3],         0, selector);
 539   #endif
 540
 541   switch (div)
 542   {
 543     case  0:  block[ 0] |= tmp0;
 544               block[ 1]  = tmp1;
 545               block[ 2]  = tmp2;
 546               block[ 3]  = tmp3;
 547               block[ 4]  = tmp4;
 548               break;
 549     case  1:  block[ 1] |= tmp0;
 550               block[ 2]  = tmp1;
 551               block[ 3]  = tmp2;
 552               block[ 4]  = tmp3;
 553               block[ 5]  = tmp4;
 554               break;
 555     case  2:  block[ 2] |= tmp0;
 556               block[ 3]  = tmp1;
 557               block[ 4]  = tmp2;
 558               block[ 5]  = tmp3;
 559               block[ 6]  = tmp4;
 560               break;
 561     case  3:  block[ 3] |= tmp0;
 562               block[ 4]  = tmp1;
 563               block[ 5]  = tmp2;
 564               block[ 6]  = tmp3;
 565               block[ 7]  = tmp4;
 566               break;
 567     case  4:  block[ 4] |= tmp0;
 568               block[ 5]  = tmp1;
 569               block[ 6]  = tmp2;
 570               block[ 7]  = tmp3;
 571               block[ 8]  = tmp4;
 572               break;
 573     case  5:  block[ 5] |= tmp0;
 574               block[ 6]  = tmp1;
 575               block[ 7]  = tmp2;
 576               block[ 8]  = tmp3;
 577               block[ 9]  = tmp4;
 578               break;
 579     case  6:  block[ 6] |= tmp0;
 580               block[ 7]  = tmp1;
 581               block[ 8]  = tmp2;
 582               block[ 9]  = tmp3;
 583               block[10]  = tmp4;
 584               break;
 585     case  7:  block[ 7] |= tmp0;
 586               block[ 8]  = tmp1;
 587               block[ 9]  = tmp2;
 588               block[10]  = tmp3;
 589               block[11]  = tmp4;
 590               break;
 591     case  8:  block[ 8] |= tmp0;
 592               block[ 9]  = tmp1;
 593               block[10]  = tmp2;
 594               block[11]  = tmp3;
 595               block[12]  = tmp4;
 596               break;
 597     case  9:  block[ 9] |= tmp0;
 598               block[10]  = tmp1;
 599               block[11]  = tmp2;
 600               block[12]  = tmp3;
 601               block[13]  = tmp4;
 602               break;
 603     case 10:  block[10] |= tmp0;
 604               block[11]  = tmp1;
 605               block[12]  = tmp2;
 606               block[13]  = tmp3;
 607               block[14]  = tmp4;
 608               break;
 609     case 11:  block[11] |= tmp0;
 610               block[12]  = tmp1;
 611               block[13]  = tmp2;
 612               block[14]  = tmp3;
 613               block[15]  = tmp4;
 614               break;
 615     case 12:  block[12] |= tmp0;
 616               block[13]  = tmp1;
 617               block[14]  = tmp2;
 618               block[15]  = tmp3;
 619               block[16]  = tmp4;
 620               break;
 621     case 13:  block[13] |= tmp0;
 622               block[14]  = tmp1;
 623               block[15]  = tmp2;
 624               block[16]  = tmp3;
 625               block[17]  = tmp4;
 626               break;
 627     case 14:  block[14] |= tmp0;
 628               block[15]  = tmp1;
 629               block[16]  = tmp2;
 630               block[17]  = tmp3;
 631               block[18]  = tmp4;
 632               break;
 633     case 15:  block[15] |= tmp0;
 634               block[16]  = tmp1;
 635               block[17]  = tmp2;
 636               block[18]  = tmp3;
 637               block[19]  = tmp4;
 638               break;
 639   }
 640
 641   return block_len + append_len;
 642 }
 643
 644 u32 memcat20_x80 (u32 block[20], const u32 block_len, const u32 append[4], const u32 append_len)
 645 {
 646   const u32 mod = block_len & 3;
 647   const u32 div = block_len / 4;
 648
 649   u32 tmp0;
 650   u32 tmp1;
 651   u32 tmp2;
 652   u32 tmp3;
 653   u32 tmp4;
 654
 655   #if defined IS_AMD || defined IS_GENERIC
 656   const int offset_minus_4 = 4 - block_len;
 657
 658   tmp0 = amd_bytealign (append[0],         0, offset_minus_4);
 659   tmp1 = amd_bytealign (append[1], append[0], offset_minus_4);
 660   tmp2 = amd_bytealign (append[2], append[1], offset_minus_4);
 661   tmp3 = amd_bytealign (append[3], append[2], offset_minus_4);
 662   tmp4 = amd_bytealign (     0x80, append[3], offset_minus_4);
 663
 664   if (mod == 0)
 665   {
 666     tmp0 = tmp1;
 667     tmp1 = tmp2;
 668     tmp2 = tmp3;
 669     tmp3 = tmp4;
 670     tmp4 = 0x80;
 671   }
 672   #endif
 673
 674   #ifdef IS_NV
 675   const int offset_minus_4 = 4 - (block_len & 3);
 676
 677   const int selector = (0x76543210 >> (offset_minus_4 * 4)) & 0xffff;
 678
 679   tmp0 = __byte_perm (        0, append[0], selector);
 680   tmp1 = __byte_perm (append[0], append[1], selector);
 681   tmp2 = __byte_perm (append[1], append[2], selector);
 682   tmp3 = __byte_perm (append[2], append[3], selector);
 683   tmp4 = __byte_perm (append[3],      0x80, selector);
 684   #endif
 685
 686   switch (div)
 687   {
 688     case  0:  block[ 0] |= tmp0;
 689               block[ 1]  = tmp1;
 690               block[ 2]  = tmp2;
 691               block[ 3]  = tmp3;
 692               block[ 4]  = tmp4;
 693               break;
 694     case  1:  block[ 1] |= tmp0;
 695               block[ 2]  = tmp1;
 696               block[ 3]  = tmp2;
 697               block[ 4]  = tmp3;
 698               block[ 5]  = tmp4;
 699               break;
 700     case  2:  block[ 2] |= tmp0;
 701               block[ 3]  = tmp1;
 702               block[ 4]  = tmp2;
 703               block[ 5]  = tmp3;
 704               block[ 6]  = tmp4;
 705               break;
 706     case  3:  block[ 3] |= tmp0;
 707               block[ 4]  = tmp1;
 708               block[ 5]  = tmp2;
 709               block[ 6]  = tmp3;
 710               block[ 7]  = tmp4;
 711               break;
 712     case  4:  block[ 4] |= tmp0;
 713               block[ 5]  = tmp1;
 714               block[ 6]  = tmp2;
 715               block[ 7]  = tmp3;
 716               block[ 8]  = tmp4;
 717               break;
 718     case  5:  block[ 5] |= tmp0;
 719               block[ 6]  = tmp1;
 720               block[ 7]  = tmp2;
 721               block[ 8]  = tmp3;
 722               block[ 9]  = tmp4;
 723               break;
 724     case  6:  block[ 6] |= tmp0;
 725               block[ 7]  = tmp1;
 726               block[ 8]  = tmp2;
 727               block[ 9]  = tmp3;
 728               block[10]  = tmp4;
 729               break;
 730     case  7:  block[ 7] |= tmp0;
 731               block[ 8]  = tmp1;
 732               block[ 9]  = tmp2;
 733               block[10]  = tmp3;
 734               block[11]  = tmp4;
 735               break;
 736     case  8:  block[ 8] |= tmp0;
 737               block[ 9]  = tmp1;
 738               block[10]  = tmp2;
 739               block[11]  = tmp3;
 740               block[12]  = tmp4;
 741               break;
 742     case  9:  block[ 9] |= tmp0;
 743               block[10]  = tmp1;
 744               block[11]  = tmp2;
 745               block[12]  = tmp3;
 746               block[13]  = tmp4;
 747               break;
 748     case 10:  block[10] |= tmp0;
 749               block[11]  = tmp1;
 750               block[12]  = tmp2;
 751               block[13]  = tmp3;
 752               block[14]  = tmp4;
 753               break;
 754     case 11:  block[11] |= tmp0;
 755               block[12]  = tmp1;
 756               block[13]  = tmp2;
 757               block[14]  = tmp3;
 758               block[15]  = tmp4;
 759               break;
 760     case 12:  block[12] |= tmp0;
 761               block[13]  = tmp1;
 762               block[14]  = tmp2;
 763               block[15]  = tmp3;
 764               block[16]  = tmp4;
 765               break;
 766     case 13:  block[13] |= tmp0;
 767               block[14]  = tmp1;
 768               block[15]  = tmp2;
 769               block[16]  = tmp3;
 770               block[17]  = tmp4;
 771               break;
 772     case 14:  block[14] |= tmp0;
 773               block[15]  = tmp1;
 774               block[16]  = tmp2;
 775               block[17]  = tmp3;
 776               block[18]  = tmp4;
 777               break;
 778     case 15:  block[15] |= tmp0;
 779               block[16]  = tmp1;
 780               block[17]  = tmp2;
 781               block[18]  = tmp3;
 782               block[19]  = tmp4;
 783               break;
 784   }
 785
 786   return block_len + append_len;
 787 }
 788
 789 __kernel void m07400_init (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
 790 {
 791   /**
 792    * base
 793    */
 794
 795   const u32 gid = get_global_id (0);
 796
 797   if (gid >= gid_max) return;
 798
 799   u32 w0[4];
 800
 801   w0[0] = pws[gid].i[0];
 802   w0[1] = pws[gid].i[1];
 803   w0[2] = pws[gid].i[2];
 804   w0[3] = pws[gid].i[3];
 805
 806   const u32 pw_len = pws[gid].pw_len;
 807
 808   /**
 809    * salt
 810    */
 811
 812   u32 salt_buf[4];
 813
 814   salt_buf[0] = salt_bufs[salt_pos].salt_buf[0];
 815   salt_buf[1] = salt_bufs[salt_pos].salt_buf[1];
 816   salt_buf[2] = salt_bufs[salt_pos].salt_buf[2];
 817   salt_buf[3] = salt_bufs[salt_pos].salt_buf[3];
 818
 819   u32 salt_len = salt_bufs[salt_pos].salt_len;
 820
 821   /**
 822    * buffers
 823    */
 824
 825   u32 block_len;     // never reaches > 64
 826   u32 transform_len; // required for w[15] = len * 8
 827
 828   u32 block[16];
 829
 830   u32 alt_result[8];
 831   u32 p_bytes[8];
 832   u32 s_bytes[8];
 833
 834   /* Prepare for the real work.  */
 835
 836   block_len = 0;
 837
 838   bzero16 (block);
 839
 840   /* Add key.  */
 841
 842   block_len = memcat16 (block, block_len, w0, pw_len);
 843
 844   /* Add salt.  */
 845
 846   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 847
 848   /* Add key again.  */
 849
 850   block_len = memcat16 (block, block_len, w0, pw_len);
 851
 852   append_0x80_1x16 (block, block_len);
 853
 854   block[15] = swap32 (block_len * 8);
 855
 856   init_ctx (alt_result);
 857
 858   sha256_transform (block, alt_result);
 859
 860   bswap8 (alt_result);
 861
 862   block_len = 0;
 863
 864   bzero16 (block);
 865
 866   u32 alt_result_tmp[8];
 867
 868   alt_result_tmp[0] = alt_result[0];
 869   alt_result_tmp[1] = alt_result[1];
 870   alt_result_tmp[2] = alt_result[2];
 871   alt_result_tmp[3] = alt_result[3];
 872   alt_result_tmp[4] = 0;
 873   alt_result_tmp[5] = 0;
 874   alt_result_tmp[6] = 0;
 875   alt_result_tmp[7] = 0;
 876
 877   truncate_block (alt_result_tmp, pw_len);
 878
 879   /* Add the key string.  */
 880
 881   block_len = memcat16 (block, block_len, w0, pw_len);
 882
 883   /* The last part is the salt string.  This must be at most 8
 884      characters and it ends at the first `$' character (for
 885      compatibility with existing implementations).  */
 886
 887   block_len = memcat16 (block, block_len, salt_buf, salt_len);
 888
 889   /* Now get result of this (32 bytes) and add it to the other
 890      context.  */
 891
 892   block_len = memcat16 (block, block_len, alt_result_tmp, pw_len);
 893
 894   transform_len = block_len;
 895
 896   /* Take the binary representation of the length of the key and for every
 897      1 add the alternate sum, for every 0 the key.  */
 898
 899   alt_result_tmp[0] = alt_result[0];
 900   alt_result_tmp[1] = alt_result[1];
 901   alt_result_tmp[2] = alt_result[2];
 902   alt_result_tmp[3] = alt_result[3];
 903   alt_result_tmp[4] = alt_result[4];
 904   alt_result_tmp[5] = alt_result[5];
 905   alt_result_tmp[6] = alt_result[6];
 906   alt_result_tmp[7] = alt_result[7];
 907
 908   init_ctx (alt_result);
 909
 910   for (u32 j = pw_len; j; j >>= 1)
 911   {
 912     if (j & 1)
 913     {
 914       block_len = memcat16c (block, block_len, &alt_result_tmp[0], 16, alt_result);
 915       block_len = memcat16c (block, block_len, &alt_result_tmp[4], 16, alt_result);
 916
 917       transform_len += 32;
 918     }
 919     else
 920     {
 921       block_len = memcat16c (block, block_len, w0, pw_len, alt_result);
 922
 923       transform_len += pw_len;
 924     }
 925   }
 926
 927   append_0x80_1x16 (block, block_len);
 928
 929   if (block_len >= 56)
 930   {
 931     sha256_transform (block, alt_result);
 932
 933     bzero16 (block);
 934   }
 935
 936   block[15] = swap32 (transform_len * 8);
 937
 938   sha256_transform (block, alt_result);
 939
 940   bswap8 (alt_result);
 941
 942   tmps[gid].alt_result[0] = alt_result[0];
 943   tmps[gid].alt_result[1] = alt_result[1];
 944   tmps[gid].alt_result[2] = alt_result[2];
 945   tmps[gid].alt_result[3] = alt_result[3];
 946   tmps[gid].alt_result[4] = alt_result[4];
 947   tmps[gid].alt_result[5] = alt_result[5];
 948   tmps[gid].alt_result[6] = alt_result[6];
 949   tmps[gid].alt_result[7] = alt_result[7];
 950
 951   /* Start computation of P byte sequence.  */
 952
 953   block_len = 0;
 954
 955   transform_len = 0;
 956
 957   bzero16 (block);
 958
 959   /* For every character in the password add the entire password.  */
 960
 961   init_ctx (p_bytes);
 962
 963   for (u32 j = 0; j < pw_len; j++)
 964   {
 965     block_len = memcat16c (block, block_len, w0, pw_len, p_bytes);
 966
 967     transform_len += pw_len;
 968   }
 969
 970   /* Finish the digest.  */
 971
 972   append_0x80_1x16 (block, block_len);
 973
 974   if (block_len >= 56)
 975   {
 976     sha256_transform (block, p_bytes);
 977
 978     bzero16 (block);
 979   }
 980
 981   block[15] = swap32 (transform_len * 8);
 982
 983   sha256_transform (block, p_bytes);
 984
 985   bswap8 (p_bytes);
 986
 987   truncate_block (p_bytes, pw_len);
 988
 989   tmps[gid].p_bytes[0] = p_bytes[0];
 990   tmps[gid].p_bytes[1] = p_bytes[1];
 991   tmps[gid].p_bytes[2] = p_bytes[2];
 992   tmps[gid].p_bytes[3] = p_bytes[3];
 993
 994   /* Start computation of S byte sequence.  */
 995
 996   block_len = 0;
 997
 998   transform_len = 0;
 999
1000   bzero16 (block);
1001
1002   /* For every character in the password add the entire password.  */
1003
1004   init_ctx (s_bytes);
1005
1006   for (u32 j = 0; j < 16 + (alt_result[0] & 0xff); j++)
1007   {
1008     block_len = memcat16c (block, block_len, salt_buf, salt_len, s_bytes);
1009
1010     transform_len += salt_len;
1011   }
1012
1013   /* Finish the digest.  */
1014
1015   append_0x80_1x16 (block, block_len);
1016
1017   if (block_len >= 56)
1018   {
1019     sha256_transform (block, s_bytes);
1020
1021     bzero16 (block);
1022   }
1023
1024   block[15] = swap32 (transform_len * 8);
1025
1026   sha256_transform (block, s_bytes);
1027
1028   bswap8 (s_bytes);
1029
1030   truncate_block (s_bytes, salt_len);
1031
1032   tmps[gid].s_bytes[0] = s_bytes[0];
1033   tmps[gid].s_bytes[1] = s_bytes[1];
1034   tmps[gid].s_bytes[2] = s_bytes[2];
1035   tmps[gid].s_bytes[3] = s_bytes[3];
1036 }
1037
1038 __kernel void m07400_loop (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1039 {
1040   /**
1041    * base
1042    */
1043
1044   const u32 gid = get_global_id (0);
1045
1046   if (gid >= gid_max) return;
1047
1048   const u32 pw_len = pws[gid].pw_len;
1049
1050   /**
1051    * base
1052    */
1053
1054   u32 p_bytes[4];
1055
1056   p_bytes[0] = tmps[gid].p_bytes[0];
1057   p_bytes[1] = tmps[gid].p_bytes[1];
1058   p_bytes[2] = tmps[gid].p_bytes[2];
1059   p_bytes[3] = tmps[gid].p_bytes[3];
1060
1061   u32 p_bytes_x80[4];
1062
1063   p_bytes_x80[0] = tmps[gid].p_bytes[0];
1064   p_bytes_x80[1] = tmps[gid].p_bytes[1];
1065   p_bytes_x80[2] = tmps[gid].p_bytes[2];
1066   p_bytes_x80[3] = tmps[gid].p_bytes[3];
1067
1068   append_0x80_1x4 (p_bytes_x80, pw_len);
1069
1070   u32 s_bytes[4];
1071
1072   s_bytes[0] = tmps[gid].s_bytes[0];
1073   s_bytes[1] = tmps[gid].s_bytes[1];
1074   s_bytes[2] = tmps[gid].s_bytes[2];
1075   s_bytes[3] = tmps[gid].s_bytes[3];
1076
1077   u32 alt_result[8];
1078
1079   alt_result[0] = tmps[gid].alt_result[0];
1080   alt_result[1] = tmps[gid].alt_result[1];
1081   alt_result[2] = tmps[gid].alt_result[2];
1082   alt_result[3] = tmps[gid].alt_result[3];
1083   alt_result[4] = tmps[gid].alt_result[4];
1084   alt_result[5] = tmps[gid].alt_result[5];
1085   alt_result[6] = tmps[gid].alt_result[6];
1086   alt_result[7] = tmps[gid].alt_result[7];
1087
1088   u32 salt_len = salt_bufs[salt_pos].salt_len;
1089
1090   /* Repeatedly run the collected hash value through SHA256 to burn
1091      CPU cycles.  */
1092
1093   for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
1094   {
1095     u32 tmp[8];
1096
1097     init_ctx (tmp);
1098
1099     u32 block[32];
1100
1101     bzero16 (&block[ 0]);
1102     bzero16 (&block[16]);
1103
1104     u32 block_len = 0;
1105
1106     const u32 j1 = (j & 1) ? 1 : 0;
1107     const u32 j3 = (j % 3) ? 1 : 0;
1108     const u32 j7 = (j % 7) ? 1 : 0;
1109
1110     if (j1)
1111     {
1112       block[0] = p_bytes[0];
1113       block[1] = p_bytes[1];
1114       block[2] = p_bytes[2];
1115       block[3] = p_bytes[3];
1116
1117       block_len = pw_len;
1118     }
1119     else
1120     {
1121       block[0] = alt_result[0];
1122       block[1] = alt_result[1];
1123       block[2] = alt_result[2];
1124       block[3] = alt_result[3];
1125       block[4] = alt_result[4];
1126       block[5] = alt_result[5];
1127       block[6] = alt_result[6];
1128       block[7] = alt_result[7];
1129
1130       block_len = 32;
1131     }
1132
1133     if (j3)
1134     {
1135       block_len = memcat20 (block, block_len, s_bytes, salt_len);
1136     }
1137
1138     if (j7)
1139     {
1140       block_len = memcat20 (block, block_len, p_bytes, pw_len);
1141     }
1142
1143     if (j1)
1144     {
1145       block_len = memcat20     (block, block_len, &alt_result[0], 16);
1146       block_len = memcat20_x80 (block, block_len, &alt_result[4], 16);
1147     }
1148     else
1149     {
1150       block_len = memcat20 (block, block_len, p_bytes_x80, pw_len);
1151     }
1152
1153     if (block_len >= 56)
1154     {
1155       sha256_transform (block, tmp);
1156
1157       block[ 0] = block[16];
1158       block[ 1] = block[17];
1159       block[ 2] = block[18];
1160       block[ 3] = block[19];
1161       block[ 4] = 0;
1162       block[ 5] = 0;
1163       block[ 6] = 0;
1164       block[ 7] = 0;
1165       block[ 8] = 0;
1166       block[ 9] = 0;
1167       block[10] = 0;
1168       block[11] = 0;
1169       block[12] = 0;
1170       block[13] = 0;
1171       block[14] = 0;
1172       block[15] = 0;
1173     }
1174
1175     block[15] = swap32 (block_len * 8);
1176
1177     sha256_transform_no14 (block, tmp);
1178
1179     bswap8 (tmp);
1180
1181     alt_result[0] = tmp[0];
1182     alt_result[1] = tmp[1];
1183     alt_result[2] = tmp[2];
1184     alt_result[3] = tmp[3];
1185     alt_result[4] = tmp[4];
1186     alt_result[5] = tmp[5];
1187     alt_result[6] = tmp[6];
1188     alt_result[7] = tmp[7];
1189   }
1190
1191   tmps[gid].alt_result[0] = alt_result[0];
1192   tmps[gid].alt_result[1] = alt_result[1];
1193   tmps[gid].alt_result[2] = alt_result[2];
1194   tmps[gid].alt_result[3] = alt_result[3];
1195   tmps[gid].alt_result[4] = alt_result[4];
1196   tmps[gid].alt_result[5] = alt_result[5];
1197   tmps[gid].alt_result[6] = alt_result[6];
1198   tmps[gid].alt_result[7] = alt_result[7];
1199 }
1200
1201 __kernel void m07400_comp (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1202 {
1203   /**
1204    * base
1205    */
1206
1207   const u32 gid = get_global_id (0);
1208
1209   if (gid >= gid_max) return;
1210
1211   const u32 lid = get_local_id (0);
1212
1213   const u32 r0 = tmps[gid].alt_result[0];
1214   const u32 r1 = tmps[gid].alt_result[1];
1215   const u32 r2 = tmps[gid].alt_result[2];
1216   const u32 r3 = tmps[gid].alt_result[3];
1217
1218   #define il_pos 0
1219
1220   #include COMPARE_M
1221 }
1222
1223 #else
1224
1225 #define PUTCHAR32_BE(a,p,c) ((u8 *)(a))[(p) ^ 3] = (u8) (c)
1226 #define GETCHAR32_BE(a,p)   ((u8 *)(a))[(p) ^ 3]
1227
1228 typedef struct
1229 {
1230   u32 state[8];
1231   u32 buf[32];
1232   int len;
1233
1234 } sha256_ctx_t;
1235
1236 void sha256_transform (const u32 w[16], u32 digest[8])
1237 {
1238   u32 a = digest[0];
1239   u32 b = digest[1];
1240   u32 c = digest[2];
1241   u32 d = digest[3];
1242   u32 e = digest[4];
1243   u32 f = digest[5];
1244   u32 g = digest[6];
1245   u32 h = digest[7];
1246
1247   u32 w0_t = w[ 0];
1248   u32 w1_t = w[ 1];
1249   u32 w2_t = w[ 2];
1250   u32 w3_t = w[ 3];
1251   u32 w4_t = w[ 4];
1252   u32 w5_t = w[ 5];
1253   u32 w6_t = w[ 6];
1254   u32 w7_t = w[ 7];
1255   u32 w8_t = w[ 8];
1256   u32 w9_t = w[ 9];
1257   u32 wa_t = w[10];
1258   u32 wb_t = w[11];
1259   u32 wc_t = w[12];
1260   u32 wd_t = w[13];
1261   u32 we_t = w[14];
1262   u32 wf_t = w[15];
1263
1264   #define ROUND_EXPAND()                            \
1265   {                                                 \
1266     w0_t = SHA256_EXPAND (we_t, w9_t, w1_t, w0_t);  \
1267     w1_t = SHA256_EXPAND (wf_t, wa_t, w2_t, w1_t);  \
1268     w2_t = SHA256_EXPAND (w0_t, wb_t, w3_t, w2_t);  \
1269     w3_t = SHA256_EXPAND (w1_t, wc_t, w4_t, w3_t);  \
1270     w4_t = SHA256_EXPAND (w2_t, wd_t, w5_t, w4_t);  \
1271     w5_t = SHA256_EXPAND (w3_t, we_t, w6_t, w5_t);  \
1272     w6_t = SHA256_EXPAND (w4_t, wf_t, w7_t, w6_t);  \
1273     w7_t = SHA256_EXPAND (w5_t, w0_t, w8_t, w7_t);  \
1274     w8_t = SHA256_EXPAND (w6_t, w1_t, w9_t, w8_t);  \
1275     w9_t = SHA256_EXPAND (w7_t, w2_t, wa_t, w9_t);  \
1276     wa_t = SHA256_EXPAND (w8_t, w3_t, wb_t, wa_t);  \
1277     wb_t = SHA256_EXPAND (w9_t, w4_t, wc_t, wb_t);  \
1278     wc_t = SHA256_EXPAND (wa_t, w5_t, wd_t, wc_t);  \
1279     wd_t = SHA256_EXPAND (wb_t, w6_t, we_t, wd_t);  \
1280     we_t = SHA256_EXPAND (wc_t, w7_t, wf_t, we_t);  \
1281     wf_t = SHA256_EXPAND (wd_t, w8_t, w0_t, wf_t);  \
1282   }
1283
1284   #define ROUND_STEP(i)                                                                   \
1285   {                                                                                       \
1286     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w0_t, k_sha256[i +  0]); \
1287     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w1_t, k_sha256[i +  1]); \
1288     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, w2_t, k_sha256[i +  2]); \
1289     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, w3_t, k_sha256[i +  3]); \
1290     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, w4_t, k_sha256[i +  4]); \
1291     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, w5_t, k_sha256[i +  5]); \
1292     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, w6_t, k_sha256[i +  6]); \
1293     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, w7_t, k_sha256[i +  7]); \
1294     SHA256_STEP (SHA256_F0o, SHA256_F1o, a, b, c, d, e, f, g, h, w8_t, k_sha256[i +  8]); \
1295     SHA256_STEP (SHA256_F0o, SHA256_F1o, h, a, b, c, d, e, f, g, w9_t, k_sha256[i +  9]); \
1296     SHA256_STEP (SHA256_F0o, SHA256_F1o, g, h, a, b, c, d, e, f, wa_t, k_sha256[i + 10]); \
1297     SHA256_STEP (SHA256_F0o, SHA256_F1o, f, g, h, a, b, c, d, e, wb_t, k_sha256[i + 11]); \
1298     SHA256_STEP (SHA256_F0o, SHA256_F1o, e, f, g, h, a, b, c, d, wc_t, k_sha256[i + 12]); \
1299     SHA256_STEP (SHA256_F0o, SHA256_F1o, d, e, f, g, h, a, b, c, wd_t, k_sha256[i + 13]); \
1300     SHA256_STEP (SHA256_F0o, SHA256_F1o, c, d, e, f, g, h, a, b, we_t, k_sha256[i + 14]); \
1301     SHA256_STEP (SHA256_F0o, SHA256_F1o, b, c, d, e, f, g, h, a, wf_t, k_sha256[i + 15]); \
1302   }
1303
1304   ROUND_STEP (0);
1305
1306   //#pragma unroll
1307   for (int i = 16; i < 64; i += 16)
1308   {
1309     ROUND_EXPAND (); ROUND_STEP (i);
1310   }
1311
1312   digest[0] += a;
1313   digest[1] += b;
1314   digest[2] += c;
1315   digest[3] += d;
1316   digest[4] += e;
1317   digest[5] += f;
1318   digest[6] += g;
1319   digest[7] += h;
1320 }
1321
1322 void sha256_init (sha256_ctx_t *sha256_ctx)
1323 {
1324   sha256_ctx->state[0] = SHA256M_A;
1325   sha256_ctx->state[1] = SHA256M_B;
1326   sha256_ctx->state[2] = SHA256M_C;
1327   sha256_ctx->state[3] = SHA256M_D;
1328   sha256_ctx->state[4] = SHA256M_E;
1329   sha256_ctx->state[5] = SHA256M_F;
1330   sha256_ctx->state[6] = SHA256M_G;
1331   sha256_ctx->state[7] = SHA256M_H;
1332
1333   sha256_ctx->len = 0;
1334 }
1335
1336 void sha256_update (sha256_ctx_t *sha256_ctx, const u32 *buf, int len)
1337 {
1338   int pos = sha256_ctx->len & 0x3f;
1339
1340   sha256_ctx->len += len;
1341
1342   if ((pos + len) < 64)
1343   {
1344     for (int i = 0; i < len; i++)
1345     {
1346       PUTCHAR32_BE (sha256_ctx->buf, pos++, GETCHAR32_BE (buf, i));
1347     }
1348
1349     return;
1350   }
1351
1352   int cnt = 64 - pos;
1353
1354   for (int i = 0; i < cnt; i++)
1355   {
1356     PUTCHAR32_BE (sha256_ctx->buf, pos++, GETCHAR32_BE (buf, i));
1357   }
1358
1359   sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1360
1361   len -= cnt;
1362
1363   for (int i = 0; i < len; i++)
1364   {
1365     PUTCHAR32_BE (sha256_ctx->buf, i, GETCHAR32_BE (buf, cnt + i));
1366   }
1367 }
1368
1369 void sha256_final (sha256_ctx_t *sha256_ctx)
1370 {
1371   int pos = sha256_ctx->len & 0x3f;
1372
1373   for (int i = pos; i < 64; i++)
1374   {
1375     PUTCHAR32_BE (sha256_ctx->buf, i, 0);
1376   }
1377
1378   PUTCHAR32_BE (sha256_ctx->buf, pos, 0x80);
1379
1380   if (pos >= 56)
1381   {
1382     sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1383
1384     sha256_ctx->buf[ 0] = 0;
1385     sha256_ctx->buf[ 1] = 0;
1386     sha256_ctx->buf[ 2] = 0;
1387     sha256_ctx->buf[ 3] = 0;
1388     sha256_ctx->buf[ 4] = 0;
1389     sha256_ctx->buf[ 5] = 0;
1390     sha256_ctx->buf[ 6] = 0;
1391     sha256_ctx->buf[ 7] = 0;
1392     sha256_ctx->buf[ 8] = 0;
1393     sha256_ctx->buf[ 9] = 0;
1394     sha256_ctx->buf[10] = 0;
1395     sha256_ctx->buf[11] = 0;
1396     sha256_ctx->buf[12] = 0;
1397     sha256_ctx->buf[13] = 0;
1398     sha256_ctx->buf[14] = 0;
1399     sha256_ctx->buf[15] = 0;
1400   }
1401
1402   sha256_ctx->buf[15] = sha256_ctx->len * 8;
1403
1404   sha256_transform (sha256_ctx->buf, sha256_ctx->state);
1405 }
1406
1407 __kernel void m07400_init (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1408 {
1409   /**
1410    * base
1411    */
1412
1413   const u32 gid = get_global_id (0);
1414
1415   if (gid >= gid_max) return;
1416
1417   u32 pw[4];
1418
1419   pw[0] = swap32 (pws[gid].i[0]);
1420   pw[1] = swap32 (pws[gid].i[1]);
1421   pw[2] = swap32 (pws[gid].i[2]);
1422   pw[3] = swap32 (pws[gid].i[3]);
1423
1424   const u32 pw_len = pws[gid].pw_len;
1425
1426   /**
1427    * salt
1428    */
1429
1430   u32 salt[4];
1431
1432   salt[0] = swap32 (salt_bufs[salt_pos].salt_buf[0]);
1433   salt[1] = swap32 (salt_bufs[salt_pos].salt_buf[1]);
1434   salt[2] = swap32 (salt_bufs[salt_pos].salt_buf[2]);
1435   salt[3] = swap32 (salt_bufs[salt_pos].salt_buf[3]);
1436
1437   u32 salt_len = salt_bufs[salt_pos].salt_len;
1438
1439   /**
1440    * begin
1441    */
1442
1443   sha256_ctx_t sha256_ctx;
1444
1445   sha256_init (&sha256_ctx);
1446
1447   sha256_update (&sha256_ctx, pw, pw_len);
1448   sha256_update (&sha256_ctx, salt, salt_len);
1449   sha256_update (&sha256_ctx, pw, pw_len);
1450
1451   sha256_final (&sha256_ctx);
1452
1453   u32 tmp[8];
1454
1455   tmp[0] = sha256_ctx.state[0];
1456   tmp[1] = sha256_ctx.state[1];
1457   tmp[2] = sha256_ctx.state[2];
1458   tmp[3] = sha256_ctx.state[3];
1459   tmp[4] = sha256_ctx.state[4];
1460   tmp[5] = sha256_ctx.state[5];
1461   tmp[6] = sha256_ctx.state[6];
1462   tmp[7] = sha256_ctx.state[7];
1463
1464   sha256_init (&sha256_ctx);
1465
1466   sha256_update (&sha256_ctx, pw, pw_len);
1467   sha256_update (&sha256_ctx, salt, salt_len);
1468   sha256_update (&sha256_ctx, tmp, pw_len);
1469
1470   for (u32 j = pw_len; j; j >>= 1)
1471   {
1472     if (j & 1)
1473     {
1474       sha256_update (&sha256_ctx, tmp, 32);
1475     }
1476     else
1477     {
1478       sha256_update (&sha256_ctx, pw, pw_len);
1479     }
1480   }
1481
1482   sha256_final (&sha256_ctx);
1483
1484   tmps[gid].alt_result[0] = sha256_ctx.state[0];
1485   tmps[gid].alt_result[1] = sha256_ctx.state[1];
1486   tmps[gid].alt_result[2] = sha256_ctx.state[2];
1487   tmps[gid].alt_result[3] = sha256_ctx.state[3];
1488   tmps[gid].alt_result[4] = sha256_ctx.state[4];
1489   tmps[gid].alt_result[5] = sha256_ctx.state[5];
1490   tmps[gid].alt_result[6] = sha256_ctx.state[6];
1491   tmps[gid].alt_result[7] = sha256_ctx.state[7];
1492
1493   // p_bytes
1494
1495   sha256_init (&sha256_ctx);
1496
1497   for (u32 j = 0; j < pw_len; j++)
1498   {
1499     sha256_update (&sha256_ctx, pw, pw_len);
1500   }
1501
1502   sha256_final (&sha256_ctx);
1503
1504   tmps[gid].p_bytes[0] = sha256_ctx.state[0];
1505   tmps[gid].p_bytes[1] = sha256_ctx.state[1];
1506   tmps[gid].p_bytes[2] = sha256_ctx.state[2];
1507   tmps[gid].p_bytes[3] = sha256_ctx.state[3];
1508
1509   // s_bytes
1510
1511   sha256_init (&sha256_ctx);
1512
1513   for (u32 j = 0; j < 16 + ((tmps[gid].alt_result[0] >> 24) & 0xff); j++)
1514   {
1515     sha256_update (&sha256_ctx, salt, salt_len);
1516   }
1517
1518   sha256_final (&sha256_ctx);
1519
1520   tmps[gid].s_bytes[0] = sha256_ctx.state[0];
1521   tmps[gid].s_bytes[1] = sha256_ctx.state[1];
1522   tmps[gid].s_bytes[2] = sha256_ctx.state[2];
1523   tmps[gid].s_bytes[3] = sha256_ctx.state[3];
1524 }
1525
1526 __kernel void m07400_loop (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1527 {
1528   /**
1529    * base
1530    */
1531
1532   const u32 gid = get_global_id (0);
1533
1534   if (gid >= gid_max) return;
1535
1536   u32 p_bytes0[4];
1537
1538   p_bytes0[0] = tmps[gid].p_bytes[0];
1539   p_bytes0[1] = tmps[gid].p_bytes[1];
1540   p_bytes0[2] = tmps[gid].p_bytes[2];
1541   p_bytes0[3] = tmps[gid].p_bytes[3];
1542
1543   const u32 pw_len = pws[gid].pw_len;
1544
1545   u32 s_bytes0[4];
1546
1547   s_bytes0[0] = tmps[gid].s_bytes[0];
1548   s_bytes0[1] = tmps[gid].s_bytes[1];
1549   s_bytes0[2] = tmps[gid].s_bytes[2];
1550   s_bytes0[3] = tmps[gid].s_bytes[3];
1551
1552   const u32 salt_len = salt_bufs[salt_pos].salt_len;
1553
1554   u32 wpc_len[8];
1555
1556   wpc_len[0] = 32     +        0 +      0 + pw_len;
1557   wpc_len[1] = pw_len +        0 +      0 + 32;
1558   wpc_len[2] = 32     + salt_len +      0 + pw_len;
1559   wpc_len[3] = pw_len + salt_len +      0 + 32;
1560   wpc_len[4] = 32     +        0 + pw_len + pw_len;
1561   wpc_len[5] = pw_len +        0 + pw_len + 32;
1562   wpc_len[6] = 32     + salt_len + pw_len + pw_len;
1563   wpc_len[7] = pw_len + salt_len + pw_len + 32;
1564
1565   u32 wpc[8][32] = { { 0 } };
1566
1567   for (u32 i = 0; i < 8; i++)
1568   {
1569     u32 block_len = 0;
1570
1571     if (i & 1)
1572     {
1573       for (u32 j = 0; j < pw_len; j++)
1574       {
1575         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1576       }
1577     }
1578     else
1579     {
1580       block_len += 32;
1581     }
1582
1583     if (i & 2)
1584     {
1585       for (u32 j = 0; j < salt_len; j++)
1586       {
1587         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (s_bytes0, j));
1588       }
1589     }
1590
1591     if (i & 4)
1592     {
1593       for (u32 j = 0; j < pw_len; j++)
1594       {
1595         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1596       }
1597     }
1598
1599     if (i & 1)
1600     {
1601       block_len += 32;
1602     }
1603     else
1604     {
1605       for (u32 j = 0; j < pw_len; j++)
1606       {
1607         PUTCHAR32_BE (wpc[i], block_len++, GETCHAR32_BE (p_bytes0, j));
1608       }
1609     }
1610
1611     PUTCHAR32_BE (wpc[i], block_len, 0x80);
1612
1613     if (block_len < 56)
1614     {
1615       wpc[i][15] = block_len * 8;
1616     }
1617     else
1618     {
1619       wpc[i][31] = block_len * 8;
1620     }
1621   }
1622
1623   /**
1624    * base
1625    */
1626
1627   u32 alt_result[8];
1628
1629   alt_result[0] = tmps[gid].alt_result[0];
1630   alt_result[1] = tmps[gid].alt_result[1];
1631   alt_result[2] = tmps[gid].alt_result[2];
1632   alt_result[3] = tmps[gid].alt_result[3];
1633   alt_result[4] = tmps[gid].alt_result[4];
1634   alt_result[5] = tmps[gid].alt_result[5];
1635   alt_result[6] = tmps[gid].alt_result[6];
1636   alt_result[7] = tmps[gid].alt_result[7];
1637
1638
1639   /* Repeatedly run the collected hash value through SHA256 to burn
1640      CPU cycles.  */
1641
1642   for (u32 i = 0, j = loop_pos; i < loop_cnt; i++, j++)
1643   {
1644     const u32 j1 = (j & 1) ? 1 : 0;
1645     const u32 j3 = (j % 3) ? 2 : 0;
1646     const u32 j7 = (j % 7) ? 4 : 0;
1647
1648     const u32 pc = j1 + j3 + j7;
1649
1650     u32 block[32];
1651
1652     block[ 0] = wpc[pc][ 0];
1653     block[ 1] = wpc[pc][ 1];
1654     block[ 2] = wpc[pc][ 2];
1655     block[ 3] = wpc[pc][ 3];
1656     block[ 4] = wpc[pc][ 4];
1657     block[ 5] = wpc[pc][ 5];
1658     block[ 6] = wpc[pc][ 6];
1659     block[ 7] = wpc[pc][ 7];
1660     block[ 8] = wpc[pc][ 8];
1661     block[ 9] = wpc[pc][ 9];
1662     block[10] = wpc[pc][10];
1663     block[11] = wpc[pc][11];
1664     block[12] = wpc[pc][12];
1665     block[13] = wpc[pc][13];
1666     block[14] = wpc[pc][14];
1667     block[15] = wpc[pc][15];
1668     block[16] = wpc[pc][16];
1669     block[17] = wpc[pc][17];
1670     block[18] = wpc[pc][18];
1671     block[19] = wpc[pc][19];
1672     block[20] = wpc[pc][20];
1673     block[21] = wpc[pc][21];
1674     block[22] = wpc[pc][22];
1675     block[23] = wpc[pc][23];
1676     block[24] = wpc[pc][24];
1677     block[25] = wpc[pc][25];
1678     block[26] = wpc[pc][26];
1679     block[27] = wpc[pc][27];
1680     block[28] = wpc[pc][28];
1681     block[29] = wpc[pc][29];
1682     block[30] = wpc[pc][30];
1683     block[31] = wpc[pc][31];
1684
1685     const u32 block_len = wpc_len[pc];
1686
1687     if (j1)
1688     {
1689       #pragma unroll 32
1690       for (u32 k = 0, p = block_len - 32; k < 32; k++, p++)
1691       {
1692         PUTCHAR32_BE (block, p, GETCHAR32_BE (alt_result, k));
1693       }
1694     }
1695     else
1696     {
1697       block[0] = alt_result[0];
1698       block[1] = alt_result[1];
1699       block[2] = alt_result[2];
1700       block[3] = alt_result[3];
1701       block[4] = alt_result[4];
1702       block[5] = alt_result[5];
1703       block[6] = alt_result[6];
1704       block[7] = alt_result[7];
1705     }
1706
1707     alt_result[0] = SHA256M_A;
1708     alt_result[1] = SHA256M_B;
1709     alt_result[2] = SHA256M_C;
1710     alt_result[3] = SHA256M_D;
1711     alt_result[4] = SHA256M_E;
1712     alt_result[5] = SHA256M_F;
1713     alt_result[6] = SHA256M_G;
1714     alt_result[7] = SHA256M_H;
1715
1716     sha256_transform (block, alt_result);
1717
1718     if (block_len >= 56)
1719     {
1720       sha256_transform (block + 16, alt_result);
1721     }
1722   }
1723
1724   tmps[gid].alt_result[0] = alt_result[0];
1725   tmps[gid].alt_result[1] = alt_result[1];
1726   tmps[gid].alt_result[2] = alt_result[2];
1727   tmps[gid].alt_result[3] = alt_result[3];
1728   tmps[gid].alt_result[4] = alt_result[4];
1729   tmps[gid].alt_result[5] = alt_result[5];
1730   tmps[gid].alt_result[6] = alt_result[6];
1731   tmps[gid].alt_result[7] = alt_result[7];
1732 }
1733
1734 __kernel void m07400_comp (__global pw_t *pws, __global kernel_rule_t *rules_buf, __global comb_t *combs_buf, __global bf_t *bfs_buf, __global sha256crypt_tmp_t *tmps, __global void *hooks, __global u32 *bitmaps_buf_s1_a, __global u32 *bitmaps_buf_s1_b, __global u32 *bitmaps_buf_s1_c, __global u32 *bitmaps_buf_s1_d, __global u32 *bitmaps_buf_s2_a, __global u32 *bitmaps_buf_s2_b, __global u32 *bitmaps_buf_s2_c, __global u32 *bitmaps_buf_s2_d, __global plain_t *plains_buf, __global digest_t *digests_buf, __global u32 *hashes_shown, __global salt_t *salt_bufs, __global void *esalt_bufs, __global u32 *d_return_buf, __global u32 *d_scryptV_buf, const u32 bitmap_mask, const u32 bitmap_shift1, const u32 bitmap_shift2, const u32 salt_pos, const u32 loop_pos, const u32 loop_cnt, const u32 il_cnt, const u32 digests_cnt, const u32 digests_offset, const u32 combs_mode, const u32 gid_max)
1735 {
1736   /**
1737    * base
1738    */
1739
1740   const u32 gid = get_global_id (0);
1741
1742   if (gid >= gid_max) return;
1743
1744   const u32 lid = get_local_id (0);
1745
1746   const u32 r0 = swap32 (tmps[gid].alt_result[0]);
1747   const u32 r1 = swap32 (tmps[gid].alt_result[1]);
1748   const u32 r2 = swap32 (tmps[gid].alt_result[2]);
1749   const u32 r3 = swap32 (tmps[gid].alt_result[3]);
1750
1751   #define il_pos 0
1752
1753   #include COMPARE_M
1754 }
1755
1756 #endif