kernel/generic/zlaswp_ncopy_4.c

   1 /*********************************************************************/
   2 /* Copyright 2009, 2010 The University of Texas at Austin.           */
   3 /* All rights reserved.                                              */
   4 /*                                                                   */
   5 /* Redistribution and use in source and binary forms, with or        */
   6 /* without modification, are permitted provided that the following   */
   7 /* conditions are met:                                               */
   8 /*                                                                   */
   9 /*   1. Redistributions of source code must retain the above         */
  10 /*      copyright notice, this list of conditions and the following  */
  11 /*      disclaimer.                                                  */
  12 /*                                                                   */
  13 /*   2. Redistributions in binary form must reproduce the above      */
  14 /*      copyright notice, this list of conditions and the following  */
  15 /*      disclaimer in the documentation and/or other materials       */
  16 /*      provided with the distribution.                              */
  17 /*                                                                   */
  18 /*    THIS  SOFTWARE IS PROVIDED  BY THE  UNIVERSITY OF  TEXAS AT    */
  19 /*    AUSTIN  ``AS IS''  AND ANY  EXPRESS OR  IMPLIED WARRANTIES,    */
  20 /*    INCLUDING, BUT  NOT LIMITED  TO, THE IMPLIED  WARRANTIES OF    */
  21 /*    MERCHANTABILITY  AND FITNESS FOR  A PARTICULAR  PURPOSE ARE    */
  22 /*    DISCLAIMED.  IN  NO EVENT SHALL THE UNIVERSITY  OF TEXAS AT    */
  23 /*    AUSTIN OR CONTRIBUTORS BE  LIABLE FOR ANY DIRECT, INDIRECT,    */
  24 /*    INCIDENTAL,  SPECIAL, EXEMPLARY,  OR  CONSEQUENTIAL DAMAGES    */
  25 /*    (INCLUDING, BUT  NOT LIMITED TO,  PROCUREMENT OF SUBSTITUTE    */
  26 /*    GOODS  OR  SERVICES; LOSS  OF  USE,  DATA,  OR PROFITS;  OR    */
  27 /*    BUSINESS INTERRUPTION) HOWEVER CAUSED  AND ON ANY THEORY OF    */
  28 /*    LIABILITY, WHETHER  IN CONTRACT, STRICT  LIABILITY, OR TORT    */
  29 /*    (INCLUDING NEGLIGENCE OR OTHERWISE)  ARISING IN ANY WAY OUT    */
  30 /*    OF  THE  USE OF  THIS  SOFTWARE,  EVEN  IF ADVISED  OF  THE    */
  31 /*    POSSIBILITY OF SUCH DAMAGE.                                    */
  32 /*                                                                   */
  33 /* The views and conclusions contained in the software and           */
  34 /* documentation are those of the authors and should not be          */
  35 /* interpreted as representing official policies, either expressed   */
  36 /* or implied, of The University of Texas at Austin.                 */
  37 /*********************************************************************/
  38
  39 #include <stdio.h>
  40 #include "common.h"
  41
  42 #define a2      (a1 + 2)
  43 #define a4      (a3 + 2)
  44 #define a6      (a5 + 2)
  45 #define a8      (a7 + 2)
  46
  47 int CNAME(BLASLONG n, BLASLONG k1, BLASLONG k2, FLOAT *a, BLASLONG lda, blasint *ipiv, FLOAT *buffer){
  48
  49   BLASLONG i, j, ip1, ip2;
  50   blasint *piv;
  51   FLOAT *a1, *a3, *a5, *a7;
  52   FLOAT *b1, *b2, *b3, *b4;
  53   FLOAT *b5, *b6, *b7, *b8;
  54   FLOAT A1, A2, A3, A4, A5, A6, A7, A8;
  55   FLOAT B1, B2, B3, B4, B5, B6, B7, B8;
  56
  57   FLOAT A9, A10, A11, A12, A13, A14, A15, A16;
  58   FLOAT B9, B10, B11, B12, B13, B14, B15, B16;
  59
  60   a -= 2;
  61   lda *= 2;
  62   k1 --;
  63
  64  ipiv += k1;
  65
  66   if (n  <= 0) return 0;
  67
  68   j = (n >> 2);
  69   if (j > 0) {
  70     do {
  71       piv = ipiv;
  72
  73       a1 = a + (k1 + 1) * 2;
  74
  75       a3 = a1 + 1 * lda;
  76       a5 = a1 + 2 * lda;
  77       a7 = a1 + 3 * lda;
  78
  79       ip1 = *(piv + 0) * 2;
  80       ip2 = *(piv + 1) * 2;
  81       piv += 2;
  82
  83       b1 = a + ip1;
  84       b2 = a + ip2;
  85
  86       b3 = b1 + 1 * lda;
  87       b4 = b2 + 1 * lda;
  88       b5 = b1 + 2 * lda;
  89       b6 = b2 + 2 * lda;
  90       b7 = b1 + 3 * lda;
  91       b8 = b2 + 3 * lda;
  92
  93       i = ((k2 - k1) >> 1);
  94
  95       if (i > 0) {
  96         do {
  97           A1  = *(a1 + 0);
  98           A9  = *(a1 + 1);
  99           A2  = *(a2 + 0);
 100           A10 = *(a2 + 1);
 101           A3  = *(a3 + 0);
 102           A11 = *(a3 + 1);
 103           A4  = *(a4 + 0);
 104           A12 = *(a4 + 1);
 105           A5  = *(a5 + 0);
 106           A13 = *(a5 + 1);
 107           A6  = *(a6 + 0);
 108           A14 = *(a6 + 1);
 109           A7  = *(a7 + 0);
 110           A15 = *(a7 + 1);
 111           A8  = *(a8 + 0);
 112           A16 = *(a8 + 1);
 113
 114           B1  = *(b1 + 0);
 115           B9  = *(b1 + 1);
 116           B2  = *(b2 + 0);
 117           B10 = *(b2 + 1);
 118           B3  = *(b3 + 0);
 119           B11 = *(b3 + 1);
 120           B4  = *(b4 + 0);
 121           B12 = *(b4 + 1);
 122           B5  = *(b5 + 0);
 123           B13 = *(b5 + 1);
 124           B6  = *(b6 + 0);
 125           B14 = *(b6 + 1);
 126           B7  = *(b7 + 0);
 127           B15 = *(b7 + 1);
 128           B8  = *(b8 + 0);
 129           B16 = *(b8 + 1);
 130
 131           ip1 = *(piv + 0) * 2;
 132           ip2 = *(piv + 1) * 2;
 133           piv += 2;
 134
 135         if (b1 == a1) {
 136             if (b2 == a2) {
 137               *(buffer +  0) = A1;
 138               *(buffer +  1) = A9;
 139               *(buffer +  2) = A3;
 140               *(buffer +  3) = A11;
 141               *(buffer +  4) = A5;
 142               *(buffer +  5) = A13;
 143               *(buffer +  6) = A7;
 144               *(buffer +  7) = A15;
 145
 146               *(buffer +  8) = A2;
 147               *(buffer +  9) = A10;
 148               *(buffer + 10) = A4;
 149               *(buffer + 11) = A12;
 150               *(buffer + 12) = A6;
 151               *(buffer + 13) = A14;
 152               *(buffer + 14) = A8;
 153               *(buffer + 15) = A16;
 154             } else {
 155               *(buffer +  0) = A1;
 156               *(buffer +  1) = A9;
 157               *(buffer +  2) = A3;
 158               *(buffer +  3) = A11;
 159               *(buffer +  4) = A5;
 160               *(buffer +  5) = A13;
 161               *(buffer +  6) = A7;
 162               *(buffer +  7) = A15;
 163
 164               *(buffer +  8) = B2;
 165               *(buffer +  9) = B10;
 166               *(buffer + 10) = B4;
 167               *(buffer + 11) = B12;
 168               *(buffer + 12) = B6;
 169               *(buffer + 13) = B14;
 170               *(buffer + 14) = B8;
 171               *(buffer + 15) = B16;
 172
 173               *(b2 + 0) = A2;
 174               *(b2 + 1) = A10;
 175               *(b4 + 0) = A4;
 176               *(b4 + 1) = A12;
 177               *(b6 + 0) = A6;
 178               *(b6 + 1) = A14;
 179               *(b8 + 0) = A8;
 180               *(b8 + 1) = A16;
 181             }
 182         } else
 183           if (b1 == a2) {
 184               if (b2 == a2) {
 185                 *(buffer +  0) = A2;
 186                 *(buffer +  1) = A10;
 187                 *(buffer +  2) = A4;
 188                 *(buffer +  3) = A12;
 189                 *(buffer +  4) = A6;
 190                 *(buffer +  5) = A14;
 191                 *(buffer +  6) = A8;
 192                 *(buffer +  7) = A16;
 193                 *(buffer +  8) = A1;
 194                 *(buffer +  9) = A9;
 195                 *(buffer + 10) = A3;
 196                 *(buffer + 11) = A11;
 197                 *(buffer + 12) = A5;
 198                 *(buffer + 13) = A13;
 199                 *(buffer + 14) = A7;
 200                 *(buffer + 15) = A15;
 201
 202               } else {
 203                 *(buffer +  0) = A2;
 204                 *(buffer +  1) = A10;
 205                 *(buffer +  2) = A4;
 206                 *(buffer +  3) = A12;
 207                 *(buffer +  4) = A6;
 208                 *(buffer +  5) = A14;
 209                 *(buffer +  6) = A8;
 210                 *(buffer +  7) = A16;
 211                 *(buffer +  8) = B2;
 212                 *(buffer +  9) = B10;
 213                 *(buffer + 10) = B4;
 214                 *(buffer + 11) = B12;
 215                 *(buffer + 12) = B6;
 216                 *(buffer + 13) = B14;
 217                 *(buffer + 14) = B8;
 218                 *(buffer + 15) = B16;
 219
 220                 *(b2 + 0) = A1;
 221                 *(b2 + 1) = A9;
 222                 *(b4 + 0) = A3;
 223                 *(b4 + 1) = A11;
 224                 *(b6 + 0) = A5;
 225                 *(b6 + 1) = A13;
 226                 *(b8 + 0) = A7;
 227                 *(b8 + 1) = A15;
 228               }
 229           } else {
 230               if (b2 == a2) {
 231                 *(buffer +  0) = B1;
 232                 *(buffer +  1) = B9;
 233                 *(buffer +  2) = B3;
 234                 *(buffer +  3) = B11;
 235                 *(buffer +  4) = B5;
 236                 *(buffer +  5) = B13;
 237                 *(buffer +  6) = B7;
 238                 *(buffer +  7) = B15;
 239                 *(buffer +  8) = A2;
 240                 *(buffer +  9) = A10;
 241                 *(buffer + 10) = A4;
 242                 *(buffer + 11) = A12;
 243                 *(buffer + 12) = A6;
 244                 *(buffer + 13) = A14;
 245                 *(buffer + 14) = A8;
 246                 *(buffer + 15) = A16;
 247
 248                 *(b1 + 0) = A1;
 249                 *(b1 + 1) = A9;
 250                 *(b3 + 0) = A3;
 251                 *(b3 + 1) = A11;
 252                 *(b5 + 0) = A5;
 253                 *(b5 + 1) = A13;
 254                 *(b7 + 0) = A7;
 255                 *(b7 + 1) = A15;
 256               } else
 257                 if (b2 == b1) {
 258                   *(buffer +  0) = B1;
 259                   *(buffer +  1) = B9;
 260                   *(buffer +  2) = B3;
 261                   *(buffer +  3) = B11;
 262                   *(buffer +  4) = B5;
 263                   *(buffer +  5) = B13;
 264                   *(buffer +  6) = B7;
 265                   *(buffer +  7) = B15;
 266                   *(buffer +  8) = A1;
 267                   *(buffer +  9) = A9;
 268                   *(buffer + 10) = A3;
 269                   *(buffer + 11) = A11;
 270                   *(buffer + 12) = A5;
 271                   *(buffer + 13) = A13;
 272                   *(buffer + 14) = A7;
 273                   *(buffer + 15) = A15;
 274
 275                   *(b1 + 0) = A2;
 276                   *(b1 + 1) = A10;
 277                   *(b3 + 0) = A4;
 278                   *(b3 + 1) = A12;
 279                   *(b5 + 0) = A6;
 280                   *(b5 + 1) = A14;
 281                   *(b7 + 0) = A8;
 282                   *(b7 + 1) = A16;
 283                 } else {
 284                   *(buffer +  0) = B1;
 285                   *(buffer +  1) = B9;
 286                   *(buffer +  2) = B3;
 287                   *(buffer +  3) = B11;
 288                   *(buffer +  4) = B5;
 289                   *(buffer +  5) = B13;
 290                   *(buffer +  6) = B7;
 291                   *(buffer +  7) = B15;
 292                   *(buffer +  8) = B2;
 293                   *(buffer +  9) = B10;
 294                   *(buffer + 10) = B4;
 295                   *(buffer + 11) = B12;
 296                   *(buffer + 12) = B6;
 297                   *(buffer + 13) = B14;
 298                   *(buffer + 14) = B8;
 299                   *(buffer + 15) = B16;
 300
 301                   *(b1 + 0) = A1;
 302                   *(b1 + 1) = A9;
 303                   *(b2 + 0) = A2;
 304                   *(b2 + 1) = A10;
 305                   *(b3 + 0) = A3;
 306                   *(b3 + 1) = A11;
 307                   *(b4 + 0) = A4;
 308                   *(b4 + 1) = A12;
 309                   *(b5 + 0) = A5;
 310                   *(b5 + 1) = A13;
 311                   *(b6 + 0) = A6;
 312                   *(b6 + 1) = A14;
 313                   *(b7 + 0) = A7;
 314                   *(b7 + 1) = A15;
 315                   *(b8 + 0) = A8;
 316                   *(b8 + 1) = A16;
 317                 }
 318           }
 319
 320          buffer += 16;
 321
 322           b1 = a + ip1;
 323           b2 = a + ip2;
 324
 325           b3 = b1 + 1 * lda;
 326           b4 = b2 + 1 * lda;
 327           b5 = b1 + 2 * lda;
 328           b6 = b2 + 2 * lda;
 329           b7 = b1 + 3 * lda;
 330           b8 = b2 + 3 * lda;
 331
 332           a1 += 4;
 333           a3 += 4;
 334           a5 += 4;
 335           a7 += 4;
 336
 337         i --;
 338         } while (i > 0);
 339       }
 340
 341       i = ((k2 - k1) & 1);
 342
 343       if (i > 0) {
 344         A1  = *(a1 + 0);
 345         A9  = *(a1 + 1);
 346         B1  = *(b1 + 0);
 347         B9  = *(b1 + 1);
 348         A3  = *(a3 + 0);
 349         A11 = *(a3 + 1);
 350         B3  = *(b3 + 0);
 351         B11 = *(b3 + 1);
 352         A5  = *(a5 + 0);
 353         A13 = *(a5 + 1);
 354         B5  = *(b5 + 0);
 355         B13 = *(b5 + 1);
 356         A7  = *(a7 + 0);
 357         A15 = *(a7 + 1);
 358         B7  = *(b7 + 0);
 359         B15 = *(b7 + 1);
 360
 361         if (a1 == b1) {
 362           *(buffer + 0) = A1;
 363           *(buffer + 1) = A9;
 364           *(buffer + 2) = A3;
 365           *(buffer + 3) = A11;
 366           *(buffer + 4) = A5;
 367           *(buffer + 5) = A13;
 368           *(buffer + 6) = A7;
 369           *(buffer + 7) = A15;
 370         } else {
 371           *(buffer + 0) = B1;
 372           *(buffer + 1) = B9;
 373           *(buffer + 2) = B3;
 374           *(buffer + 3) = B11;
 375           *(buffer + 4) = B5;
 376           *(buffer + 5) = B13;
 377           *(buffer + 6) = B7;
 378           *(buffer + 7) = B15;
 379
 380           *(b1 + 0) = A1;
 381           *(b1 + 1) = A9;
 382           *(b3 + 0) = A3;
 383           *(b3 + 1) = A11;
 384           *(b5 + 0) = A5;
 385           *(b5 + 1) = A13;
 386           *(b7 + 0) = A7;
 387           *(b7 + 1) = A15;
 388         }
 389         buffer += 8;
 390       }
 391
 392       a += 4 * lda;
 393
 394       j --;
 395     } while (j > 0);
 396   }
 397
 398   if (n & 2) {
 399     piv = ipiv;
 400
 401     a1 = a + (k1 + 1) * 2;
 402     a3 = a1 + lda;
 403
 404     ip1 = *(piv + 0) * 2;
 405     ip2 = *(piv + 1) * 2;
 406     piv += 2;
 407
 408     b1 = a + ip1;
 409     b2 = a + ip2;
 410
 411     b3 = b1 + lda;
 412     b4 = b2 + lda;
 413
 414     i = ((k2 - k1) >> 1);
 415
 416     if (i > 0) {
 417       do {
 418         A1 = *(a1 + 0);
 419         A2 = *(a1 + 1);
 420         A3 = *(a2 + 0);
 421         A4 = *(a2 + 1);
 422         A5 = *(a3 + 0);
 423         A6 = *(a3 + 1);
 424         A7 = *(a4 + 0);
 425         A8 = *(a4 + 1);
 426
 427         B1 = *(b1 + 0);
 428         B2 = *(b1 + 1);
 429         B3 = *(b2 + 0);
 430         B4 = *(b2 + 1);
 431         B5 = *(b3 + 0);
 432         B6 = *(b3 + 1);
 433         B7 = *(b4 + 0);
 434         B8 = *(b4 + 1);
 435
 436         ip1 = *(piv + 0) * 2;
 437         ip2 = *(piv + 1) * 2;
 438         piv += 2;
 439
 440         if (b1 == a1) {
 441           if (b2 == a2) {
 442             *(buffer + 0) = A1;
 443             *(buffer + 1) = A2;
 444             *(buffer + 2) = A5;
 445             *(buffer + 3) = A6;
 446             *(buffer + 4) = A3;
 447             *(buffer + 5) = A4;
 448             *(buffer + 6) = A7;
 449             *(buffer + 7) = A8;
 450           } else {
 451             *(buffer + 0) = A1;
 452             *(buffer + 1) = A2;
 453             *(buffer + 2) = A5;
 454             *(buffer + 3) = A6;
 455             *(buffer + 4) = B3;
 456             *(buffer + 5) = B4;
 457             *(buffer + 6) = B7;
 458             *(buffer + 7) = B8;
 459
 460             *(b2 + 0) = A3;
 461             *(b2 + 1) = A4;
 462             *(b4 + 0) = A7;
 463             *(b4 + 1) = A8;
 464           }
 465         } else {
 466           if (b1 == a2) {
 467             if (b2 == a2) {
 468               *(buffer + 0) = A3;
 469               *(buffer + 1) = A4;
 470               *(buffer + 2) = A7;
 471               *(buffer + 3) = A8;
 472               *(buffer + 4) = A1;
 473               *(buffer + 5) = A2;
 474               *(buffer + 6) = A5;
 475               *(buffer + 7) = A6;
 476             } else {
 477               *(buffer + 0) = A3;
 478               *(buffer + 1) = A4;
 479               *(buffer + 2) = A7;
 480               *(buffer + 3) = A8;
 481               *(buffer + 4) = B3;
 482               *(buffer + 5) = B4;
 483               *(buffer + 6) = B7;
 484               *(buffer + 7) = B8;
 485
 486               *(b2 + 0) = A1;
 487               *(b2 + 1) = A2;
 488               *(b4 + 0) = A5;
 489               *(b4 + 1) = A6;
 490             }
 491           } else {
 492             if (b2 == a2) {
 493               *(buffer + 0) = B1;
 494               *(buffer + 1) = B2;
 495               *(buffer + 2) = B5;
 496               *(buffer + 3) = B6;
 497               *(buffer + 4) = A3;
 498               *(buffer + 5) = A4;
 499               *(buffer + 6) = A7;
 500               *(buffer + 7) = A8;
 501
 502               *(b1 + 0) = A1;
 503               *(b1 + 1) = A2;
 504               *(b3 + 0) = A5;
 505               *(b3 + 1) = A6;
 506             } else {
 507               if (b2 == b1) {
 508                 *(buffer + 0) = B1;
 509                 *(buffer + 1) = B2;
 510                 *(buffer + 2) = B5;
 511                 *(buffer + 3) = B6;
 512                 *(buffer + 4) = A1;
 513                 *(buffer + 5) = A2;
 514                 *(buffer + 6) = A5;
 515                 *(buffer + 7) = A6;
 516
 517                 *(b1 + 0) = A3;
 518                 *(b1 + 1) = A4;
 519                 *(b3 + 0) = A7;
 520                 *(b3 + 1) = A8;
 521               } else {
 522                 *(buffer + 0) = B1;
 523                 *(buffer + 1) = B2;
 524                 *(buffer + 2) = B5;
 525                 *(buffer + 3) = B6;
 526                 *(buffer + 4) = B3;
 527                 *(buffer + 5) = B4;
 528                 *(buffer + 6) = B7;
 529                 *(buffer + 7) = B8;
 530                 *(b1 + 0) = A1;
 531                 *(b1 + 1) = A2;
 532                 *(b2 + 0) = A3;
 533                 *(b2 + 1) = A4;
 534                 *(b3 + 0) = A5;
 535                 *(b3 + 1) = A6;
 536                 *(b4 + 0) = A7;
 537                 *(b4 + 1) = A8;
 538               }
 539             }
 540           }
 541           }
 542
 543           buffer += 8;
 544
 545           b1 = a + ip1;
 546           b2 = a + ip2;
 547
 548           b3 = b1 + lda;
 549           b4 = b2 + lda;
 550
 551           a1 += 4;
 552           a3 += 4;
 553
 554           i --;
 555       } while (i > 0);
 556     }
 557
 558     i = ((k2 - k1) & 1);
 559
 560     if (i > 0) {
 561       A1 = *(a1 + 0);
 562       A2 = *(a1 + 1);
 563       B1 = *(b1 + 0);
 564       B2 = *(b1 + 1);
 565       A3 = *(a3 + 0);
 566       A4 = *(a3 + 1);
 567       B3 = *(b3 + 0);
 568       B4 = *(b3 + 1);
 569
 570       if (a1 == b1) {
 571         *(buffer + 0) = A1;
 572         *(buffer + 1) = A2;
 573         *(buffer + 2) = A3;
 574         *(buffer + 3) = A4;
 575
 576       } else {
 577         *(buffer + 0) = B1;
 578         *(buffer + 1) = B2;
 579         *(buffer + 2) = B3;
 580         *(buffer + 3) = B4;
 581         *(b1 + 0) = A1;
 582         *(b1 + 1) = A2;
 583         *(b3 + 0) = A3;
 584         *(b3 + 1) = A4;
 585       }
 586       buffer += 4;
 587     }
 588
 589     a += 2 * lda;
 590   }
 591
 592   if (n & 1) {
 593     piv = ipiv;
 594
 595     a1 = a + (k1 + 1) * 2;
 596
 597     ip1 = *(piv + 0) * 2;
 598     ip2 = *(piv + 1) * 2;
 599     piv += 2;
 600
 601     b1 = a + ip1;
 602     b2 = a + ip2;
 603
 604     i = ((k2 - k1) >> 1);
 605
 606     if (i > 0) {
 607       do {
 608         A1 = *(a1 + 0);
 609         A2 = *(a1 + 1);
 610         A3 = *(a2 + 0);
 611         A4 = *(a2 + 1);
 612         B1 = *(b1 + 0);
 613         B2 = *(b1 + 1);
 614         B3 = *(b2 + 0);
 615         B4 = *(b2 + 1);
 616
 617         ip1 = *(piv + 0) * 2;
 618         ip2 = *(piv + 1) * 2;
 619         piv += 2;
 620
 621         if (b1 == a1) {
 622           if (b2 == a2) {
 623             *(buffer + 0) = A1;
 624             *(buffer + 1) = A2;
 625             *(buffer + 2) = A3;
 626             *(buffer + 3) = A4;
 627           } else {
 628             *(buffer + 0) = A1;
 629             *(buffer + 1) = A2;
 630             *(buffer + 2) = B3;
 631             *(buffer + 3) = B4;
 632
 633             *(b2 + 0) = A3;
 634             *(b2 + 1) = A4;
 635           }
 636         } else
 637           if (b1 == a2) {
 638             if (b2 == a2) {
 639               *(buffer + 0) = A3;
 640               *(buffer + 1) = A4;
 641               *(buffer + 2) = A1;
 642               *(buffer + 3) = A2;
 643             } else {
 644               *(buffer + 0) = A3;
 645               *(buffer + 1) = A4;
 646               *(buffer + 2) = B3;
 647               *(buffer + 3) = B4;
 648               *(b2 + 0) = A1;
 649               *(b2 + 1) = A2;
 650             }
 651           } else {
 652             if (b2 == a2) {
 653               *(buffer + 0) = B1;
 654               *(buffer + 1) = B2;
 655               *(buffer + 2) = A3;
 656               *(buffer + 3) = A4;
 657               *(b1 + 0) = A1;
 658               *(b1 + 1) = A2;
 659             } else
 660               if (b2 == b1) {
 661                 *(buffer + 0) = B1;
 662                 *(buffer + 1) = B2;
 663                 *(buffer + 2) = A1;
 664                 *(buffer + 3) = A2;
 665                 *(b1 + 0) = A3;
 666                 *(b1 + 1) = A4;
 667               } else {
 668                 *(buffer + 0) = B1;
 669                 *(buffer + 1) = B2;
 670                 *(buffer + 2) = B3;
 671                 *(buffer + 3) = B4;
 672                 *(b1 + 0) = A1;
 673                 *(b1 + 1) = A2;
 674                 *(b2 + 0) = A3;
 675                 *(b2 + 1) = A4;
 676               }
 677           }
 678
 679         buffer += 4;
 680
 681         b1 = a + ip1;
 682         b2 = a + ip2;
 683
 684         a1 += 4;
 685
 686         i --;
 687       } while (i > 0);
 688     }
 689
 690     i = ((k2 - k1) & 1);
 691
 692     if (i > 0) {
 693       A1 = *(a1 + 0);
 694       A2 = *(a1 + 1);
 695       B1 = *(b1 + 0);
 696       B2 = *(b1 + 1);
 697
 698       if (a1 == b1) {
 699         *(buffer + 0) = A1;
 700         *(buffer + 1) = A2;
 701       } else {
 702         *(buffer + 0) = B1;
 703         *(buffer + 1) = B2;
 704         *(b1 + 0) = A1;
 705         *(b1 + 1) = A2;
 706       }
 707       // buffer += 2;
 708     }
 709   }
 710
 711   return 0;
 712 }
 713