kernel/mips/strsm_kernel_LN_8x8_msa.c

   1 /*******************************************************************************
   2 Copyright (c) 2016, The OpenBLAS Project
   3 All rights reserved.
   4 Redistribution and use in source and binary forms, with or without
   5 modification, are permitted provided that the following conditions are
   6 met:
   7 1. Redistributions of source code must retain the above copyright
   8 notice, this list of conditions and the following disclaimer.
   9 2. Redistributions in binary form must reproduce the above copyright
  10 notice, this list of conditions and the following disclaimer in
  11 the documentation and/or other materials provided with the
  12 distribution.
  13 3. Neither the name of the OpenBLAS project nor the names of
  14 its contributors may be used to endorse or promote products
  15 derived from this software without specific prior written permission.
  16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19 ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT OR CONTRIBUTORS BE
  20 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  25 USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 *******************************************************************************/
  27
  28 #include "common.h"
  29 #include "macros_msa.h"
  30
  31 static void ssolve_8x8_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
  32 {
  33     v4f32 src_c0, src_c1, src_c2, src_c3, src_c4, src_c5, src_c6, src_c7;
  34     v4f32 src_c8, src_c9, src_c10, src_c11, src_c12, src_c13, src_c14, src_c15;
  35     v4f32 res_c0, res_c1, res_c2, res_c3, res_c4, res_c5, res_c6, res_c7;
  36     v4f32 res_c8, res_c9, res_c10, res_c11, res_c12, res_c13, res_c14, res_c15;
  37     v4f32 src_a, src_a0, src_a8, src_a9, src_a16, src_a17, src_a18, src_a24;
  38     v4f32 src_a25, src_a26, src_a27, src_a32, src_a33, src_a34, src_a35, src_a36;
  39     v4f32 src_a40, src_a41, src_a42, src_a43, src_a44, src_a45;
  40     v4f32 src_a48, src_a49, src_a50, src_a51, src_a52, src_a53, src_a54;
  41     v4f32 src_a56, src_a57, src_a58, src_a59, src_a60, src_a61, src_a62, src_a63;
  42     FLOAT *c_nxt1line = c + ldc;
  43     FLOAT *c_nxt2line = c + 2 * ldc;
  44     FLOAT *c_nxt3line = c + 3 * ldc;
  45     FLOAT *c_nxt4line = c + 4 * ldc;
  46     FLOAT *c_nxt5line = c + 5 * ldc;
  47     FLOAT *c_nxt6line = c + 6 * ldc;
  48     FLOAT *c_nxt7line = c + 7 * ldc;
  49
  50     LD_SP2(c, 4, src_c0, src_c1);
  51     LD_SP2(c_nxt1line, 4, src_c2, src_c3);
  52     LD_SP2(c_nxt2line, 4, src_c4, src_c5);
  53     LD_SP2(c_nxt3line, 4, src_c6, src_c7);
  54     LD_SP2(c_nxt4line, 4, src_c8, src_c9);
  55     LD_SP2(c_nxt5line, 4, src_c10, src_c11);
  56     LD_SP2(c_nxt6line, 4, src_c12, src_c13);
  57     LD_SP2(c_nxt7line, 4, src_c14, src_c15);
  58
  59     if (bk > 0)
  60     {
  61         BLASLONG k, pref_offset;
  62         FLOAT *aa = a, *bb = b, *pa0_pref;
  63         v4f32 src_a1, src_b0, src_b1, src_b2, src_b3, src_bb0, src_bb1;
  64
  65         pref_offset = (uintptr_t)a & (L1_DATA_LINESIZE - 1);
  66
  67         if (pref_offset)
  68         {
  69             pref_offset = L1_DATA_LINESIZE - pref_offset;
  70             pref_offset = pref_offset / sizeof(FLOAT);
  71         }
  72
  73         pa0_pref = a + pref_offset;
  74
  75         for (k = 0; k < (bk >> 1); k++)
  76         {
  77             PREF_OFFSET(pa0_pref, 64);
  78             PREF_OFFSET(pa0_pref, 96);
  79
  80             LD_SP2_INC(aa, 4, src_a0, src_a1);
  81             LD_SP2_INC(bb, 4, src_bb0, src_bb1);
  82
  83             SPLATI_W4_SP(src_bb0, src_b0, src_b1, src_b2, src_b3);
  84             src_c0 -= src_a0 * src_b0;
  85             src_c1 -= src_a1 * src_b0;
  86             src_c2 -= src_a0 * src_b1;
  87             src_c3 -= src_a1 * src_b1;
  88             src_c4 -= src_a0 * src_b2;
  89             src_c5 -= src_a1 * src_b2;
  90             src_c6 -= src_a0 * src_b3;
  91             src_c7 -= src_a1 * src_b3;
  92
  93             SPLATI_W4_SP(src_bb1, src_b0, src_b1, src_b2, src_b3);
  94             src_c8 -= src_a0 * src_b0;
  95             src_c9 -= src_a1 * src_b0;
  96             src_c10 -= src_a0 * src_b1;
  97             src_c11 -= src_a1 * src_b1;
  98             src_c12 -= src_a0 * src_b2;
  99             src_c13 -= src_a1 * src_b2;
 100             src_c14 -= src_a0 * src_b3;
 101             src_c15 -= src_a1 * src_b3;
 102
 103             LD_SP2_INC(aa, 4, src_a0, src_a1);
 104             LD_SP2_INC(bb, 4, src_bb0, src_bb1);
 105
 106             SPLATI_W4_SP(src_bb0, src_b0, src_b1, src_b2, src_b3);
 107             src_c0 -= src_a0 * src_b0;
 108             src_c1 -= src_a1 * src_b0;
 109             src_c2 -= src_a0 * src_b1;
 110             src_c3 -= src_a1 * src_b1;
 111             src_c4 -= src_a0 * src_b2;
 112             src_c5 -= src_a1 * src_b2;
 113             src_c6 -= src_a0 * src_b3;
 114             src_c7 -= src_a1 * src_b3;
 115
 116             SPLATI_W4_SP(src_bb1, src_b0, src_b1, src_b2, src_b3);
 117             src_c8 -= src_a0 * src_b0;
 118             src_c9 -= src_a1 * src_b0;
 119             src_c10 -= src_a0 * src_b1;
 120             src_c11 -= src_a1 * src_b1;
 121             src_c12 -= src_a0 * src_b2;
 122             src_c13 -= src_a1 * src_b2;
 123             src_c14 -= src_a0 * src_b3;
 124             src_c15 -= src_a1 * src_b3;
 125
 126             pa0_pref += 16;
 127         }
 128
 129         if (bk & 1)
 130         {
 131             LD_SP2_INC(aa, 4, src_a0, src_a1);
 132             LD_SP2_INC(bb, 4, src_bb0, src_bb1);
 133
 134             SPLATI_W4_SP(src_bb0, src_b0, src_b1, src_b2, src_b3);
 135             src_c0 -= src_a0 * src_b0;
 136             src_c1 -= src_a1 * src_b0;
 137             src_c2 -= src_a0 * src_b1;
 138             src_c3 -= src_a1 * src_b1;
 139             src_c4 -= src_a0 * src_b2;
 140             src_c5 -= src_a1 * src_b2;
 141             src_c6 -= src_a0 * src_b3;
 142             src_c7 -= src_a1 * src_b3;
 143
 144             SPLATI_W4_SP(src_bb1, src_b0, src_b1, src_b2, src_b3);
 145             src_c8 -= src_a0 * src_b0;
 146             src_c9 -= src_a1 * src_b0;
 147             src_c10 -= src_a0 * src_b1;
 148             src_c11 -= src_a1 * src_b1;
 149             src_c12 -= src_a0 * src_b2;
 150             src_c13 -= src_a1 * src_b2;
 151             src_c14 -= src_a0 * src_b3;
 152             src_c15 -= src_a1 * src_b3;
 153         }
 154     }
 155
 156     a -= 64;
 157     b -= 64;
 158
 159     TRANSPOSE4x4_SP_SP(src_c1, src_c3, src_c5, src_c7,
 160                        res_c4, res_c5, res_c6, res_c7);
 161     TRANSPOSE4x4_SP_SP(src_c9, src_c11, src_c13, src_c15,
 162                        res_c12, res_c13, res_c14, res_c15);
 163     TRANSPOSE4x4_SP_SP(src_c0, src_c2, src_c4, src_c6,
 164                        res_c0, res_c1, res_c2, res_c3);
 165     TRANSPOSE4x4_SP_SP(src_c8, src_c10, src_c12, src_c14,
 166                        res_c8, res_c9, res_c10, res_c11);
 167
 168     src_a = LD_SP(a + 60);
 169     SPLATI_W4_SP(src_a, src_a60, src_a61, src_a62, src_a63);
 170     src_a = LD_SP(a + 56);
 171     SPLATI_W4_SP(src_a, src_a56, src_a57, src_a58, src_a59);
 172
 173     res_c7 *= src_a63;
 174     res_c15 *= src_a63;
 175     res_c6 -= res_c7 * src_a62;
 176     res_c14 -= res_c15 * src_a62;
 177     res_c5 -= res_c7 * src_a61;
 178     res_c13 -= res_c15 * src_a61;
 179     res_c4 -= res_c7 * src_a60;
 180     res_c12 -= res_c15 * src_a60;
 181     res_c3 -= res_c7 * src_a59;
 182     res_c11 -= res_c15 * src_a59;
 183     res_c2 -= res_c7 * src_a58;
 184     res_c10 -= res_c15 * src_a58;
 185     res_c1 -= res_c7 * src_a57;
 186     res_c9 -= res_c15 * src_a57;
 187     res_c0 -= res_c7 * src_a56;
 188     res_c8 -= res_c15 * src_a56;
 189
 190     src_a = LD_SP(a + 48);
 191     SPLATI_W4_SP(src_a, src_a48, src_a49, src_a50, src_a51);
 192     src_a52 = LD_SP(a + 52);
 193     src_a54 = (v4f32) __msa_splati_w((v4i32) src_a52, 2);
 194     src_a53 = (v4f32) __msa_splati_w((v4i32) src_a52, 1);
 195     src_a52 = (v4f32) __msa_splati_w((v4i32) src_a52, 0);
 196
 197     res_c6 *= src_a54;
 198     res_c14 *= src_a54;
 199     res_c5 -= res_c6 * src_a53;
 200     res_c13 -= res_c14 * src_a53;
 201     res_c4 -= res_c6 * src_a52;
 202     res_c12 -= res_c14 * src_a52;
 203     res_c3 -= res_c6 * src_a51;
 204     res_c11 -= res_c14 * src_a51;
 205     res_c2 -= res_c6 * src_a50;
 206     res_c10 -= res_c14 * src_a50;
 207     res_c1 -= res_c6 * src_a49;
 208     res_c9 -= res_c14 * src_a49;
 209     res_c0 -= res_c6 * src_a48;
 210     res_c8 -= res_c14 * src_a48;
 211
 212     src_a = LD_SP(a + 40);
 213     SPLATI_W4_SP(src_a, src_a40, src_a41, src_a42, src_a43);
 214     src_a44 = LD_SP(a + 44);
 215     src_a45 = (v4f32) __msa_splati_w((v4i32) src_a44, 1);
 216     src_a44 = (v4f32) __msa_splati_w((v4i32) src_a44, 0);
 217
 218     res_c5 *= src_a45;
 219     res_c13 *= src_a45;
 220     res_c4 -= res_c5 * src_a44;
 221     res_c12 -= res_c13 * src_a44;
 222     res_c3 -= res_c5 * src_a43;
 223     res_c11 -= res_c13 * src_a43;
 224     res_c2 -= res_c5 * src_a42;
 225     res_c10 -= res_c13 * src_a42;
 226     res_c1 -= res_c5 * src_a41;
 227     res_c9 -= res_c13 * src_a41;
 228     res_c0 -= res_c5 * src_a40;
 229     res_c8 -= res_c13 * src_a40;
 230
 231     src_a = LD_SP(a + 32);
 232     SPLATI_W4_SP(src_a, src_a32, src_a33, src_a34, src_a35);
 233     src_a36 = COPY_FLOAT_TO_VECTOR(*(a + 36));
 234
 235     res_c4 *= src_a36;
 236     res_c12 *= src_a36;
 237     res_c3 -= res_c4 * src_a35;
 238     res_c11 -= res_c12 * src_a35;
 239     res_c2 -= res_c4 * src_a34;
 240     res_c10 -= res_c12 * src_a34;
 241     res_c1 -= res_c4 * src_a33;
 242     res_c9 -= res_c12 * src_a33;
 243     res_c0 -= res_c4 * src_a32;
 244     res_c8 -= res_c12 * src_a32;
 245
 246     ST_SP4(res_c4, res_c12, res_c5, res_c13, b + 32, 4);
 247     ST_SP4(res_c6, res_c14, res_c7, res_c15, b + 48, 4);
 248
 249     TRANSPOSE4x4_SP_SP(res_c4, res_c5, res_c6, res_c7,
 250                        src_c1, src_c3, src_c5, src_c7);
 251     TRANSPOSE4x4_SP_SP(res_c12, res_c13, res_c14, res_c15,
 252                        src_c9, src_c11, src_c13, src_c15);
 253
 254     ST_SP(src_c1, c + 4);
 255     ST_SP(src_c3, c_nxt1line + 4);
 256     ST_SP(src_c5, c_nxt2line + 4);
 257     ST_SP(src_c7, c_nxt3line + 4);
 258     ST_SP(src_c9, c_nxt4line + 4);
 259     ST_SP(src_c11, c_nxt5line + 4);
 260     ST_SP(src_c13, c_nxt6line + 4);
 261     ST_SP(src_c15, c_nxt7line + 4);
 262
 263     src_a = LD_SP(a + 24);
 264     SPLATI_W4_SP(src_a, src_a24, src_a25, src_a26, src_a27);
 265
 266     res_c3 *= src_a27;
 267     res_c11 *= src_a27;
 268     res_c2 -= res_c3 * src_a26;
 269     res_c10 -= res_c11 * src_a26;
 270     res_c1 -= res_c3 * src_a25;
 271     res_c9 -= res_c11 * src_a25;
 272     res_c0 -= res_c3 * src_a24;
 273     res_c8 -= res_c11 * src_a24;
 274
 275     src_a16 = LD_SP(a + 16);
 276     src_a18 = (v4f32) __msa_splati_w((v4i32) src_a16, 2);
 277     src_a17 = (v4f32) __msa_splati_w((v4i32) src_a16, 1);
 278     src_a16 = (v4f32) __msa_splati_w((v4i32) src_a16, 0);
 279
 280     res_c2 *= src_a18;
 281     res_c10 *= src_a18;
 282     res_c1 -= res_c2 * src_a17;
 283     res_c9 -= res_c10 * src_a17;
 284     res_c0 -= res_c2 * src_a16;
 285     res_c8 -= res_c10 * src_a16;
 286
 287     src_a9 = COPY_FLOAT_TO_VECTOR(*(a + 9));
 288     src_a8 = COPY_FLOAT_TO_VECTOR(*(a + 8));
 289     src_a0 = COPY_FLOAT_TO_VECTOR(*(a + 0));
 290
 291     res_c1 *= src_a9;
 292     res_c9 *= src_a9;
 293     res_c0 -= res_c1 * src_a8;
 294     res_c8 -= res_c9 * src_a8;
 295
 296     res_c0 *= src_a0;
 297     res_c8 *= src_a0;
 298
 299     ST_SP4(res_c0, res_c8, res_c1, res_c9, b, 4);
 300     ST_SP4(res_c2, res_c10, res_c3, res_c11, b + 16, 4);
 301
 302     TRANSPOSE4x4_SP_SP(res_c0, res_c1, res_c2, res_c3,
 303                        src_c0, src_c2, src_c4, src_c6);
 304     TRANSPOSE4x4_SP_SP(res_c8, res_c9, res_c10, res_c11,
 305                        src_c8, src_c10, src_c12, src_c14);
 306
 307     ST_SP(src_c0, c);
 308     ST_SP(src_c2, c_nxt1line);
 309     ST_SP(src_c4, c_nxt2line);
 310     ST_SP(src_c6, c_nxt3line);
 311     ST_SP(src_c8, c_nxt4line);
 312     ST_SP(src_c10, c_nxt5line);
 313     ST_SP(src_c12, c_nxt6line);
 314     ST_SP(src_c14, c_nxt7line);
 315 }
 316
 317 static void ssolve_8x4_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
 318 {
 319     BLASLONG k;
 320     FLOAT *aa = a, *bb = b;
 321     v4f32 src_b, src_b0, src_b1, src_b2, src_b3, src_a1;
 322     v4f32 src_c0, src_c1, src_c2, src_c3, src_c4, src_c5, src_c6, src_c7;
 323     v4f32 res_c0, res_c1, res_c2, res_c3, res_c4, res_c5, res_c6, res_c7;
 324     v4f32 src_a, src_a0, src_a8, src_a9, src_a16, src_a17, src_a18, src_a24;
 325     v4f32 src_a25, src_a26, src_a27, src_a32, src_a33, src_a34, src_a35;
 326     v4f32 src_a36, src_a40, src_a41, src_a42, src_a43, src_a44, src_a45;
 327     v4f32 src_a48, src_a49, src_a50, src_a51, src_a52, src_a53, src_a54;
 328     v4f32 src_a56, src_a57, src_a58, src_a59, src_a60, src_a61, src_a62, src_a63;
 329     FLOAT *c_nxt1line = c + ldc;
 330     FLOAT *c_nxt2line = c + 2 * ldc;
 331     FLOAT *c_nxt3line = c + 3 * ldc;
 332
 333     LD_SP2(c, 4, src_c0, src_c1);
 334     LD_SP2(c_nxt1line, 4, src_c2, src_c3);
 335     LD_SP2(c_nxt2line, 4, src_c4, src_c5);
 336     LD_SP2(c_nxt3line, 4, src_c6, src_c7);
 337
 338     for (k = 0; k < (bk >> 1); k++)
 339     {
 340         LD_SP2(aa, 4, src_a0, src_a1);
 341
 342         src_b = LD_SP(bb + 0);
 343         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 344         src_c0 -= src_a0 * src_b0;
 345         src_c1 -= src_a1 * src_b0;
 346         src_c2 -= src_a0 * src_b1;
 347         src_c3 -= src_a1 * src_b1;
 348         src_c4 -= src_a0 * src_b2;
 349         src_c5 -= src_a1 * src_b2;
 350         src_c6 -= src_a0 * src_b3;
 351         src_c7 -= src_a1 * src_b3;
 352
 353         aa += 8;
 354         bb += 4;
 355
 356         LD_SP2(aa, 4, src_a0, src_a1);
 357
 358         src_b = LD_SP(bb + 0);
 359         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 360         src_c0 -= src_a0 * src_b0;
 361         src_c1 -= src_a1 * src_b0;
 362         src_c2 -= src_a0 * src_b1;
 363         src_c3 -= src_a1 * src_b1;
 364         src_c4 -= src_a0 * src_b2;
 365         src_c5 -= src_a1 * src_b2;
 366         src_c6 -= src_a0 * src_b3;
 367         src_c7 -= src_a1 * src_b3;
 368
 369         aa += 8;
 370         bb += 4;
 371     }
 372
 373     if ((bk & 1) && (bk > 0))
 374     {
 375         LD_SP2(aa, 4, src_a0, src_a1);
 376
 377         src_b = LD_SP(bb + 0);
 378         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 379         src_c0 -= src_a0 * src_b0;
 380         src_c1 -= src_a1 * src_b0;
 381         src_c2 -= src_a0 * src_b1;
 382         src_c3 -= src_a1 * src_b1;
 383         src_c4 -= src_a0 * src_b2;
 384         src_c5 -= src_a1 * src_b2;
 385         src_c6 -= src_a0 * src_b3;
 386         src_c7 -= src_a1 * src_b3;
 387     }
 388
 389     a -= 64;
 390     b -= 32;
 391
 392     TRANSPOSE4x4_SP_SP(src_c0, src_c2, src_c4, src_c6,
 393                        res_c0, res_c1, res_c2, res_c3);
 394     TRANSPOSE4x4_SP_SP(src_c1, src_c3, src_c5, src_c7,
 395                        res_c4, res_c5, res_c6, res_c7);
 396
 397     src_a = LD_SP(a + 60);
 398     SPLATI_W4_SP(src_a, src_a60, src_a61, src_a62, src_a63);
 399     src_a = LD_SP(a + 56);
 400     SPLATI_W4_SP(src_a, src_a56, src_a57, src_a58, src_a59);
 401
 402     src_a = LD_SP(a + 48);
 403     SPLATI_W4_SP(src_a, src_a48, src_a49, src_a50, src_a51);
 404     src_a52 = LD_SP(a + 52);
 405     src_a54 = (v4f32) __msa_splati_w((v4i32) src_a52, 2);
 406     src_a53 = (v4f32) __msa_splati_w((v4i32) src_a52, 1);
 407     src_a52 = (v4f32) __msa_splati_w((v4i32) src_a52, 0);
 408
 409     res_c7 *= src_a63;
 410     res_c6 -= res_c7 * src_a62;
 411     res_c5 -= res_c7 * src_a61;
 412     res_c4 -= res_c7 * src_a60;
 413     res_c3 -= res_c7 * src_a59;
 414     res_c2 -= res_c7 * src_a58;
 415     res_c1 -= res_c7 * src_a57;
 416     res_c0 -= res_c7 * src_a56;
 417
 418     res_c6 *= src_a54;
 419     res_c5 -= res_c6 * src_a53;
 420     res_c4 -= res_c6 * src_a52;
 421     res_c3 -= res_c6 * src_a51;
 422     res_c2 -= res_c6 * src_a50;
 423     res_c1 -= res_c6 * src_a49;
 424     res_c0 -= res_c6 * src_a48;
 425
 426     src_a = LD_SP(a + 40);
 427     SPLATI_W4_SP(src_a, src_a40, src_a41, src_a42, src_a43);
 428     src_a44 = LD_SP(a + 44);
 429     src_a45 = (v4f32) __msa_splati_w((v4i32) src_a44, 1);
 430     src_a44 = (v4f32) __msa_splati_w((v4i32) src_a44, 0);
 431
 432     res_c5 *= src_a45;
 433     res_c4 -= res_c5 * src_a44;
 434     res_c3 -= res_c5 * src_a43;
 435     res_c2 -= res_c5 * src_a42;
 436     res_c1 -= res_c5 * src_a41;
 437     res_c0 -= res_c5 * src_a40;
 438
 439     src_a = LD_SP(a + 32);
 440     SPLATI_W4_SP(src_a, src_a32, src_a33, src_a34, src_a35);
 441     src_a36 = COPY_FLOAT_TO_VECTOR(*(a + 36));
 442
 443     res_c4 *= src_a36;
 444     res_c3 -= res_c4 * src_a35;
 445     res_c2 -= res_c4 * src_a34;
 446     res_c1 -= res_c4 * src_a33;
 447     res_c0 -= res_c4 * src_a32;
 448
 449     src_a = LD_SP(a + 24);
 450     SPLATI_W4_SP(src_a, src_a24, src_a25, src_a26, src_a27);
 451
 452     res_c3 *= src_a27;
 453     res_c2 -= res_c3 * src_a26;
 454     res_c1 -= res_c3 * src_a25;
 455     res_c0 -= res_c3 * src_a24;
 456
 457     src_a16 = LD_SP(a + 16);
 458     src_a18 = (v4f32) __msa_splati_w((v4i32) src_a16, 2);
 459     src_a17 = (v4f32) __msa_splati_w((v4i32) src_a16, 1);
 460     src_a16 = (v4f32) __msa_splati_w((v4i32) src_a16, 0);
 461
 462     res_c2 *= src_a18;
 463     res_c1 -= res_c2 * src_a17;
 464     res_c0 -= res_c2 * src_a16;
 465
 466     src_a9 = COPY_FLOAT_TO_VECTOR(*(a + 9));
 467     src_a8 = COPY_FLOAT_TO_VECTOR(*(a + 8));
 468     src_a0 = COPY_FLOAT_TO_VECTOR(*(a + 0));
 469
 470     res_c1 *= src_a9;
 471     res_c0 -= res_c1 * src_a8;
 472
 473     res_c0 *= src_a0;
 474
 475     ST_SP4(res_c0, res_c1, res_c2, res_c3, b, 4);
 476     ST_SP4(res_c4, res_c5, res_c6, res_c7, b + 16, 4);
 477
 478     TRANSPOSE4x4_SP_SP(res_c0, res_c1, res_c2, res_c3,
 479                        src_c0, src_c2, src_c4, src_c6);
 480     TRANSPOSE4x4_SP_SP(res_c4, res_c5, res_c6, res_c7,
 481                        src_c1, src_c3, src_c5, src_c7);
 482
 483     ST_SP2(src_c0, src_c1, c, 4);
 484     ST_SP2(src_c2, src_c3, c_nxt1line, 4);
 485     ST_SP2(src_c4, src_c5, c_nxt2line, 4);
 486     ST_SP2(src_c6, src_c7, c_nxt3line, 4);
 487 }
 488
 489 static void ssolve_8x2_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
 490 {
 491     BLASLONG k;
 492     FLOAT *aa = a, *bb = b;
 493     FLOAT a0, a8, a9, a16, a17, a18, a24, a25, a26, a27, a32, a33, a34, a35;
 494     FLOAT a36, a40, a41, a42, a43, a44, a45, a48, a49, a50, a51, a52, a53;
 495     FLOAT a54, a56, a57, a58, a59, a60, a61, a62, a63;
 496     FLOAT c0, c1, c2, c3, c4, c5, c6, c7;
 497     FLOAT c0_nxt, c1_nxt, c2_nxt, c3_nxt, c4_nxt, c5_nxt, c6_nxt, c7_nxt;
 498
 499     c0 = *(c + 0);
 500     c1 = *(c + 1);
 501     c2 = *(c + 2);
 502     c3 = *(c + 3);
 503     c4 = *(c + 4);
 504     c5 = *(c + 5);
 505     c6 = *(c + 6);
 506     c7 = *(c + 7);
 507     c0_nxt = *(c + 0 + ldc);
 508     c1_nxt = *(c + 1 + ldc);
 509     c2_nxt = *(c + 2 + ldc);
 510     c3_nxt = *(c + 3 + ldc);
 511     c4_nxt = *(c + 4 + ldc);
 512     c5_nxt = *(c + 5 + ldc);
 513     c6_nxt = *(c + 6 + ldc);
 514     c7_nxt = *(c + 7 + ldc);
 515
 516     for (k = 0; k < bk; k++)
 517     {
 518         c0 -= aa[0] * bb[0];
 519         c1 -= aa[1] * bb[0];
 520         c2 -= aa[2] * bb[0];
 521         c3 -= aa[3] * bb[0];
 522         c4 -= aa[4] * bb[0];
 523         c5 -= aa[5] * bb[0];
 524         c6 -= aa[6] * bb[0];
 525         c7 -= aa[7] * bb[0];
 526         c0_nxt -= aa[0] * bb[1];
 527         c1_nxt -= aa[1] * bb[1];
 528         c2_nxt -= aa[2] * bb[1];
 529         c3_nxt -= aa[3] * bb[1];
 530         c4_nxt -= aa[4] * bb[1];
 531         c5_nxt -= aa[5] * bb[1];
 532         c6_nxt -= aa[6] * bb[1];
 533         c7_nxt -= aa[7] * bb[1];
 534
 535         aa += 8;
 536         bb += 2;
 537     }
 538
 539     a -= 64;
 540     b -= 16;
 541
 542     a0 = *(a + 0);
 543     a8 = *(a + 8);
 544     a9 = *(a + 9);
 545     a16 = *(a + 16);
 546     a17 = *(a + 17);
 547     a18 = *(a + 18);
 548     a24 = *(a + 24);
 549     a25 = *(a + 25);
 550     a26 = *(a + 26);
 551     a27 = *(a + 27);
 552     a32 = *(a + 32);
 553     a33 = *(a + 33);
 554     a34 = *(a + 34);
 555     a35 = *(a + 35);
 556     a36 = *(a + 36);
 557     a40 = *(a + 40);
 558     a41 = *(a + 41);
 559     a42 = *(a + 42);
 560     a43 = *(a + 43);
 561     a44 = *(a + 44);
 562     a45 = *(a + 45);
 563     a48 = *(a + 48);
 564     a49 = *(a + 49);
 565     a50 = *(a + 50);
 566     a51 = *(a + 51);
 567     a52 = *(a + 52);
 568     a53 = *(a + 53);
 569     a54 = *(a + 54);
 570     a56 = *(a + 56);
 571     a57 = *(a + 57);
 572     a58 = *(a + 58);
 573     a59 = *(a + 59);
 574     a60 = *(a + 60);
 575     a61 = *(a + 61);
 576     a62 = *(a + 62);
 577     a63 = *(a + 63);
 578
 579     c7 *= a63;
 580     c7_nxt *= a63;
 581     c6 -= c7 * a62;
 582     c6_nxt -= c7_nxt * a62;
 583     c5 -= c7 * a61;
 584     c5_nxt -= c7_nxt * a61;
 585     c4 -= c7 * a60;
 586     c4_nxt -= c7_nxt * a60;
 587     c3 -= c7 * a59;
 588     c3_nxt -= c7_nxt * a59;
 589     c2 -= c7 * a58;
 590     c2_nxt -= c7_nxt * a58;
 591     c1 -= c7 * a57;
 592     c1_nxt -= c7_nxt * a57;
 593     c0 -= c7 * a56;
 594     c0_nxt -= c7_nxt * a56;
 595
 596     c6 *= a54;
 597     c6_nxt *= a54;
 598     c5 -= c6 * a53;
 599     c5_nxt -= c6_nxt * a53;
 600     c4 -= c6 * a52;
 601     c4_nxt -= c6_nxt * a52;
 602     c3 -= c6 * a51;
 603     c3_nxt -= c6_nxt * a51;
 604     c2 -= c6 * a50;
 605     c2_nxt -= c6_nxt * a50;
 606     c1 -= c6 * a49;
 607     c1_nxt -= c6_nxt * a49;
 608     c0 -= c6 * a48;
 609     c0_nxt -= c6_nxt * a48;
 610
 611     c5 *= a45;
 612     c5_nxt *= a45;
 613     c4 -= c5 * a44;
 614     c4_nxt -= c5_nxt * a44;
 615     c3 -= c5 * a43;
 616     c3_nxt -= c5_nxt * a43;
 617     c2 -= c5 * a42;
 618     c2_nxt -= c5_nxt * a42;
 619     c1 -= c5 * a41;
 620     c1_nxt -= c5_nxt * a41;
 621     c0 -= c5 * a40;
 622     c0_nxt -= c5_nxt * a40;
 623
 624     c4 *= a36;
 625     c4_nxt *= a36;
 626     c3 -= c4 * a35;
 627     c3_nxt -= c4_nxt * a35;
 628     c2 -= c4 * a34;
 629     c2_nxt -= c4_nxt * a34;
 630     c1 -= c4 * a33;
 631     c1_nxt -= c4_nxt * a33;
 632     c0 -= c4 * a32;
 633     c0_nxt -= c4_nxt * a32;
 634
 635     c3 *= a27;
 636     c3_nxt *= a27;
 637     c2 -= c3 * a26;
 638     c2_nxt -= c3_nxt * a26;
 639     c1 -= c3 * a25;
 640     c1_nxt -= c3_nxt * a25;
 641     c0 -= c3 * a24;
 642     c0_nxt -= c3_nxt * a24;
 643
 644     c2 *= a18;
 645     c2_nxt *= a18;
 646     c1 -= c2 * a17;
 647     c1_nxt -= c2_nxt * a17;
 648     c0 -= c2 * a16;
 649     c0_nxt -= c2_nxt * a16;
 650
 651     c1 *= a9;
 652     c1_nxt *= a9;
 653     c0 -= c1 * a8;
 654     c0_nxt -= c1_nxt * a8;
 655
 656     c0 *= a0;
 657     c0_nxt *= a0;
 658
 659     *(b + 0) = c0;
 660     *(b + 1) = c0_nxt;
 661     *(b + 2) = c1;
 662     *(b + 3) = c1_nxt;
 663     *(b + 4) = c2;
 664     *(b + 5) = c2_nxt;
 665     *(b + 6) = c3;
 666     *(b + 7) = c3_nxt;
 667     *(b + 8) = c4;
 668     *(b + 9) = c4_nxt;
 669     *(b + 10) = c5;
 670     *(b + 11) = c5_nxt;
 671     *(b + 12) = c6;
 672     *(b + 13) = c6_nxt;
 673     *(b + 14) = c7;
 674     *(b + 15) = c7_nxt;
 675
 676     *(c + 0) = c0;
 677     *(c + 1) = c1;
 678     *(c + 2) = c2;
 679     *(c + 3) = c3;
 680     *(c + 4) = c4;
 681     *(c + 5) = c5;
 682     *(c + 6) = c6;
 683     *(c + 7) = c7;
 684     *(c + 0 + ldc) = c0_nxt;
 685     *(c + 1 + ldc) = c1_nxt;
 686     *(c + 2 + ldc) = c2_nxt;
 687     *(c + 3 + ldc) = c3_nxt;
 688     *(c + 4 + ldc) = c4_nxt;
 689     *(c + 5 + ldc) = c5_nxt;
 690     *(c + 6 + ldc) = c6_nxt;
 691     *(c + 7 + ldc) = c7_nxt;
 692 }
 693
 694 static void ssolve_8x1_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG bk)
 695 {
 696     BLASLONG k;
 697     FLOAT *aa = a, *bb = b;
 698     FLOAT a0, a8, a9, a16, a17, a18, a24, a25, a26, a27, a32, a33, a34, a35;
 699     FLOAT a36, a40, a41, a42, a43, a44, a45, a48, a49, a50, a51, a52, a53;
 700     FLOAT a54, a56, a57, a58, a59, a60, a61, a62, a63;
 701     FLOAT c0, c1, c2, c3, c4, c5, c6, c7;
 702
 703     c0 = *(c + 0);
 704     c1 = *(c + 1);
 705     c2 = *(c + 2);
 706     c3 = *(c + 3);
 707     c4 = *(c + 4);
 708     c5 = *(c + 5);
 709     c6 = *(c + 6);
 710     c7 = *(c + 7);
 711
 712     for (k = 0; k < bk; k++)
 713     {
 714         c0 -= aa[0] * bb[0];
 715         c1 -= aa[1] * bb[0];
 716         c2 -= aa[2] * bb[0];
 717         c3 -= aa[3] * bb[0];
 718         c4 -= aa[4] * bb[0];
 719         c5 -= aa[5] * bb[0];
 720         c6 -= aa[6] * bb[0];
 721         c7 -= aa[7] * bb[0];
 722
 723         aa += 8;
 724         bb += 1;
 725     }
 726
 727     a -= 64;
 728     b -= 8;
 729
 730     a0 = *(a + 0);
 731     a8 = *(a + 8);
 732     a9 = *(a + 9);
 733     a16 = *(a + 16);
 734     a17 = *(a + 17);
 735     a18 = *(a + 18);
 736     a24 = *(a + 24);
 737     a25 = *(a + 25);
 738     a26 = *(a + 26);
 739     a27 = *(a + 27);
 740     a32 = *(a + 32);
 741     a33 = *(a + 33);
 742     a34 = *(a + 34);
 743     a35 = *(a + 35);
 744     a36 = *(a + 36);
 745     a40 = *(a + 40);
 746     a41 = *(a + 41);
 747     a42 = *(a + 42);
 748     a43 = *(a + 43);
 749     a44 = *(a + 44);
 750     a45 = *(a + 45);
 751     a48 = *(a + 48);
 752     a49 = *(a + 49);
 753     a50 = *(a + 50);
 754     a51 = *(a + 51);
 755     a52 = *(a + 52);
 756     a53 = *(a + 53);
 757     a54 = *(a + 54);
 758     a56 = *(a + 56);
 759     a57 = *(a + 57);
 760     a58 = *(a + 58);
 761     a59 = *(a + 59);
 762     a60 = *(a + 60);
 763     a61 = *(a + 61);
 764     a62 = *(a + 62);
 765     a63 = *(a + 63);
 766
 767     c7 *= a63;
 768
 769     c6 -= c7 * a62;
 770     c6 *= a54;
 771
 772     c5 -= c7 * a61;
 773     c5 -= c6 * a53;
 774     c5 *= a45;
 775
 776     c4 -= c7 * a60;
 777     c4 -= c6 * a52;
 778     c4 -= c5 * a44;
 779     c4 *= a36;
 780
 781     c3 -= c7 * a59;
 782     c3 -= c6 * a51;
 783     c3 -= c5 * a43;
 784     c3 -= c4 * a35;
 785     c3 *= a27;
 786
 787     c2 -= c7 * a58;
 788     c2 -= c6 * a50;
 789     c2 -= c5 * a42;
 790     c2 -= c4 * a34;
 791     c2 -= c3 * a26;
 792     c2 *= a18;
 793
 794     c1 -= c7 * a57;
 795     c1 -= c6 * a49;
 796     c1 -= c5 * a41;
 797     c1 -= c4 * a33;
 798     c1 -= c3 * a25;
 799     c1 -= c2 * a17;
 800     c1 *= a9;
 801
 802     c0 -= c7 * a56;
 803     c0 -= c6 * a48;
 804     c0 -= c5 * a40;
 805     c0 -= c4 * a32;
 806     c0 -= c3 * a24;
 807     c0 -= c2 * a16;
 808     c0 -= c1 * a8;
 809     c0 *= a0;
 810
 811     *(b + 0) = c0;
 812     *(b + 1) = c1;
 813     *(b + 2) = c2;
 814     *(b + 3) = c3;
 815     *(b + 4) = c4;
 816     *(b + 5) = c5;
 817     *(b + 6) = c6;
 818     *(b + 7) = c7;
 819
 820     *(c + 0) = c0;
 821     *(c + 1) = c1;
 822     *(c + 2) = c2;
 823     *(c + 3) = c3;
 824     *(c + 4) = c4;
 825     *(c + 5) = c5;
 826     *(c + 6) = c6;
 827     *(c + 7) = c7;
 828 }
 829
 830 static void ssolve_4x8_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
 831 {
 832     BLASLONG k;
 833     FLOAT *aa = a, *bb = b;
 834     v4f32 src_b, src_b0, src_b1, src_b2, src_b3;
 835     v4f32 src_c0, src_c1, src_c2, src_c3, src_c4, src_c5, src_c6, src_c7;
 836     v4f32 res_c0, res_c1, res_c2, res_c3, res_c4, res_c5, res_c6, res_c7;
 837     v4f32 src_a, src_a0, src_a4, src_a5, src_a8, src_a9, src_a10, src_a12;
 838     v4f32 src_a13, src_a14, src_a15;
 839     FLOAT *c_nxt1line = c + ldc;
 840     FLOAT *c_nxt2line = c + 2 * ldc;
 841     FLOAT *c_nxt3line = c + 3 * ldc;
 842     FLOAT *c_nxt4line = c + 4 * ldc;
 843     FLOAT *c_nxt5line = c + 5 * ldc;
 844     FLOAT *c_nxt6line = c + 6 * ldc;
 845     FLOAT *c_nxt7line = c + 7 * ldc;
 846
 847     src_c0 = LD_SP(c);
 848     src_c1 = LD_SP(c_nxt1line);
 849     src_c2 = LD_SP(c_nxt2line);
 850     src_c3 = LD_SP(c_nxt3line);
 851     src_c4 = LD_SP(c_nxt4line);
 852     src_c5 = LD_SP(c_nxt5line);
 853     src_c6 = LD_SP(c_nxt6line);
 854     src_c7 = LD_SP(c_nxt7line);
 855
 856     for (k = 0; k < bk; k++)
 857     {
 858         src_a0 = LD_SP(aa);
 859
 860         src_b = LD_SP(bb);
 861         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 862         src_c0 -= src_a0 * src_b0;
 863         src_c1 -= src_a0 * src_b1;
 864         src_c2 -= src_a0 * src_b2;
 865         src_c3 -= src_a0 * src_b3;
 866
 867         src_b = LD_SP(bb + 4);
 868         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 869         src_c4 -= src_a0 * src_b0;
 870         src_c5 -= src_a0 * src_b1;
 871         src_c6 -= src_a0 * src_b2;
 872         src_c7 -= src_a0 * src_b3;
 873
 874         aa += 4;
 875         bb += 8;
 876     }
 877
 878     a -= 16;
 879     b -= 32;
 880
 881     TRANSPOSE4x4_SP_SP(src_c0, src_c1, src_c2, src_c3,
 882                        res_c0, res_c1, res_c2, res_c3);
 883     TRANSPOSE4x4_SP_SP(src_c4, src_c5, src_c6, src_c7,
 884                        res_c4, res_c5, res_c6, res_c7);
 885
 886     src_a = LD_SP(a + 12);
 887     SPLATI_W4_SP(src_a, src_a12, src_a13, src_a14, src_a15);
 888     src_a8 = LD_SP(a + 8);
 889     src_a10 = (v4f32) __msa_splati_w((v4i32) src_a8, 2);
 890     src_a9 = (v4f32) __msa_splati_w((v4i32) src_a8, 1);
 891     src_a8 = (v4f32) __msa_splati_w((v4i32) src_a8, 0);
 892
 893     src_a5 = COPY_FLOAT_TO_VECTOR(*(a + 5));
 894     src_a4 = COPY_FLOAT_TO_VECTOR(*(a + 4));
 895     src_a0 = COPY_FLOAT_TO_VECTOR(*(a + 0));
 896
 897     res_c3 *= src_a15;
 898     res_c7 *= src_a15;
 899     res_c2 -= res_c3 * src_a14;
 900     res_c6 -= res_c7 * src_a14;
 901     res_c1 -= res_c3 * src_a13;
 902     res_c5 -= res_c7 * src_a13;
 903     res_c0 -= res_c3 * src_a12;
 904     res_c4 -= res_c7 * src_a12;
 905
 906     res_c2 *= src_a10;
 907     res_c6 *= src_a10;
 908     res_c1 -= res_c2 * src_a9;
 909     res_c5 -= res_c6 * src_a9;
 910     res_c0 -= res_c2 * src_a8;
 911     res_c4 -= res_c6 * src_a8;
 912
 913     res_c1 *= src_a5;
 914     res_c5 *= src_a5;
 915     res_c0 -= res_c1 * src_a4;
 916     res_c4 -= res_c5 * src_a4;
 917
 918     res_c0 *= src_a0;
 919     res_c4 *= src_a0;
 920
 921     ST_SP4(res_c0, res_c4, res_c1, res_c5, b, 4);
 922     ST_SP4(res_c2, res_c6, res_c3, res_c7, b + 16, 4);
 923
 924     TRANSPOSE4x4_SP_SP(res_c0, res_c1, res_c2, res_c3,
 925                        src_c0, src_c1, src_c2, src_c3);
 926     TRANSPOSE4x4_SP_SP(res_c4, res_c5, res_c6, res_c7,
 927                        src_c4, src_c5, src_c6, src_c7);
 928
 929     ST_SP(src_c0, c);
 930     ST_SP(src_c1, c_nxt1line);
 931     ST_SP(src_c2, c_nxt2line);
 932     ST_SP(src_c3, c_nxt3line);
 933     ST_SP(src_c4, c_nxt4line);
 934     ST_SP(src_c5, c_nxt5line);
 935     ST_SP(src_c6, c_nxt6line);
 936     ST_SP(src_c7, c_nxt7line);
 937 }
 938
 939 static void ssolve_4x4_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
 940 {
 941     BLASLONG k;
 942     FLOAT *aa = a, *bb = b;
 943     v4f32 src_b, src_b0, src_b1, src_b2, src_b3;
 944     v4f32 src_c0, src_c1, src_c2, src_c3, res_c0, res_c1, res_c2, res_c3;
 945     v4f32 src_a, src_a0, src_a4, src_a5, src_a8, src_a9, src_a10, src_a12;
 946     v4f32 src_a13, src_a14, src_a15;
 947     FLOAT *c_nxt1line = c + ldc;
 948     FLOAT *c_nxt2line = c + 2 * ldc;
 949     FLOAT *c_nxt3line = c + 3 * ldc;
 950
 951     src_c0 = LD_SP(c);
 952     src_c1 = LD_SP(c_nxt1line);
 953     src_c2 = LD_SP(c_nxt2line);
 954     src_c3 = LD_SP(c_nxt3line);
 955
 956     for (k = 0; k < (bk >> 1); k++)
 957     {
 958         src_a0 = LD_SP(aa);
 959
 960         src_b = LD_SP(bb);
 961         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 962         src_c0 -= src_a0 * src_b0;
 963         src_c1 -= src_a0 * src_b1;
 964         src_c2 -= src_a0 * src_b2;
 965         src_c3 -= src_a0 * src_b3;
 966
 967         aa += 4;
 968         bb += 4;
 969
 970         src_a0 = LD_SP(aa);
 971
 972         src_b = LD_SP(bb);
 973         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 974         src_c0 -= src_a0 * src_b0;
 975         src_c1 -= src_a0 * src_b1;
 976         src_c2 -= src_a0 * src_b2;
 977         src_c3 -= src_a0 * src_b3;
 978
 979         aa += 4;
 980         bb += 4;
 981     }
 982
 983     if ((bk & 1) && (bk > 0))
 984     {
 985         src_a0 = LD_SP(aa);
 986
 987         src_b = LD_SP(bb);
 988         SPLATI_W4_SP(src_b, src_b0, src_b1, src_b2, src_b3);
 989         src_c0 -= src_a0 * src_b0;
 990         src_c1 -= src_a0 * src_b1;
 991         src_c2 -= src_a0 * src_b2;
 992         src_c3 -= src_a0 * src_b3;
 993     }
 994
 995     a -= 16;
 996     b -= 16;
 997
 998     TRANSPOSE4x4_SP_SP(src_c0, src_c1, src_c2, src_c3,
 999                        res_c0, res_c1, res_c2, res_c3);
1000
1001     src_a = LD_SP(a + 12);
1002     SPLATI_W4_SP(src_a, src_a12, src_a13, src_a14, src_a15);
1003     src_a8 = LD_SP(a + 8);
1004     src_a10 = (v4f32) __msa_splati_w((v4i32) src_a8, 2);
1005     src_a9 = (v4f32) __msa_splati_w((v4i32) src_a8, 1);
1006     src_a8 = (v4f32) __msa_splati_w((v4i32) src_a8, 0);
1007     src_a5 = COPY_FLOAT_TO_VECTOR(*(a + 5));
1008     src_a4 = COPY_FLOAT_TO_VECTOR(*(a + 4));
1009     src_a0 = COPY_FLOAT_TO_VECTOR(*(a + 0));
1010
1011     res_c3 *= src_a15;
1012     res_c2 -= res_c3 * src_a14;
1013     res_c1 -= res_c3 * src_a13;
1014     res_c0 -= res_c3 * src_a12;
1015
1016     res_c2 *= src_a10;
1017     res_c1 -= res_c2 * src_a9;
1018     res_c0 -= res_c2 * src_a8;
1019
1020     res_c1 *= src_a5;
1021     res_c0 -= res_c1 * src_a4;
1022
1023     res_c0 *= src_a0;
1024
1025     ST_SP4(res_c0, res_c1, res_c2, res_c3, b, 4);
1026
1027     TRANSPOSE4x4_SP_SP(res_c0, res_c1, res_c2, res_c3,
1028                        src_c0, src_c1, src_c2, src_c3);
1029
1030     ST_SP(src_c0, c);
1031     ST_SP(src_c1, c_nxt1line);
1032     ST_SP(src_c2, c_nxt2line);
1033     ST_SP(src_c3, c_nxt3line);
1034 }
1035
1036 static void ssolve_4x2_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1037 {
1038     BLASLONG k;
1039     FLOAT *aa = a, *bb = b;
1040     FLOAT a0, a4, a5, a8, a9, a10, a12, a13, a14, a15;
1041     FLOAT c0, c1, c2, c3, c0_nxt, c1_nxt, c2_nxt, c3_nxt;
1042
1043     c0 = *(c + 0);
1044     c1 = *(c + 1);
1045     c2 = *(c + 2);
1046     c3 = *(c + 3);
1047     c0_nxt = *(c + 0 + ldc);
1048     c1_nxt = *(c + 1 + ldc);
1049     c2_nxt = *(c + 2 + ldc);
1050     c3_nxt = *(c + 3 + ldc);
1051
1052     for (k = 0; k < bk; k++)
1053     {
1054         c0 -= aa[0] * bb[0];
1055         c1 -= aa[1] * bb[0];
1056         c2 -= aa[2] * bb[0];
1057         c3 -= aa[3] * bb[0];
1058         c0_nxt -= aa[0] * bb[1];
1059         c1_nxt -= aa[1] * bb[1];
1060         c2_nxt -= aa[2] * bb[1];
1061         c3_nxt -= aa[3] * bb[1];
1062
1063         aa += 4;
1064         bb += 2;
1065     }
1066
1067     a -= 16;
1068     b -= 8;
1069
1070     a0 = *(a + 0);
1071     a4 = *(a + 4);
1072     a5 = *(a + 5);
1073     a8 = *(a + 8);
1074     a9 = *(a + 9);
1075     a10 = *(a + 10);
1076     a12 = *(a + 12);
1077     a13 = *(a + 13);
1078     a14 = *(a + 14);
1079     a15 = *(a + 15);
1080
1081     c3 *= a15;
1082     c3_nxt *= a15;
1083
1084     c2 -= c3 * a14;
1085     c2_nxt -= c3_nxt * a14;
1086
1087     c2 *= a10;
1088     c2_nxt *= a10;
1089
1090     c1 -= c3 * a13;
1091     c1_nxt -= c3_nxt * a13;
1092
1093     c1 -= c2 * a9;
1094     c1_nxt -= c2_nxt * a9;
1095
1096     c1 *= a5;
1097     c1_nxt *= a5;
1098
1099     c0 -= c3 * a12;
1100     c0_nxt -= c3_nxt * a12;
1101
1102     c0 -= c2 * a8;
1103     c0_nxt -= c2_nxt * a8;
1104
1105     c0 -= c1 * a4;
1106     c0_nxt -= c1_nxt * a4;
1107
1108     c0 *= a0;
1109     c0_nxt *= a0;
1110
1111     *(b + 0) = c0;
1112     *(b + 1) = c0_nxt;
1113     *(b + 2) = c1;
1114     *(b + 3) = c1_nxt;
1115     *(b + 4) = c2;
1116     *(b + 5) = c2_nxt;
1117     *(b + 6) = c3;
1118     *(b + 7) = c3_nxt;
1119
1120     *(c + 0) = c0;
1121     *(c + 1) = c1;
1122     *(c + 2) = c2;
1123     *(c + 3) = c3;
1124     *(c + 0 + ldc) = c0_nxt;
1125     *(c + 1 + ldc) = c1_nxt;
1126     *(c + 2 + ldc) = c2_nxt;
1127     *(c + 3 + ldc) = c3_nxt;
1128 }
1129
1130 static void ssolve_4x1_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG bk)
1131 {
1132     BLASLONG k;
1133     FLOAT *aa = a, *bb = b;
1134     FLOAT a0, a4, a5, a8, a9, a10, a12, a13, a14, a15, c0, c1, c2, c3;
1135
1136     c0 = *(c + 0);
1137     c1 = *(c + 1);
1138     c2 = *(c + 2);
1139     c3 = *(c + 3);
1140
1141     for (k = 0; k < bk; k++)
1142     {
1143         c0 -= aa[0] * bb[0];
1144         c1 -= aa[1] * bb[0];
1145         c2 -= aa[2] * bb[0];
1146         c3 -= aa[3] * bb[0];
1147
1148         aa += 4;
1149         bb += 1;
1150     }
1151
1152     a -= 16;
1153     b -= 4;
1154
1155     a0 = *(a + 0);
1156     a4 = *(a + 4);
1157     a5 = *(a + 5);
1158     a8 = *(a + 8);
1159     a9 = *(a + 9);
1160     a10 = *(a + 10);
1161     a12 = *(a + 12);
1162     a13 = *(a + 13);
1163     a14 = *(a + 14);
1164     a15 = *(a + 15);
1165
1166     c3 *= a15;
1167
1168     c2 -= c3 * a14;
1169     c2 *= a10;
1170
1171     c1 -= c3 * a13;
1172     c1 -= c2 * a9;
1173     c1 *= a5;
1174
1175     c0 -= c3 * a12;
1176     c0 -= c2 * a8;
1177     c0 -= c1 * a4;
1178     c0 *= a0;
1179
1180     *(b + 0) = c0;
1181     *(b + 1) = c1;
1182     *(b + 2) = c2;
1183     *(b + 3) = c3;
1184
1185     *(c + 0) = c0;
1186     *(c + 1) = c1;
1187     *(c + 2) = c2;
1188     *(c + 3) = c3;
1189 }
1190
1191 static void ssolve_2x8_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1192 {
1193     BLASLONG k;
1194     FLOAT *aa = a, *bb = b;
1195     FLOAT a0, a2, a3, c0, c1, c0_nxt1, c1_nxt1, c0_nxt2, c1_nxt2, c0_nxt3;
1196     FLOAT c1_nxt3, c0_nxt4, c1_nxt4, c0_nxt5, c1_nxt5, c0_nxt6, c1_nxt6;
1197     FLOAT c0_nxt7, c1_nxt7;
1198
1199     c0 = *(c + 0);
1200     c1 = *(c + 1);
1201     c0_nxt1 = *(c + 0 + 1 * ldc);
1202     c1_nxt1 = *(c + 1 + 1 * ldc);
1203     c0_nxt2 = *(c + 0 + 2 * ldc);
1204     c1_nxt2 = *(c + 1 + 2 * ldc);
1205     c0_nxt3 = *(c + 0 + 3 * ldc);
1206     c1_nxt3 = *(c + 1 + 3 * ldc);
1207     c0_nxt4 = *(c + 0 + 4 * ldc);
1208     c1_nxt4 = *(c + 1 + 4 * ldc);
1209     c0_nxt5 = *(c + 0 + 5 * ldc);
1210     c1_nxt5 = *(c + 1 + 5 * ldc);
1211     c0_nxt6 = *(c + 0 + 6 * ldc);
1212     c1_nxt6 = *(c + 1 + 6 * ldc);
1213     c0_nxt7 = *(c + 0 + 7 * ldc);
1214     c1_nxt7 = *(c + 1 + 7 * ldc);
1215
1216     for (k = 0; k < bk; k++)
1217     {
1218         c0 -= aa[0] * bb[0];
1219         c1 -= aa[1] * bb[0];
1220         c0_nxt1 -= aa[0] * bb[1];
1221         c1_nxt1 -= aa[1] * bb[1];
1222         c0_nxt2 -= aa[0] * bb[2];
1223         c1_nxt2 -= aa[1] * bb[2];
1224         c0_nxt3 -= aa[0] * bb[3];
1225         c1_nxt3 -= aa[1] * bb[3];
1226         c0_nxt4 -= aa[0] * bb[4];
1227         c1_nxt4 -= aa[1] * bb[4];
1228         c0_nxt5 -= aa[0] * bb[5];
1229         c1_nxt5 -= aa[1] * bb[5];
1230         c0_nxt6 -= aa[0] * bb[6];
1231         c1_nxt6 -= aa[1] * bb[6];
1232         c0_nxt7 -= aa[0] * bb[7];
1233         c1_nxt7 -= aa[1] * bb[7];
1234
1235         aa += 2;
1236         bb += 8;
1237     }
1238
1239     a -= 4;
1240     b -= 16;
1241
1242     a0 = *(a + 0);
1243     a2 = *(a + 2);
1244     a3 = *(a + 3);
1245
1246     c1 *= a3;
1247     c1_nxt1 *= a3;
1248     c1_nxt2 *= a3;
1249     c1_nxt3 *= a3;
1250     c1_nxt4 *= a3;
1251     c1_nxt5 *= a3;
1252     c1_nxt6 *= a3;
1253     c1_nxt7 *= a3;
1254
1255     c0 -= c1 * a2;
1256     c0_nxt1 -= c1_nxt1 * a2;
1257     c0_nxt2 -= c1_nxt2 * a2;
1258     c0_nxt3 -= c1_nxt3 * a2;
1259     c0_nxt4 -= c1_nxt4 * a2;
1260     c0_nxt5 -= c1_nxt5 * a2;
1261     c0_nxt6 -= c1_nxt6 * a2;
1262     c0_nxt7 -= c1_nxt7 * a2;
1263
1264     c0 *= a0;
1265     c0_nxt1 *= a0;
1266     c0_nxt2 *= a0;
1267     c0_nxt3 *= a0;
1268     c0_nxt4 *= a0;
1269     c0_nxt5 *= a0;
1270     c0_nxt6 *= a0;
1271     c0_nxt7 *= a0;
1272
1273     *(b + 0) = c0;
1274     *(b + 1) = c0_nxt1;
1275     *(b + 2) = c0_nxt2;
1276     *(b + 3) = c0_nxt3;
1277     *(b + 4) = c0_nxt4;
1278     *(b + 5) = c0_nxt5;
1279     *(b + 6) = c0_nxt6;
1280     *(b + 7) = c0_nxt7;
1281     *(b + 8) = c1;
1282     *(b + 9)  = c1_nxt1;
1283     *(b + 10) = c1_nxt2;
1284     *(b + 11) = c1_nxt3;
1285     *(b + 12) = c1_nxt4;
1286     *(b + 13) = c1_nxt5;
1287     *(b + 14) = c1_nxt6;
1288     *(b + 15) = c1_nxt7;
1289
1290     *(c + 0) = c0;
1291     *(c + 1) = c1;
1292     *(c + 0 + 1 * ldc) = c0_nxt1;
1293     *(c + 1 + 1 * ldc) = c1_nxt1;
1294     *(c + 0 + 2 * ldc) = c0_nxt2;
1295     *(c + 1 + 2 * ldc) = c1_nxt2;
1296     *(c + 0 + 3 * ldc) = c0_nxt3;
1297     *(c + 1 + 3 * ldc) = c1_nxt3;
1298     *(c + 0 + 4 * ldc) = c0_nxt4;
1299     *(c + 1 + 4 * ldc) = c1_nxt4;
1300     *(c + 0 + 5 * ldc) = c0_nxt5;
1301     *(c + 1 + 5 * ldc) = c1_nxt5;
1302     *(c + 0 + 6 * ldc) = c0_nxt6;
1303     *(c + 1 + 6 * ldc) = c1_nxt6;
1304     *(c + 0 + 7 * ldc) = c0_nxt7;
1305     *(c + 1 + 7 * ldc) = c1_nxt7;
1306 }
1307
1308 static void ssolve_2x4_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1309 {
1310     BLASLONG k;
1311     FLOAT *aa = a, *bb = b;
1312     FLOAT a0, a2, a3, c0, c1, c0_nxt1, c1_nxt1;
1313     FLOAT c0_nxt2, c1_nxt2, c0_nxt3, c1_nxt3;
1314
1315     c0 = *(c + 0);
1316     c1 = *(c + 1);
1317     c0_nxt1 = *(c + 0 + ldc);
1318     c1_nxt1 = *(c + 1 + ldc);
1319     c0_nxt2 = *(c + 0 + 2 * ldc);
1320     c1_nxt2 = *(c + 1 + 2 * ldc);
1321     c0_nxt3 = *(c + 0 + 3 * ldc);
1322     c1_nxt3 = *(c + 1 + 3 * ldc);
1323
1324     for (k = 0; k < bk; k++)
1325     {
1326         c0 -= aa[0] * bb[0];
1327         c1 -= aa[1] * bb[0];
1328         c0_nxt1 -= aa[0] * bb[1];
1329         c1_nxt1 -= aa[1] * bb[1];
1330         c0_nxt2 -= aa[0] * bb[2];
1331         c1_nxt2 -= aa[1] * bb[2];
1332         c0_nxt3 -= aa[0] * bb[3];
1333         c1_nxt3 -= aa[1] * bb[3];
1334
1335         aa += 2;
1336         bb += 4;
1337     }
1338
1339     a -= 4;
1340     b -= 8;
1341
1342     a0 = *(a + 0);
1343     a2 = *(a + 2);
1344     a3 = *(a + 3);
1345
1346     c1 *= a3;
1347     c1_nxt1 *= a3;
1348     c1_nxt2 *= a3;
1349     c1_nxt3 *= a3;
1350
1351     c0 -= c1 * a2;
1352     c0_nxt1 -= c1_nxt1 * a2;
1353     c0_nxt2 -= c1_nxt2 * a2;
1354     c0_nxt3 -= c1_nxt3 * a2;
1355
1356     c0 *= a0;
1357     c0_nxt1 *= a0;
1358     c0_nxt2 *= a0;
1359     c0_nxt3 *= a0;
1360
1361     *(b + 0) = c0;
1362     *(b + 1) = c0_nxt1;
1363     *(b + 2) = c0_nxt2;
1364     *(b + 3) = c0_nxt3;
1365     *(b + 4) = c1;
1366     *(b + 5) = c1_nxt1;
1367     *(b + 6) = c1_nxt2;
1368     *(b + 7) = c1_nxt3;
1369
1370     *(c + 0) = c0;
1371     *(c + 1) = c1;
1372     *(c + 0 + ldc) = c0_nxt1;
1373     *(c + 1 + ldc) = c1_nxt1;
1374     *(c + 0 + 2 * ldc) = c0_nxt2;
1375     *(c + 1 + 2 * ldc) = c1_nxt2;
1376     *(c + 0 + 3 * ldc) = c0_nxt3;
1377     *(c + 1 + 3 * ldc) = c1_nxt3;
1378 }
1379
1380 static void ssolve_2x2_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1381 {
1382     BLASLONG k;
1383     FLOAT *aa = a, *bb = b;
1384     FLOAT a0, a2, a3, c0, c1, c0_nxt, c1_nxt;
1385
1386     c0 = *(c + 0);
1387     c1 = *(c + 1);
1388     c0_nxt = *(c + 0 + ldc);
1389     c1_nxt = *(c + 1 + ldc);
1390
1391     for (k = 0; k < bk; k++)
1392     {
1393         c0 -= aa[0] * bb[0];
1394         c1 -= aa[1] * bb[0];
1395         c0_nxt -= aa[0] * bb[1];
1396         c1_nxt -= aa[1] * bb[1];
1397
1398         aa += 2;
1399         bb += 2;
1400     }
1401
1402     a -= 4;
1403     b -= 4;
1404
1405     a0 = *(a + 0);
1406     a2 = *(a + 2);
1407     a3 = *(a + 3);
1408
1409     c1 *= a3;
1410     c1_nxt *= a3;
1411
1412     c0 -= c1 * a2;
1413     c0_nxt -= c1_nxt * a2;
1414
1415     c0 *= a0;
1416     c0_nxt *= a0;
1417
1418     *(b + 0) = c0;
1419     *(b + 1) = c0_nxt;
1420     *(b + 2) = c1;
1421     *(b + 3) = c1_nxt;
1422
1423     *(c + 0) = c0;
1424     *(c + 1) = c1;
1425     *(c + 0 + ldc) = c0_nxt;
1426     *(c + 1 + ldc) = c1_nxt;
1427 }
1428
1429 static void ssolve_2x1_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG bk)
1430 {
1431     BLASLONG k;
1432     FLOAT *aa = a, *bb = b;
1433     FLOAT a0, a2, a3, c0, c1;
1434
1435     c0 = *(c + 0);
1436     c1 = *(c + 1);
1437
1438     for (k = 0; k < bk; k++)
1439     {
1440         c0 -= aa[0] * bb[0];
1441         c1 -= aa[1] * bb[0];
1442
1443         aa += 2;
1444         bb += 1;
1445     }
1446
1447     a -= 4;
1448     b -= 2;
1449
1450     a0 = *(a + 0);
1451     a2 = *(a + 2);
1452     a3 = *(a + 3);
1453
1454     c1 *= a3;
1455
1456     c0 -= c1 * a2;
1457     c0 *= a0;
1458
1459     *(b + 0) = c0;
1460     *(b + 1) = c1;
1461
1462     *(c + 0) = c0;
1463     *(c + 1) = c1;
1464 }
1465
1466 static void ssolve_1x8_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1467 {
1468     BLASLONG k;
1469     FLOAT *aa = a, *bb = b;
1470     FLOAT a0, c0, c1, c2, c3, c4, c5, c6, c7;
1471
1472     c0 = *(c + 0);
1473     c1 = *(c + 1 * ldc);
1474     c2 = *(c + 2 * ldc);
1475     c3 = *(c + 3 * ldc);
1476     c4 = *(c + 4 * ldc);
1477     c5 = *(c + 5 * ldc);
1478     c6 = *(c + 6 * ldc);
1479     c7 = *(c + 7 * ldc);
1480
1481     for (k = 0; k < bk; k++)
1482     {
1483         c0 -= aa[0] * bb[0];
1484         c1 -= aa[0] * bb[1];
1485         c2 -= aa[0] * bb[2];
1486         c3 -= aa[0] * bb[3];
1487         c4 -= aa[0] * bb[4];
1488         c5 -= aa[0] * bb[5];
1489         c6 -= aa[0] * bb[6];
1490         c7 -= aa[0] * bb[7];
1491
1492         aa += 1;
1493         bb += 8;
1494     }
1495
1496     a0 = *(a - 1);
1497
1498     c0 *= a0;
1499     c1 *= a0;
1500     c2 *= a0;
1501     c3 *= a0;
1502     c4 *= a0;
1503     c5 *= a0;
1504     c6 *= a0;
1505     c7 *= a0;
1506
1507     *(b - 8) = c0;
1508     *(b - 7) = c1;
1509     *(b - 6) = c2;
1510     *(b - 5) = c3;
1511     *(b - 4) = c4;
1512     *(b - 3) = c5;
1513     *(b - 2) = c6;
1514     *(b - 1) = c7;
1515
1516     *(c + 0 * ldc) = c0;
1517     *(c + 1 * ldc) = c1;
1518     *(c + 2 * ldc) = c2;
1519     *(c + 3 * ldc) = c3;
1520     *(c + 4 * ldc) = c4;
1521     *(c + 5 * ldc) = c5;
1522     *(c + 6 * ldc) = c6;
1523     *(c + 7 * ldc) = c7;
1524 }
1525
1526 static void ssolve_1x4_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1527 {
1528     BLASLONG k;
1529     FLOAT *aa = a, *bb = b;
1530     FLOAT a0, c0, c1, c2, c3;
1531
1532     c0 = *(c + 0 * ldc);
1533     c1 = *(c + 1 * ldc);
1534     c2 = *(c + 2 * ldc);
1535     c3 = *(c + 3 * ldc);
1536
1537     for (k = 0; k < bk; k++)
1538     {
1539         c0 -= aa[0] * bb[0];
1540         c1 -= aa[0] * bb[1];
1541         c2 -= aa[0] * bb[2];
1542         c3 -= aa[0] * bb[3];
1543
1544         aa += 1;
1545         bb += 4;
1546     }
1547
1548     a0 = *(a - 1);
1549
1550     c0 *= a0;
1551     c1 *= a0;
1552     c2 *= a0;
1553     c3 *= a0;
1554
1555     *(b - 4) = c0;
1556     *(b - 3) = c1;
1557     *(b - 2) = c2;
1558     *(b - 1) = c3;
1559
1560     *(c + 0 * ldc) = c0;
1561     *(c + 1 * ldc) = c1;
1562     *(c + 2 * ldc) = c2;
1563     *(c + 3 * ldc) = c3;
1564 }
1565
1566 static void ssolve_1x2_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG ldc, BLASLONG bk)
1567 {
1568     BLASLONG k;
1569     FLOAT *aa = a, *bb = b;
1570     FLOAT a0, c0, c1;
1571
1572     c0 = *c;
1573     c1 = *(c + ldc);
1574
1575     for (k = 0; k < bk; k++)
1576     {
1577         c0 -= aa[0] * bb[0];
1578         c1 -= aa[0] * bb[1];
1579
1580         aa += 1;
1581         bb += 2;
1582     }
1583
1584     a0 = *(a - 1);
1585
1586     c0 *= a0;
1587     c1 *= a0;
1588
1589     *(b - 2) = c0;
1590     *(b - 1) = c1;
1591
1592     *(c + 0 * ldc) = c0;
1593     *(c + 1 * ldc) = c1;
1594 }
1595
1596 static void ssolve_1x1_ln_msa(FLOAT *a, FLOAT *b, FLOAT *c, BLASLONG bk)
1597 {
1598     BLASLONG k;
1599
1600     for (k = 0; k < bk; k++)
1601     {
1602         *c -= a[k] * b[k];
1603     }
1604
1605     *c *= *(a - 1);
1606     *(b - 1) = *c;
1607 }
1608
1609 int CNAME(BLASLONG m, BLASLONG n, BLASLONG k, FLOAT dummy1, FLOAT *a, FLOAT *b,
1610           FLOAT *c, BLASLONG ldc, BLASLONG offset)
1611 {
1612     FLOAT *aa, *cc;
1613     BLASLONG i, j, kk;
1614
1615     for (j = (n >> 3); j--;)
1616     {
1617         kk = m + offset;
1618         if (m & 7)
1619         {
1620             if (m & 1)
1621             {
1622                 aa = a + (m - 1) * k + kk;
1623                 cc = c + (m - 1);
1624
1625                 ssolve_1x8_ln_msa(aa, b + 8 * kk, cc, ldc, (k - kk));
1626
1627                 kk -= 1;
1628             }
1629
1630             if (m & 2)
1631             {
1632                 aa = a + ((m & ~1) - 2) * k + 2 * kk;
1633                 cc = c + ((m & ~1) - 2);
1634
1635                 ssolve_2x8_ln_msa(aa, b + 8 * kk, cc, ldc, (k - kk));
1636
1637                 kk -= 2;
1638             }
1639
1640             if (m & 4)
1641             {
1642                 aa = a + ((m & ~3) - 4) * k + 4 * kk;
1643                 cc = c + ((m & ~3) - 4);
1644
1645                 ssolve_4x8_ln_msa(aa, b + 8 * kk, cc, ldc, (k - kk));
1646
1647                 kk -= 4;
1648             }
1649         }
1650
1651         i = (m >> 3);
1652         if (i > 0)
1653         {
1654             aa = a + ((m & ~7) - 8) * k;
1655             cc = c + ((m & ~7) - 8);
1656
1657             do
1658             {
1659                 ssolve_8x8_ln_msa(aa + 8 * kk, b + 8 * kk, cc, ldc, (k - kk));
1660
1661                 aa -= 8 * k;
1662                 cc -= 8;
1663                 kk -= 8;
1664                 i --;
1665             } while (i > 0);
1666         }
1667
1668         b += 8 * k;
1669         c += 8 * ldc;
1670     }
1671
1672     if (n & 7)
1673     {
1674         if (n & 4)
1675         {
1676             kk = m + offset;
1677
1678             if (m & 7)
1679             {
1680                 if (m & 1)
1681                 {
1682                     aa = a + (m - 1) * k + kk;
1683                     cc = c + (m - 1);
1684
1685                     ssolve_1x4_ln_msa(aa, b + 4 * kk, cc, ldc, (k - kk));
1686
1687                     kk -= 1;
1688                 }
1689
1690                 if (m & 2)
1691                 {
1692                     aa = a + ((m & ~1) - 2) * k + 2 * kk;
1693                     cc = c + ((m & ~1) - 2);
1694
1695                     ssolve_2x4_ln_msa(aa, b + 4 * kk, cc, ldc, (k - kk));
1696
1697                     kk -= 2;
1698                 }
1699
1700                 if (m & 4)
1701                 {
1702                     aa = a + ((m & ~3) - 4) * k + 4 * kk;
1703                     cc = c + ((m & ~3) - 4);
1704
1705                     ssolve_4x4_ln_msa(aa, b + 4 * kk, cc, ldc, (k - kk));
1706
1707                     kk -= 4;
1708                 }
1709             }
1710
1711             i = (m >> 3);
1712             if (i > 0)
1713             {
1714                 aa = a + ((m & ~7) - 8) * k;
1715                 cc = c + ((m & ~7) - 8);
1716
1717                 do
1718                 {
1719                     ssolve_8x4_ln_msa(aa + 8 * kk, b + 4 * kk, cc, ldc, (k - kk));
1720
1721                     aa -= 8 * k;
1722                     cc -= 8;
1723                     kk -= 8;
1724                     i --;
1725                 } while (i > 0);
1726             }
1727
1728             b += 4 * k;
1729             c += 4 * ldc;
1730         }
1731
1732         if (n & 2)
1733         {
1734             kk = m + offset;
1735
1736             if (m & 7)
1737             {
1738                 if (m & 1)
1739                 {
1740                     aa = a + (m - 1) * k + kk;
1741                     cc = c + (m - 1);
1742
1743                     ssolve_1x2_ln_msa(aa, b + 2 * kk, cc, ldc, (k - kk));
1744
1745                     kk -= 1;
1746                 }
1747
1748                 if (m & 2)
1749                 {
1750                     aa = a + ((m & ~1) - 2) * k + 2 * kk;
1751                     cc = c + ((m & ~1) - 2);
1752
1753                     ssolve_2x2_ln_msa(aa, b + 2 * kk, cc, ldc, (k - kk));
1754
1755                     kk -= 2;
1756                 }
1757
1758                 if (m & 4)
1759                 {
1760                     aa = a + ((m & ~3) - 4) * k + 4 * kk;
1761                     cc = c + ((m & ~3) - 4);
1762
1763                     ssolve_4x2_ln_msa(aa, b + 2 * kk, cc, ldc, (k - kk));
1764
1765                     kk -= 4;
1766                 }
1767             }
1768
1769             i = (m >> 3);
1770             if (i > 0)
1771             {
1772                 aa = a + ((m & ~7) - 8) * k;
1773                 cc = c + ((m & ~7) - 8);
1774
1775                 do
1776                 {
1777                     ssolve_8x2_ln_msa(aa + 8 * kk, b + 2 * kk, cc, ldc, (k - kk));
1778
1779                     aa -= 8 * k;
1780                     cc -= 8;
1781                     kk -= 8;
1782                     i --;
1783                 } while (i > 0);
1784             }
1785
1786             b += 2 * k;
1787             c += 2 * ldc;
1788         }
1789
1790         if (n & 1)
1791         {
1792             kk = m + offset;
1793
1794             if (m & 7)
1795             {
1796                 if (m & 1)
1797                 {
1798                     aa = a + (m - 1) * k + kk;
1799                     cc = c + (m - 1);
1800
1801                     ssolve_1x1_ln_msa(aa, b + kk, cc, (k - kk));
1802
1803                     kk -= 1;
1804                 }
1805
1806                 if (m & 2)
1807                 {
1808                     aa = a + ((m & ~1) - 2) * k + 2 * kk;
1809                     cc = c + ((m & ~1) - 2);
1810
1811                     ssolve_2x1_ln_msa(aa, b + kk, cc, (k - kk));
1812
1813                     kk -= 2;
1814                 }
1815
1816                 if (m & 4)
1817                 {
1818                     aa = a + ((m & ~3) - 4) * k + 4 * kk;
1819                     cc = c + ((m & ~3) - 4);
1820
1821                     ssolve_4x1_ln_msa(aa, b + kk, cc, (k - kk));
1822
1823                     kk -= 4;
1824                 }
1825             }
1826
1827             i = (m >> 3);
1828             if (i > 0)
1829             {
1830                 aa = a + ((m & ~7) - 8) * k;
1831                 cc = c + ((m & ~7) - 8);
1832
1833                 do
1834                 {
1835                     ssolve_8x1_ln_msa(aa + 8 * kk, b + kk, cc, (k - kk));
1836
1837                     aa -= 8 * k;
1838                     cc -= 8;
1839                     kk -= 8;
1840                     i --;
1841                 } while (i > 0);
1842             }
1843
1844             b += k;
1845             c += ldc;
1846         }
1847     }
1848
1849     return 0;
1850 }