~ubuntu-branches/ubuntu/vivid/atlas/vivid

« back to all changes in this revision

Viewing changes to tune/blas/gemm/CASES/ATL_smm2x4x256_fma4.c

  • Committer: Package Import Robot
  • Author(s): Sébastien Villemot
  • Date: 2013-06-11 15:58:16 UTC
  • mfrom: (1.1.3 upstream)
  • mto: (2.2.21 experimental)
  • mto: This revision was merged to the branch mainline in revision 26.
  • Revision ID: package-import@ubuntu.com-20130611155816-b72z8f621tuhbzn0
Tags: upstream-3.10.1
Import upstream version 3.10.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
#include "atlas_asm.h"
 
2
#ifndef ATL_AVXFMA4
 
3
   #error "This kernel requires AMD's 4-operand FMAC (FM4)"
 
4
#endif
 
5
#ifdef SCPLX
 
6
   #define CMUL(arg_) 2*arg_
 
7
#else
 
8
   #define CMUL(arg_) arg_
 
9
#endif
 
10
/*
 
11
 *Integer register usage shown by these defines
 
12
 */
 
13
#define pA0     %rcx
 
14
#define lda     %rbx
 
15
#define ldb3    %rbp
 
16
#define pfA     %rdi
 
17
#define pB0     %rax
 
18
#define ldb     %rsi
 
19
#define pfB     %rdx
 
20
#define incAn   %r8
 
21
#define incCn   %r9
 
22
#define pC0     %r10
 
23
#define MM      %r11
 
24
#define NN      %r12
 
25
#define MM0     %r13
 
26
#define ldc     %r14
 
27
#define ldc3    %r15
 
28
 
 
29
#define rA0     %xmm0
 
30
#define rA1     %xmm1
 
31
#define ra0     %xmm2
 
32
#define ra1     %xmm3
 
33
#define rB0     %xmm4
 
34
#define rB1     %xmm5
 
35
#define rB2     %xmm6
 
36
#define rB3     %xmm7
 
37
#define rC00    %xmm8
 
38
#define rC10    %xmm9
 
39
#define rC01    %xmm10
 
40
#define rC11    %xmm11
 
41
#define rC02    %xmm12
 
42
#define rC12    %xmm13
 
43
#define rC03    %xmm14
 
44
#define rC13    %xmm15
 
45
 
 
46
/*
 
47
 * Save some inst space by using short version of instructions
 
48
 */
 
49
#define movapd movaps
 
50
#define movupd movups
 
51
#define movlpd movlps
 
52
#define movhpd movhps
 
53
 
 
54
/*
 
55
                      %rdi/4       %rsi/8       %rdx/12          %xmm0/16
 
56
 void ATL_USERMM(const int M, const int N, const int K, const TYPE alpha,
 
57
                       %rcx/24         %r8/28         %r9/32           8/36
 
58
                 const TYPE *A, const int lda, const TYPE *B, const int ldb,
 
59
                        %xmm1/40    16/48          24/52
 
60
                 const TYPE beta, TYPE *C, const int ldc)
 
61
*/
 
62
#define MOVCPD movupd
 
63
        .text
 
64
.global ATL_asmdecor(ATL_USERMM)
 
65
ALIGN16
 
66
ATL_asmdecor(ATL_USERMM):
 
67
/*
 
68
 *      Save callee-saved iregs
 
69
 */
 
70
        movq    %rbp, -8(%rsp)
 
71
        movq    %rbx, -16(%rsp)
 
72
        movq    %r12, -24(%rsp)
 
73
        movq    %r13, -32(%rsp)
 
74
        movq    %r14, -40(%rsp)
 
75
                                        prefetcht0 (pA0)
 
76
        movq    %r15, -48(%rsp)
 
77
 
 
78
/*
 
79
 *      Setup input parameters
 
80
 */
 
81
   #ifdef BETAX
 
82
      #define BETAOFF -72
 
83
        movlhps %xmm1, %xmm1
 
84
        unpcklps %xmm1, %xmm1
 
85
        movaps  %xmm1, BETAOFF(%rsp)
 
86
   #endif
 
87
        movq    %rdi, MM0
 
88
        movq    %rsi, NN
 
89
        movq    %r8, lda
 
90
                                        prefetcht0      (pA0,lda)
 
91
        movq    %r9, pB0
 
92
                                        prefetcht0      (pB0)
 
93
        movslq  8(%rsp), ldb
 
94
                                        prefetcht0      (pB0,ldb)
 
95
        movq    16(%rsp), pC0
 
96
        movslq  24(%rsp), incCn
 
97
        movq    incCn, ldc
 
98
                                        prefetcht0      (pB0,lda,2)
 
99
/*
 
100
 *      incCn = (4*ldc-M)*sizeof
 
101
 */
 
102
        shl     $2, incCn
 
103
        sub     MM0, incCn
 
104
#ifdef SCPLX
 
105
        shl     $3, incCn
 
106
        shl     $3, ldc
 
107
#else
 
108
        shl     $2, incCn
 
109
        shl     $2, ldc
 
110
#endif
 
111
/*
 
112
 *      pA0 += 128; pB0 += 128
 
113
 */
 
114
        sub     $-128, pA0
 
115
        sub     $-128, pB0
 
116
                                        prefetcht0      -64(pB0)
 
117
/*
 
118
 *      ldb = ldb*sizeof;  ldb3 = ldb*3;   ldc3 = ldc*3
 
119
 */
 
120
        shl     $2, ldb
 
121
                                                prefetcht0      (pB0)
 
122
        lea     (ldb,ldb,2), ldb3
 
123
        lea     (ldc,ldc,2), ldc3
 
124
/*
 
125
 *      lda = lda*sizeof
 
126
 */
 
127
        shl     $2, lda
 
128
                                                prefetcht0      64(pB0)
 
129
/*
 
130
 *      pfA = A + lda*M ; incAn = lda*M
 
131
 */
 
132
        movq    lda, pfA
 
133
                                                prefetcht0      128(pB0)
 
134
        imulq   MM0, pfA
 
135
        movq    pfA, incAn
 
136
        lea     -128(pA0, pfA), pfA
 
137
        movq    MM0, MM
 
138
        lea     -128(pB0,ldb,2), pfB
 
139
ALIGN16
 
140
   MNLOOP:
 
141
/*
 
142
 *       K=0-3, with rCxx starting at zero
 
143
 */
 
144
         movaps -128(pB0), rB0
 
145
         xorpd  rC13, rC13
 
146
         movaps -128(pA0), rA0
 
147
         vfmaddps rC13, rA0, rB0, rC00
 
148
         movaps -128(pB0,ldb), rB1
 
149
         vfmaddps rC13, rA0, rB1, rC01
 
150
         movaps -128(pB0,ldb,2), rB2
 
151
         vfmaddps rC13, rA0, rB2, rC02
 
152
         movaps -128(pB0,ldb3), rB3
 
153
         vfmaddps rC13, rA0, rB3, rC03
 
154
         movaps -128(pA0,lda), rA1
 
155
         vfmaddps rC13, rA1, rB0, rC10
 
156
         #if KB > 4
 
157
            movaps -112(pA0), ra0
 
158
         #endif
 
159
         vfmaddps rC13, rA1, rB1, rC11
 
160
         #if KB > 4
 
161
            movaps -112(pA0,lda), ra1
 
162
         #endif
 
163
         vfmaddps rC13, rA1, rB2, rC12
 
164
         #if KB > 4
 
165
            movaps -112(pB0), rB0
 
166
         #endif
 
167
         vfmaddps rC13, rA1, rB3, rC13
 
168
         #if KB > 4
 
169
            movaps -112(pB0,ldb), rB1
 
170
         #endif
 
171
/*
 
172
 *       K=4-7
 
173
 */
 
174
        #if KB > 4
 
175
           vfmaddps rC00, ra0, rB0, rC00
 
176
           movaps -112(pB0,ldb,2), rB2
 
177
           vfmaddps rC10, ra1, rB0, rC10
 
178
           movaps -112(pB0,ldb3), rB3
 
179
           vfmaddps rC01, ra0, rB1, rC01
 
180
           #if KB > 8
 
181
              movaps -96(pA0), rA0
 
182
           #endif
 
183
           vfmaddps rC11, ra1, rB1, rC11
 
184
           #if KB > 8
 
185
              movaps -96(pA0,lda), rA1
 
186
           #endif
 
187
           vfmaddps rC02, ra0, rB2, rC02
 
188
           #if KB > 8
 
189
              movaps -96(pB0), rB0
 
190
           #endif
 
191
           vfmaddps rC12, ra1, rB2, rC12
 
192
           #if KB > 8
 
193
              movaps -96(pB0,ldb), rB1
 
194
           #endif
 
195
           vfmaddps rC03, ra0, rB3, rC03
 
196
           #if KB > 8
 
197
              movaps -96(pB0,ldb,2), rB2
 
198
           #endif
 
199
           vfmaddps rC13, ra1, rB3, rC13
 
200
           #if KB > 8
 
201
              movaps -96(pB0,ldb3), rB3
 
202
           #endif
 
203
        #endif
 
204
        #if KB <= 8
 
205
        #endif
 
206
        #if KB > 8
 
207
           vfmaddps rC00, rA0, rB0, rC00
 
208
           #if KB > 12
 
209
              movaps -80(pA0), ra0
 
210
           #endif
 
211
           vfmaddps rC10, rA1, rB0, rC10
 
212
           #if KB > 12
 
213
              movaps -80(pA0,lda), ra1
 
214
           #endif
 
215
           vfmaddps rC01, rA0, rB1, rC01
 
216
           #if KB > 12
 
217
              movaps -80(pB0), rB0
 
218
           #elif KB == 12 && defined(BETA1)
 
219
           #endif
 
220
           vfmaddps rC11, rA1, rB1, rC11
 
221
           #if KB > 12
 
222
              movaps -80(pB0,ldb), rB1
 
223
           #elif KB == 12 && defined(BETA1)
 
224
           #endif
 
225
           vfmaddps rC02, rA0, rB2, rC02
 
226
           #if KB == 12
 
227
              prefetcht0 (pfB)
 
228
              add $64, pfB
 
229
           #endif
 
230
           vfmaddps rC12, rA1, rB2, rC12
 
231
           #if KB > 12
 
232
              movaps -80(pB0,ldb,2), rB2
 
233
           #elif KB == 12 && defined(BETA1)
 
234
           #endif
 
235
           vfmaddps rC03, rA0, rB3, rC03
 
236
           #if KB == 12 && defined(BETA1)
 
237
           #endif
 
238
           vfmaddps rC13, rA1, rB3, rC13
 
239
           #if KB > 12
 
240
              movaps -80(pB0,ldb3), rB3
 
241
           #elif KB == 12 && defined(BETA0)
 
242
           #endif
 
243
        #endif
 
244
        #if KB > 12
 
245
           vfmaddps rC00, ra0, rB0, rC00
 
246
           #if KB > 16
 
247
              movaps -64(pA0), rA0
 
248
           #endif
 
249
           vfmaddps rC10, ra1, rB0, rC10
 
250
           #if KB > 16
 
251
              movaps -64(pA0,lda), rA1
 
252
           #endif
 
253
           vfmaddps rC01, ra0, rB1, rC01
 
254
           #if KB > 16
 
255
              movaps -64(pB0), rB0
 
256
           #elif KB == 16 && defined(BETA1)
 
257
           #endif
 
258
           vfmaddps rC11, ra1, rB1, rC11
 
259
           #if KB > 16
 
260
              movaps -64(pB0,ldb), rB1
 
261
           #elif KB == 16 && defined(BETA1)
 
262
           #endif
 
263
           vfmaddps rC02, ra0, rB2, rC02
 
264
           #if KB == 16
 
265
              prefetcht0 (pfB)
 
266
              add $64, pfB
 
267
           #endif
 
268
           vfmaddps rC12, ra1, rB2, rC12
 
269
           #if KB > 16
 
270
              movaps -64(pB0,ldb,2), rB2
 
271
           #elif KB == 16 && defined(BETA1)
 
272
           #endif
 
273
           vfmaddps rC03, ra0, rB3, rC03
 
274
           #if KB == 16 && defined(BETA1)
 
275
           #endif
 
276
           vfmaddps rC13, ra1, rB3, rC13
 
277
           #if KB > 16
 
278
              movaps -64(pB0,ldb3), rB3
 
279
           #elif KB == 16 && defined(BETA1)
 
280
           #endif
 
281
        #endif
 
282
        #if KB > 16
 
283
           vfmaddps rC00, rA0, rB0, rC00
 
284
           #if KB > 20
 
285
              movaps -48(pA0), ra0
 
286
           #endif
 
287
           vfmaddps rC10, rA1, rB0, rC10
 
288
           #if KB > 20
 
289
              movaps -48(pA0,lda), ra1
 
290
           #endif
 
291
           vfmaddps rC01, rA0, rB1, rC01
 
292
           #if KB > 20
 
293
              movaps -48(pB0), rB0
 
294
           #elif KB == 20 && defined(BETA1)
 
295
           #endif
 
296
           vfmaddps rC11, rA1, rB1, rC11
 
297
           #if KB > 20
 
298
              movaps -48(pB0,ldb), rB1
 
299
           #elif KB == 20 && defined(BETA1)
 
300
           #endif
 
301
           vfmaddps rC02, rA0, rB2, rC02
 
302
           #if KB == 20 && defined(BETA0)
 
303
           #endif
 
304
           vfmaddps rC12, rA1, rB2, rC12
 
305
           #if KB > 20
 
306
              movaps -48(pB0,ldb,2), rB2
 
307
           #elif KB == 20 && defined(BETA1)
 
308
           #endif
 
309
           vfmaddps rC03, rA0, rB3, rC03
 
310
           #if KB == 20 && defined(BETA1)
 
311
           #endif
 
312
           vfmaddps rC13, rA1, rB3, rC13
 
313
           #if KB > 20
 
314
              movaps -48(pB0,ldb3), rB3
 
315
           #elif KB == 20 && defined(BETA0)
 
316
           #endif
 
317
        #endif
 
318
        #if KB > 20
 
319
           vfmaddps rC00, ra0, rB0, rC00
 
320
           #if KB > 24
 
321
              movaps -32(pA0), rA0
 
322
           #endif
 
323
           vfmaddps rC10, ra1, rB0, rC10
 
324
           #if KB > 24
 
325
              movaps -32(pA0,lda), rA1
 
326
           #endif
 
327
           vfmaddps rC01, ra0, rB1, rC01
 
328
           #if KB > 24
 
329
              movaps -32(pB0), rB0
 
330
           #elif KB == 24 && defined(BETA1)
 
331
           #endif
 
332
           vfmaddps rC11, ra1, rB1, rC11
 
333
           #if KB > 24
 
334
              movaps -32(pB0,ldb), rB1
 
335
           #elif KB == 24 && defined(BETA1)
 
336
           #endif
 
337
           vfmaddps rC02, ra0, rB2, rC02
 
338
           #if KB == 24 && defined(BETA1)
 
339
           #endif
 
340
           vfmaddps rC12, ra1, rB2, rC12
 
341
           #if KB > 24
 
342
              movaps -32(pB0,ldb,2), rB2
 
343
           #elif KB == 24 && defined(BETA1)
 
344
           #endif
 
345
           vfmaddps rC03, ra0, rB3, rC03
 
346
           #if KB == 24 && defined(BETA1)
 
347
           #endif
 
348
           vfmaddps rC13, ra1, rB3, rC13
 
349
           #if KB > 24
 
350
              movaps -32(pB0,ldb3), rB3
 
351
           #elif KB == 24 && defined(BETA1)
 
352
           #endif
 
353
        #endif
 
354
        #if KB > 24
 
355
           vfmaddps rC00, rA0, rB0, rC00
 
356
           #if KB > 28
 
357
              movaps -16(pA0), ra0
 
358
           #endif
 
359
           vfmaddps rC10, rA1, rB0, rC10
 
360
           #if KB > 28
 
361
              movaps -16(pA0,lda), ra1
 
362
           #endif
 
363
           vfmaddps rC01, rA0, rB1, rC01
 
364
           #if KB > 28
 
365
              movaps -16(pB0), rB0
 
366
           #elif KB == 28 && defined(BETA1)
 
367
           #endif
 
368
           vfmaddps rC11, rA1, rB1, rC11
 
369
           #if KB > 28
 
370
              movaps -16(pB0,ldb), rB1
 
371
           #elif KB == 28 && defined(BETA1)
 
372
           #endif
 
373
           vfmaddps rC02, rA0, rB2, rC02
 
374
           #if KB == 28 && defined(BETA0)
 
375
           #endif
 
376
           vfmaddps rC12, rA1, rB2, rC12
 
377
           #if KB > 28
 
378
              movaps -16(pB0,ldb,2), rB2
 
379
           #elif KB == 28 && defined(BETA1)
 
380
           #endif
 
381
           vfmaddps rC03, rA0, rB3, rC03
 
382
           #if KB == 28 && defined(BETA1)
 
383
           #endif
 
384
           vfmaddps rC13, rA1, rB3, rC13
 
385
           #if KB > 28
 
386
              movaps -16(pB0,ldb3), rB3
 
387
           #elif KB == 28 && defined(BETA0)
 
388
           #endif
 
389
        #endif
 
390
        #if KB > 28
 
391
           vfmaddps rC00, ra0, rB0, rC00
 
392
           #if KB > 32
 
393
              movaps 0(pA0), rA0
 
394
           #endif
 
395
           vfmaddps rC10, ra1, rB0, rC10
 
396
           #if KB > 32
 
397
              movaps 0(pA0,lda), rA1
 
398
           #endif
 
399
           vfmaddps rC01, ra0, rB1, rC01
 
400
           #if KB > 32
 
401
              movaps 0(pB0), rB0
 
402
           #elif KB == 32 && defined(BETA1)
 
403
           #endif
 
404
           vfmaddps rC11, ra1, rB1, rC11
 
405
           #if KB > 32
 
406
              movaps 0(pB0,ldb), rB1
 
407
           #elif KB == 32 && defined(BETA1)
 
408
           #endif
 
409
           vfmaddps rC02, ra0, rB2, rC02
 
410
           #if KB == 32 && defined(BETA1)
 
411
           #endif
 
412
           vfmaddps rC12, ra1, rB2, rC12
 
413
           #if KB > 32
 
414
              movaps 0(pB0,ldb,2), rB2
 
415
           #elif KB == 32 && defined(BETA1)
 
416
           #endif
 
417
           vfmaddps rC03, ra0, rB3, rC03
 
418
           #if KB == 32 && defined(BETA1)
 
419
           #endif
 
420
           vfmaddps rC13, ra1, rB3, rC13
 
421
           #if KB > 32
 
422
              movaps 0(pB0,ldb3), rB3
 
423
           #elif KB == 32 && defined(BETA1)
 
424
           #endif
 
425
        #endif
 
426
        #if KB > 32
 
427
           vfmaddps rC00, rA0, rB0, rC00
 
428
           #if KB > 36
 
429
              movaps 16(pA0), ra0
 
430
           #endif
 
431
           vfmaddps rC10, rA1, rB0, rC10
 
432
           #if KB > 36
 
433
              movaps 16(pA0,lda), ra1
 
434
           #endif
 
435
           vfmaddps rC01, rA0, rB1, rC01
 
436
           #if KB > 36
 
437
              movaps 16(pB0), rB0
 
438
           #elif KB == 36 && defined(BETA1)
 
439
           #endif
 
440
           vfmaddps rC11, rA1, rB1, rC11
 
441
           #if KB > 36
 
442
              movaps 16(pB0,ldb), rB1
 
443
           #elif KB == 36 && defined(BETA1)
 
444
           #endif
 
445
           vfmaddps rC02, rA0, rB2, rC02
 
446
           #if KB == 36 && defined(BETA0)
 
447
           #endif
 
448
           vfmaddps rC12, rA1, rB2, rC12
 
449
           #if KB > 36
 
450
              movaps 16(pB0,ldb,2), rB2
 
451
           #elif KB == 36 && defined(BETA1)
 
452
           #endif
 
453
           vfmaddps rC03, rA0, rB3, rC03
 
454
           #if KB == 36 && defined(BETA1)
 
455
           #endif
 
456
           vfmaddps rC13, rA1, rB3, rC13
 
457
           #if KB > 36
 
458
              movaps 16(pB0,ldb3), rB3
 
459
           #elif KB == 36 && defined(BETA0)
 
460
           #endif
 
461
        #endif
 
462
        #if KB > 36
 
463
           vfmaddps rC00, ra0, rB0, rC00
 
464
           #if KB > 40
 
465
              movaps 32(pA0), rA0
 
466
           #endif
 
467
           vfmaddps rC10, ra1, rB0, rC10
 
468
           #if KB > 40
 
469
              movaps 32(pA0,lda), rA1
 
470
           #endif
 
471
           vfmaddps rC01, ra0, rB1, rC01
 
472
           #if KB > 40
 
473
              movaps 32(pB0), rB0
 
474
           #elif KB == 40 && defined(BETA1)
 
475
           #endif
 
476
           vfmaddps rC11, ra1, rB1, rC11
 
477
           #if KB > 40
 
478
              movaps 32(pB0,ldb), rB1
 
479
           #elif KB == 40 && defined(BETA1)
 
480
           #endif
 
481
           vfmaddps rC02, ra0, rB2, rC02
 
482
           #if KB == 40 && defined(BETA1)
 
483
           #endif
 
484
           vfmaddps rC12, ra1, rB2, rC12
 
485
           #if KB > 40
 
486
              movaps 32(pB0,ldb,2), rB2
 
487
           #elif KB == 40 && defined(BETA1)
 
488
           #endif
 
489
           vfmaddps rC03, ra0, rB3, rC03
 
490
           #if KB == 40 && defined(BETA1)
 
491
           #endif
 
492
           vfmaddps rC13, ra1, rB3, rC13
 
493
           #if KB > 40
 
494
              movaps 32(pB0,ldb3), rB3
 
495
           #elif KB == 40 && defined(BETA1)
 
496
           #endif
 
497
        #endif
 
498
        #if KB > 40
 
499
           vfmaddps rC00, rA0, rB0, rC00
 
500
           #if KB > 44
 
501
              movaps 48(pA0), ra0
 
502
           #endif
 
503
           vfmaddps rC10, rA1, rB0, rC10
 
504
           #if KB > 44
 
505
              movaps 48(pA0,lda), ra1
 
506
           #endif
 
507
           vfmaddps rC01, rA0, rB1, rC01
 
508
           #if KB > 44
 
509
              movaps 48(pB0), rB0
 
510
           #elif KB == 44 && defined(BETA1)
 
511
           #endif
 
512
           vfmaddps rC11, rA1, rB1, rC11
 
513
           #if KB > 44
 
514
              movaps 48(pB0,ldb), rB1
 
515
           #elif KB == 44 && defined(BETA1)
 
516
           #endif
 
517
           vfmaddps rC02, rA0, rB2, rC02
 
518
           #if KB == 44 && defined(BETA0)
 
519
           #endif
 
520
           vfmaddps rC12, rA1, rB2, rC12
 
521
           #if KB > 44
 
522
              movaps 48(pB0,ldb,2), rB2
 
523
           #elif KB == 44 && defined(BETA1)
 
524
           #endif
 
525
           vfmaddps rC03, rA0, rB3, rC03
 
526
           #if KB == 44 && defined(BETA1)
 
527
           #endif
 
528
           vfmaddps rC13, rA1, rB3, rC13
 
529
           #if KB > 44
 
530
              movaps 48(pB0,ldb3), rB3
 
531
           #elif KB == 44 && defined(BETA0)
 
532
           #endif
 
533
        #endif
 
534
        #if KB > 44
 
535
           vfmaddps rC00, ra0, rB0, rC00
 
536
           #if KB > 48
 
537
              movaps 64(pA0), rA0
 
538
           #endif
 
539
           vfmaddps rC10, ra1, rB0, rC10
 
540
           #if KB > 48
 
541
              movaps 64(pA0,lda), rA1
 
542
           #endif
 
543
           vfmaddps rC01, ra0, rB1, rC01
 
544
           #if KB > 48
 
545
              movaps 64(pB0), rB0
 
546
           #elif KB == 48 && defined(BETA1)
 
547
           #endif
 
548
           vfmaddps rC11, ra1, rB1, rC11
 
549
           #if KB > 48
 
550
              movaps 64(pB0,ldb), rB1
 
551
           #elif KB == 48 && defined(BETA1)
 
552
           #endif
 
553
           vfmaddps rC02, ra0, rB2, rC02
 
554
           #if KB == 48 && defined(BETA1)
 
555
           #endif
 
556
           vfmaddps rC12, ra1, rB2, rC12
 
557
           #if KB > 48
 
558
              movaps 64(pB0,ldb,2), rB2
 
559
           #elif KB == 48 && defined(BETA1)
 
560
           #endif
 
561
           vfmaddps rC03, ra0, rB3, rC03
 
562
           #if KB == 48 && defined(BETA1)
 
563
           #endif
 
564
           vfmaddps rC13, ra1, rB3, rC13
 
565
           #if KB > 48
 
566
              movaps 64(pB0,ldb3), rB3
 
567
           #elif KB == 48 && defined(BETA1)
 
568
           #endif
 
569
        #endif
 
570
        #if KB > 48
 
571
           vfmaddps rC00, rA0, rB0, rC00
 
572
           #if KB > 52
 
573
              movaps 80(pA0), ra0
 
574
           #endif
 
575
           vfmaddps rC10, rA1, rB0, rC10
 
576
           #if KB > 52
 
577
              movaps 80(pA0,lda), ra1
 
578
           #endif
 
579
           vfmaddps rC01, rA0, rB1, rC01
 
580
           #if KB > 52
 
581
              movaps 80(pB0), rB0
 
582
           #elif KB == 52 && defined(BETA1)
 
583
           #endif
 
584
           vfmaddps rC11, rA1, rB1, rC11
 
585
           #if KB > 52
 
586
              movaps 80(pB0,ldb), rB1
 
587
           #elif KB == 52 && defined(BETA1)
 
588
           #endif
 
589
           vfmaddps rC02, rA0, rB2, rC02
 
590
           #if KB == 52 && defined(BETA0)
 
591
           #endif
 
592
           vfmaddps rC12, rA1, rB2, rC12
 
593
           #if KB > 52
 
594
              movaps 80(pB0,ldb,2), rB2
 
595
           #elif KB == 52 && defined(BETA1)
 
596
           #endif
 
597
           vfmaddps rC03, rA0, rB3, rC03
 
598
           #if KB == 52 && defined(BETA1)
 
599
           #endif
 
600
           vfmaddps rC13, rA1, rB3, rC13
 
601
           #if KB > 52
 
602
              movaps 80(pB0,ldb3), rB3
 
603
           #elif KB == 52 && defined(BETA0)
 
604
           #endif
 
605
        #endif
 
606
        #if KB > 52
 
607
           vfmaddps rC00, ra0, rB0, rC00
 
608
           #if KB > 56
 
609
              movaps 96(pA0), rA0
 
610
           #endif
 
611
           vfmaddps rC10, ra1, rB0, rC10
 
612
           #if KB > 56
 
613
              movaps 96(pA0,lda), rA1
 
614
           #endif
 
615
           vfmaddps rC01, ra0, rB1, rC01
 
616
           #if KB > 56
 
617
              movaps 96(pB0), rB0
 
618
           #elif KB == 56 && defined(BETA1)
 
619
           #endif
 
620
           vfmaddps rC11, ra1, rB1, rC11
 
621
           #if KB > 56
 
622
              movaps 96(pB0,ldb), rB1
 
623
           #elif KB == 56 && defined(BETA1)
 
624
           #endif
 
625
           vfmaddps rC02, ra0, rB2, rC02
 
626
           #if KB == 56 && defined(BETA1)
 
627
           #endif
 
628
           vfmaddps rC12, ra1, rB2, rC12
 
629
           #if KB > 56
 
630
              movaps 96(pB0,ldb,2), rB2
 
631
           #elif KB == 56 && defined(BETA1)
 
632
           #endif
 
633
           vfmaddps rC03, ra0, rB3, rC03
 
634
           #if KB == 56 && defined(BETA1)
 
635
           #endif
 
636
           vfmaddps rC13, ra1, rB3, rC13
 
637
           #if KB > 56
 
638
              movaps 96(pB0,ldb3), rB3
 
639
           #elif KB == 56 && defined(BETA1)
 
640
           #endif
 
641
        #endif
 
642
        #if KB > 56
 
643
           vfmaddps rC00, rA0, rB0, rC00
 
644
           #if KB > 60
 
645
              movaps 112(pA0), ra0
 
646
           #endif
 
647
           vfmaddps rC10, rA1, rB0, rC10
 
648
           #if KB > 60
 
649
              movaps 112(pA0,lda), ra1
 
650
           #endif
 
651
           vfmaddps rC01, rA0, rB1, rC01
 
652
           #if KB > 60
 
653
              movaps 112(pB0), rB0
 
654
           #elif KB == 60 && defined(BETA1)
 
655
           #endif
 
656
           vfmaddps rC11, rA1, rB1, rC11
 
657
           #if KB > 60
 
658
              movaps 112(pB0,ldb), rB1
 
659
           #elif KB == 60 && defined(BETA1)
 
660
           #endif
 
661
           vfmaddps rC02, rA0, rB2, rC02
 
662
           #if KB == 60 && defined(BETA0)
 
663
           #endif
 
664
           vfmaddps rC12, rA1, rB2, rC12
 
665
           #if KB > 60
 
666
              movaps 112(pB0,ldb,2), rB2
 
667
           #elif KB == 60 && defined(BETA1)
 
668
           #endif
 
669
           vfmaddps rC03, rA0, rB3, rC03
 
670
           #if KB == 60 && defined(BETA1)
 
671
           #endif
 
672
           vfmaddps rC13, rA1, rB3, rC13
 
673
           #if KB > 60
 
674
              movaps 112(pB0,ldb3), rB3
 
675
           #elif KB == 60 && defined(BETA0)
 
676
           #endif
 
677
        #endif
 
678
        #if KB > 60
 
679
           vfmaddps rC00, ra0, rB0, rC00
 
680
           #if KB > 64
 
681
              movaps 128(pA0), rA0
 
682
           #endif
 
683
           vfmaddps rC10, ra1, rB0, rC10
 
684
           #if KB > 64
 
685
              movaps 128(pA0,lda), rA1
 
686
           #endif
 
687
           vfmaddps rC01, ra0, rB1, rC01
 
688
           #if KB > 64
 
689
              movaps 128(pB0), rB0
 
690
           #elif KB == 64 && defined(BETA1)
 
691
           #endif
 
692
           vfmaddps rC11, ra1, rB1, rC11
 
693
           #if KB > 64
 
694
              movaps 128(pB0,ldb), rB1
 
695
           #elif KB == 64 && defined(BETA1)
 
696
           #endif
 
697
           vfmaddps rC02, ra0, rB2, rC02
 
698
           #if KB == 64 && defined(BETA1)
 
699
           #endif
 
700
           vfmaddps rC12, ra1, rB2, rC12
 
701
           #if KB > 64
 
702
              movaps 128(pB0,ldb,2), rB2
 
703
           #elif KB == 64 && defined(BETA1)
 
704
           #endif
 
705
           vfmaddps rC03, ra0, rB3, rC03
 
706
           #if KB == 64 && defined(BETA1)
 
707
           #endif
 
708
           vfmaddps rC13, ra1, rB3, rC13
 
709
           #if KB > 64
 
710
              movaps 128(pB0,ldb3), rB3
 
711
           #elif KB == 64 && defined(BETA1)
 
712
           #endif
 
713
        #endif
 
714
        #if KB > 64
 
715
           vfmaddps rC00, rA0, rB0, rC00
 
716
           #if KB > 68
 
717
              movaps 144(pA0), ra0
 
718
           #endif
 
719
           vfmaddps rC10, rA1, rB0, rC10
 
720
           #if KB > 68
 
721
              movaps 144(pA0,lda), ra1
 
722
           #endif
 
723
           vfmaddps rC01, rA0, rB1, rC01
 
724
           #if KB > 68
 
725
              movaps 144(pB0), rB0
 
726
           #elif KB == 68 && defined(BETA1)
 
727
           #endif
 
728
           vfmaddps rC11, rA1, rB1, rC11
 
729
           #if KB > 68
 
730
              movaps 144(pB0,ldb), rB1
 
731
           #elif KB == 68 && defined(BETA1)
 
732
           #endif
 
733
           vfmaddps rC02, rA0, rB2, rC02
 
734
           #if KB == 68 && defined(BETA0)
 
735
           #endif
 
736
           vfmaddps rC12, rA1, rB2, rC12
 
737
           #if KB > 68
 
738
              movaps 144(pB0,ldb,2), rB2
 
739
           #elif KB == 68 && defined(BETA1)
 
740
           #endif
 
741
           vfmaddps rC03, rA0, rB3, rC03
 
742
           #if KB == 68 && defined(BETA1)
 
743
           #endif
 
744
           vfmaddps rC13, rA1, rB3, rC13
 
745
           #if KB > 68
 
746
              movaps 144(pB0,ldb3), rB3
 
747
           #elif KB == 68 && defined(BETA0)
 
748
           #endif
 
749
        #endif
 
750
        #if KB > 68
 
751
           vfmaddps rC00, ra0, rB0, rC00
 
752
           #if KB > 72
 
753
              movaps 160(pA0), rA0
 
754
           #endif
 
755
           vfmaddps rC10, ra1, rB0, rC10
 
756
           #if KB > 72
 
757
              movaps 160(pA0,lda), rA1
 
758
           #endif
 
759
           vfmaddps rC01, ra0, rB1, rC01
 
760
           #if KB > 72
 
761
              movaps 160(pB0), rB0
 
762
           #elif KB == 72 && defined(BETA1)
 
763
           #endif
 
764
           vfmaddps rC11, ra1, rB1, rC11
 
765
           #if KB > 72
 
766
              movaps 160(pB0,ldb), rB1
 
767
           #elif KB == 72 && defined(BETA1)
 
768
           #endif
 
769
           vfmaddps rC02, ra0, rB2, rC02
 
770
           #if KB == 72 && defined(BETA1)
 
771
           #endif
 
772
           vfmaddps rC12, ra1, rB2, rC12
 
773
           #if KB > 72
 
774
              movaps 160(pB0,ldb,2), rB2
 
775
           #elif KB == 72 && defined(BETA1)
 
776
           #endif
 
777
           vfmaddps rC03, ra0, rB3, rC03
 
778
           #if KB == 72 && defined(BETA1)
 
779
           #endif
 
780
           vfmaddps rC13, ra1, rB3, rC13
 
781
           #if KB > 72
 
782
              movaps 160(pB0,ldb3), rB3
 
783
           #elif KB == 72 && defined(BETA1)
 
784
           #endif
 
785
        #endif
 
786
        #if KB > 72
 
787
           vfmaddps rC00, rA0, rB0, rC00
 
788
           #if KB > 76
 
789
              movaps 176(pA0), ra0
 
790
           #endif
 
791
           vfmaddps rC10, rA1, rB0, rC10
 
792
           #if KB > 76
 
793
              movaps 176(pA0,lda), ra1
 
794
           #endif
 
795
           vfmaddps rC01, rA0, rB1, rC01
 
796
           #if KB > 76
 
797
              movaps 176(pB0), rB0
 
798
           #elif KB == 76 && defined(BETA1)
 
799
           #endif
 
800
           vfmaddps rC11, rA1, rB1, rC11
 
801
           #if KB > 76
 
802
              movaps 176(pB0,ldb), rB1
 
803
           #elif KB == 76 && defined(BETA1)
 
804
           #endif
 
805
           vfmaddps rC02, rA0, rB2, rC02
 
806
           #if KB == 76 && defined(BETA0)
 
807
           #endif
 
808
           vfmaddps rC12, rA1, rB2, rC12
 
809
           #if KB > 76
 
810
              movaps 176(pB0,ldb,2), rB2
 
811
           #elif KB == 76 && defined(BETA1)
 
812
           #endif
 
813
           vfmaddps rC03, rA0, rB3, rC03
 
814
           #if KB == 76 && defined(BETA1)
 
815
           #endif
 
816
           vfmaddps rC13, rA1, rB3, rC13
 
817
           #if KB > 76
 
818
              movaps 176(pB0,ldb3), rB3
 
819
           #elif KB == 76 && defined(BETA0)
 
820
           #endif
 
821
        #endif
 
822
        #if KB > 76
 
823
           vfmaddps rC00, ra0, rB0, rC00
 
824
           #if KB > 80
 
825
              movaps 192(pA0), rA0
 
826
           #endif
 
827
           vfmaddps rC10, ra1, rB0, rC10
 
828
           #if KB > 80
 
829
              movaps 192(pA0,lda), rA1
 
830
           #endif
 
831
           vfmaddps rC01, ra0, rB1, rC01
 
832
           #if KB > 80
 
833
              movaps 192(pB0), rB0
 
834
           #elif KB == 80 && defined(BETA1)
 
835
           #endif
 
836
           vfmaddps rC11, ra1, rB1, rC11
 
837
           #if KB > 80
 
838
              movaps 192(pB0,ldb), rB1
 
839
           #elif KB == 80 && defined(BETA1)
 
840
           #endif
 
841
           vfmaddps rC02, ra0, rB2, rC02
 
842
           #if KB == 80 && defined(BETA1)
 
843
           #endif
 
844
           vfmaddps rC12, ra1, rB2, rC12
 
845
           #if KB > 80
 
846
              movaps 192(pB0,ldb,2), rB2
 
847
           #elif KB == 80 && defined(BETA1)
 
848
           #endif
 
849
           vfmaddps rC03, ra0, rB3, rC03
 
850
           #if KB == 80 && defined(BETA1)
 
851
           #endif
 
852
           vfmaddps rC13, ra1, rB3, rC13
 
853
           #if KB > 80
 
854
              movaps 192(pB0,ldb3), rB3
 
855
           #elif KB == 80 && defined(BETA1)
 
856
           #endif
 
857
        #endif
 
858
        #if KB > 80
 
859
           vfmaddps rC00, rA0, rB0, rC00
 
860
           #if KB > 84
 
861
              movaps 208(pA0), ra0
 
862
           #endif
 
863
           vfmaddps rC10, rA1, rB0, rC10
 
864
           #if KB > 84
 
865
              movaps 208(pA0,lda), ra1
 
866
           #endif
 
867
           vfmaddps rC01, rA0, rB1, rC01
 
868
           #if KB > 84
 
869
              movaps 208(pB0), rB0
 
870
           #elif KB == 84 && defined(BETA1)
 
871
           #endif
 
872
           vfmaddps rC11, rA1, rB1, rC11
 
873
           #if KB > 84
 
874
              movaps 208(pB0,ldb), rB1
 
875
           #elif KB == 84 && defined(BETA1)
 
876
           #endif
 
877
           vfmaddps rC02, rA0, rB2, rC02
 
878
           #if KB == 84 && defined(BETA0)
 
879
           #endif
 
880
           vfmaddps rC12, rA1, rB2, rC12
 
881
           #if KB > 84
 
882
              movaps 208(pB0,ldb,2), rB2
 
883
           #elif KB == 84 && defined(BETA1)
 
884
           #endif
 
885
           vfmaddps rC03, rA0, rB3, rC03
 
886
           #if KB == 84 && defined(BETA1)
 
887
           #endif
 
888
           vfmaddps rC13, rA1, rB3, rC13
 
889
           #if KB > 84
 
890
              movaps 208(pB0,ldb3), rB3
 
891
           #elif KB == 84 && defined(BETA0)
 
892
           #endif
 
893
        #endif
 
894
        #if KB > 84
 
895
           vfmaddps rC00, ra0, rB0, rC00
 
896
           #if KB > 88
 
897
              movaps 224(pA0), rA0
 
898
           #endif
 
899
           vfmaddps rC10, ra1, rB0, rC10
 
900
           #if KB > 88
 
901
              movaps 224(pA0,lda), rA1
 
902
           #endif
 
903
           vfmaddps rC01, ra0, rB1, rC01
 
904
           #if KB > 88
 
905
              movaps 224(pB0), rB0
 
906
           #elif KB == 88 && defined(BETA1)
 
907
           #endif
 
908
           vfmaddps rC11, ra1, rB1, rC11
 
909
           #if KB > 88
 
910
              movaps 224(pB0,ldb), rB1
 
911
           #elif KB == 88 && defined(BETA1)
 
912
           #endif
 
913
           vfmaddps rC02, ra0, rB2, rC02
 
914
           #if KB == 88 && defined(BETA1)
 
915
           #endif
 
916
           vfmaddps rC12, ra1, rB2, rC12
 
917
           #if KB > 88
 
918
              movaps 224(pB0,ldb,2), rB2
 
919
           #elif KB == 88 && defined(BETA1)
 
920
           #endif
 
921
           vfmaddps rC03, ra0, rB3, rC03
 
922
           #if KB == 88 && defined(BETA1)
 
923
           #endif
 
924
           vfmaddps rC13, ra1, rB3, rC13
 
925
           #if KB > 88
 
926
              movaps 224(pB0,ldb3), rB3
 
927
           #elif KB == 88 && defined(BETA1)
 
928
           #endif
 
929
        #endif
 
930
        #if KB > 88
 
931
           vfmaddps rC00, rA0, rB0, rC00
 
932
           #if KB > 92
 
933
              movaps 240(pA0), ra0
 
934
           #endif
 
935
           vfmaddps rC10, rA1, rB0, rC10
 
936
           #if KB > 92
 
937
              movaps 240(pA0,lda), ra1
 
938
           #endif
 
939
           vfmaddps rC01, rA0, rB1, rC01
 
940
           #if KB > 92
 
941
              movaps 240(pB0), rB0
 
942
           #elif KB == 92 && defined(BETA1)
 
943
           #endif
 
944
           vfmaddps rC11, rA1, rB1, rC11
 
945
           #if KB > 92
 
946
              movaps 240(pB0,ldb), rB1
 
947
           #elif KB == 92 && defined(BETA1)
 
948
           #endif
 
949
           vfmaddps rC02, rA0, rB2, rC02
 
950
           #if KB == 92 && defined(BETA0)
 
951
           #endif
 
952
           vfmaddps rC12, rA1, rB2, rC12
 
953
           #if KB > 92
 
954
              movaps 240(pB0,ldb,2), rB2
 
955
           #elif KB == 92 && defined(BETA1)
 
956
           #endif
 
957
           vfmaddps rC03, rA0, rB3, rC03
 
958
           #if KB == 92 && defined(BETA1)
 
959
           #endif
 
960
           vfmaddps rC13, rA1, rB3, rC13
 
961
           #if KB > 92
 
962
              movaps 240(pB0,ldb3), rB3
 
963
           #elif KB == 92 && defined(BETA0)
 
964
           #endif
 
965
        #endif
 
966
        #if KB > 92
 
967
           vfmaddps rC00, ra0, rB0, rC00
 
968
           #if KB > 96
 
969
              movaps 256(pA0), rA0
 
970
           #endif
 
971
           vfmaddps rC10, ra1, rB0, rC10
 
972
           #if KB > 96
 
973
              movaps 256(pA0,lda), rA1
 
974
           #endif
 
975
           vfmaddps rC01, ra0, rB1, rC01
 
976
           #if KB > 96
 
977
              movaps 256(pB0), rB0
 
978
           #elif KB == 96 && defined(BETA1)
 
979
           #endif
 
980
           vfmaddps rC11, ra1, rB1, rC11
 
981
           #if KB > 96
 
982
              movaps 256(pB0,ldb), rB1
 
983
           #elif KB == 96 && defined(BETA1)
 
984
           #endif
 
985
           vfmaddps rC02, ra0, rB2, rC02
 
986
           #if KB == 96 && defined(BETA1)
 
987
           #endif
 
988
           vfmaddps rC12, ra1, rB2, rC12
 
989
           #if KB > 96
 
990
              movaps 256(pB0,ldb,2), rB2
 
991
           #elif KB == 96 && defined(BETA1)
 
992
           #endif
 
993
           vfmaddps rC03, ra0, rB3, rC03
 
994
           #if KB == 96 && defined(BETA1)
 
995
           #endif
 
996
           vfmaddps rC13, ra1, rB3, rC13
 
997
           #if KB > 96
 
998
              movaps 256(pB0,ldb3), rB3
 
999
           #elif KB == 96 && defined(BETA1)
 
1000
           #endif
 
1001
        #endif
 
1002
        #if KB > 96
 
1003
           vfmaddps rC00, rA0, rB0, rC00
 
1004
           #if KB > 100
 
1005
              movaps 272(pA0), ra0
 
1006
           #endif
 
1007
           vfmaddps rC10, rA1, rB0, rC10
 
1008
           #if KB > 100
 
1009
              movaps 272(pA0,lda), ra1
 
1010
           #endif
 
1011
           vfmaddps rC01, rA0, rB1, rC01
 
1012
           #if KB > 100
 
1013
              movaps 272(pB0), rB0
 
1014
           #elif KB == 100 && defined(BETA1)
 
1015
           #endif
 
1016
           vfmaddps rC11, rA1, rB1, rC11
 
1017
           #if KB > 100
 
1018
              movaps 272(pB0,ldb), rB1
 
1019
           #elif KB == 100 && defined(BETA1)
 
1020
           #endif
 
1021
           vfmaddps rC02, rA0, rB2, rC02
 
1022
           #if KB == 100 && defined(BETA0)
 
1023
           #endif
 
1024
           vfmaddps rC12, rA1, rB2, rC12
 
1025
           #if KB > 100
 
1026
              movaps 272(pB0,ldb,2), rB2
 
1027
           #elif KB == 100 && defined(BETA1)
 
1028
           #endif
 
1029
           vfmaddps rC03, rA0, rB3, rC03
 
1030
           #if KB == 100 && defined(BETA1)
 
1031
           #endif
 
1032
           vfmaddps rC13, rA1, rB3, rC13
 
1033
           #if KB > 100
 
1034
              movaps 272(pB0,ldb3), rB3
 
1035
           #elif KB == 100 && defined(BETA0)
 
1036
           #endif
 
1037
        #endif
 
1038
        #if KB > 100
 
1039
           vfmaddps rC00, ra0, rB0, rC00
 
1040
           #if KB > 104
 
1041
              movaps 288(pA0), rA0
 
1042
           #endif
 
1043
           vfmaddps rC10, ra1, rB0, rC10
 
1044
           #if KB > 104
 
1045
              movaps 288(pA0,lda), rA1
 
1046
           #endif
 
1047
           vfmaddps rC01, ra0, rB1, rC01
 
1048
           #if KB > 104
 
1049
              movaps 288(pB0), rB0
 
1050
           #elif KB == 104 && defined(BETA1)
 
1051
           #endif
 
1052
           vfmaddps rC11, ra1, rB1, rC11
 
1053
           #if KB > 104
 
1054
              movaps 288(pB0,ldb), rB1
 
1055
           #elif KB == 104 && defined(BETA1)
 
1056
           #endif
 
1057
           vfmaddps rC02, ra0, rB2, rC02
 
1058
           #if KB == 104 && defined(BETA1)
 
1059
           #endif
 
1060
           vfmaddps rC12, ra1, rB2, rC12
 
1061
           #if KB > 104
 
1062
              movaps 288(pB0,ldb,2), rB2
 
1063
           #elif KB == 104 && defined(BETA1)
 
1064
           #endif
 
1065
           vfmaddps rC03, ra0, rB3, rC03
 
1066
           #if KB == 104 && defined(BETA1)
 
1067
           #endif
 
1068
           vfmaddps rC13, ra1, rB3, rC13
 
1069
           #if KB > 104
 
1070
              movaps 288(pB0,ldb3), rB3
 
1071
           #elif KB == 104 && defined(BETA1)
 
1072
           #endif
 
1073
        #endif
 
1074
        #if KB > 104
 
1075
           vfmaddps rC00, rA0, rB0, rC00
 
1076
           #if KB > 108
 
1077
              movaps 304(pA0), ra0
 
1078
           #endif
 
1079
           vfmaddps rC10, rA1, rB0, rC10
 
1080
           #if KB > 108
 
1081
              movaps 304(pA0,lda), ra1
 
1082
           #endif
 
1083
           vfmaddps rC01, rA0, rB1, rC01
 
1084
           #if KB > 108
 
1085
              movaps 304(pB0), rB0
 
1086
           #elif KB == 108 && defined(BETA1)
 
1087
           #endif
 
1088
           vfmaddps rC11, rA1, rB1, rC11
 
1089
           #if KB > 108
 
1090
              movaps 304(pB0,ldb), rB1
 
1091
           #elif KB == 108 && defined(BETA1)
 
1092
           #endif
 
1093
           vfmaddps rC02, rA0, rB2, rC02
 
1094
           #if KB == 108 && defined(BETA0)
 
1095
           #endif
 
1096
           vfmaddps rC12, rA1, rB2, rC12
 
1097
           #if KB > 108
 
1098
              movaps 304(pB0,ldb,2), rB2
 
1099
           #elif KB == 108 && defined(BETA1)
 
1100
           #endif
 
1101
           vfmaddps rC03, rA0, rB3, rC03
 
1102
           #if KB == 108 && defined(BETA1)
 
1103
           #endif
 
1104
           vfmaddps rC13, rA1, rB3, rC13
 
1105
           #if KB > 108
 
1106
              movaps 304(pB0,ldb3), rB3
 
1107
           #elif KB == 108 && defined(BETA0)
 
1108
           #endif
 
1109
        #endif
 
1110
        #if KB > 108
 
1111
           vfmaddps rC00, ra0, rB0, rC00
 
1112
           #if KB > 112
 
1113
              movaps 320(pA0), rA0
 
1114
           #endif
 
1115
           vfmaddps rC10, ra1, rB0, rC10
 
1116
           #if KB > 112
 
1117
              movaps 320(pA0,lda), rA1
 
1118
           #endif
 
1119
           vfmaddps rC01, ra0, rB1, rC01
 
1120
           #if KB > 112
 
1121
              movaps 320(pB0), rB0
 
1122
           #elif KB == 112 && defined(BETA1)
 
1123
           #endif
 
1124
           vfmaddps rC11, ra1, rB1, rC11
 
1125
           #if KB > 112
 
1126
              movaps 320(pB0,ldb), rB1
 
1127
           #elif KB == 112 && defined(BETA1)
 
1128
           #endif
 
1129
           vfmaddps rC02, ra0, rB2, rC02
 
1130
           #if KB == 112 && defined(BETA1)
 
1131
           #endif
 
1132
           vfmaddps rC12, ra1, rB2, rC12
 
1133
           #if KB > 112
 
1134
              movaps 320(pB0,ldb,2), rB2
 
1135
           #elif KB == 112 && defined(BETA1)
 
1136
           #endif
 
1137
           vfmaddps rC03, ra0, rB3, rC03
 
1138
           #if KB == 112 && defined(BETA1)
 
1139
           #endif
 
1140
           vfmaddps rC13, ra1, rB3, rC13
 
1141
           #if KB > 112
 
1142
              movaps 320(pB0,ldb3), rB3
 
1143
           #elif KB == 112 && defined(BETA1)
 
1144
           #endif
 
1145
        #endif
 
1146
        #if KB > 112
 
1147
           vfmaddps rC00, rA0, rB0, rC00
 
1148
           #if KB > 116
 
1149
              movaps 336(pA0), ra0
 
1150
           #endif
 
1151
           vfmaddps rC10, rA1, rB0, rC10
 
1152
           #if KB > 116
 
1153
              movaps 336(pA0,lda), ra1
 
1154
           #endif
 
1155
           vfmaddps rC01, rA0, rB1, rC01
 
1156
           #if KB > 116
 
1157
              movaps 336(pB0), rB0
 
1158
           #elif KB == 116 && defined(BETA1)
 
1159
           #endif
 
1160
           vfmaddps rC11, rA1, rB1, rC11
 
1161
           #if KB > 116
 
1162
              movaps 336(pB0,ldb), rB1
 
1163
           #elif KB == 116 && defined(BETA1)
 
1164
           #endif
 
1165
           vfmaddps rC02, rA0, rB2, rC02
 
1166
           #if KB == 116 && defined(BETA0)
 
1167
           #endif
 
1168
           vfmaddps rC12, rA1, rB2, rC12
 
1169
           #if KB > 116
 
1170
              movaps 336(pB0,ldb,2), rB2
 
1171
           #elif KB == 116 && defined(BETA1)
 
1172
           #endif
 
1173
           vfmaddps rC03, rA0, rB3, rC03
 
1174
           #if KB == 116 && defined(BETA1)
 
1175
           #endif
 
1176
           vfmaddps rC13, rA1, rB3, rC13
 
1177
           #if KB > 116
 
1178
              movaps 336(pB0,ldb3), rB3
 
1179
           #elif KB == 116 && defined(BETA0)
 
1180
           #endif
 
1181
        #endif
 
1182
        #if KB > 116
 
1183
           vfmaddps rC00, ra0, rB0, rC00
 
1184
           #if KB > 120
 
1185
              movaps 352(pA0), rA0
 
1186
           #endif
 
1187
           vfmaddps rC10, ra1, rB0, rC10
 
1188
           #if KB > 120
 
1189
              movaps 352(pA0,lda), rA1
 
1190
           #endif
 
1191
           vfmaddps rC01, ra0, rB1, rC01
 
1192
           #if KB > 120
 
1193
              movaps 352(pB0), rB0
 
1194
           #elif KB == 120 && defined(BETA1)
 
1195
           #endif
 
1196
           vfmaddps rC11, ra1, rB1, rC11
 
1197
           #if KB > 120
 
1198
              movaps 352(pB0,ldb), rB1
 
1199
           #elif KB == 120 && defined(BETA1)
 
1200
           #endif
 
1201
           vfmaddps rC02, ra0, rB2, rC02
 
1202
           #if KB == 120 && defined(BETA1)
 
1203
           #endif
 
1204
           vfmaddps rC12, ra1, rB2, rC12
 
1205
           #if KB > 120
 
1206
              movaps 352(pB0,ldb,2), rB2
 
1207
           #elif KB == 120 && defined(BETA1)
 
1208
           #endif
 
1209
           vfmaddps rC03, ra0, rB3, rC03
 
1210
           #if KB == 120 && defined(BETA1)
 
1211
           #endif
 
1212
           vfmaddps rC13, ra1, rB3, rC13
 
1213
           #if KB > 120
 
1214
              movaps 352(pB0,ldb3), rB3
 
1215
           #elif KB == 120 && defined(BETA1)
 
1216
           #endif
 
1217
        #endif
 
1218
        #if KB > 120
 
1219
           vfmaddps rC00, rA0, rB0, rC00
 
1220
           #if KB > 124
 
1221
              movaps 368(pA0), ra0
 
1222
           #endif
 
1223
           vfmaddps rC10, rA1, rB0, rC10
 
1224
           #if KB > 124
 
1225
              movaps 368(pA0,lda), ra1
 
1226
           #endif
 
1227
           vfmaddps rC01, rA0, rB1, rC01
 
1228
           #if KB > 124
 
1229
              movaps 368(pB0), rB0
 
1230
           #elif KB == 124 && defined(BETA1)
 
1231
           #endif
 
1232
           vfmaddps rC11, rA1, rB1, rC11
 
1233
           #if KB > 124
 
1234
              movaps 368(pB0,ldb), rB1
 
1235
           #elif KB == 124 && defined(BETA1)
 
1236
           #endif
 
1237
           vfmaddps rC02, rA0, rB2, rC02
 
1238
           #if KB == 124 && defined(BETA0)
 
1239
           #endif
 
1240
           vfmaddps rC12, rA1, rB2, rC12
 
1241
           #if KB > 124
 
1242
              movaps 368(pB0,ldb,2), rB2
 
1243
           #elif KB == 124 && defined(BETA1)
 
1244
           #endif
 
1245
           vfmaddps rC03, rA0, rB3, rC03
 
1246
           #if KB == 124 && defined(BETA1)
 
1247
           #endif
 
1248
           vfmaddps rC13, rA1, rB3, rC13
 
1249
           #if KB > 124
 
1250
              movaps 368(pB0,ldb3), rB3
 
1251
           #elif KB == 124 && defined(BETA0)
 
1252
           #endif
 
1253
        #endif
 
1254
        #if KB > 124
 
1255
           vfmaddps rC00, ra0, rB0, rC00
 
1256
           #if KB > 128
 
1257
              movaps 384(pA0), rA0
 
1258
           #endif
 
1259
           vfmaddps rC10, ra1, rB0, rC10
 
1260
           #if KB > 128
 
1261
              movaps 384(pA0,lda), rA1
 
1262
           #endif
 
1263
           vfmaddps rC01, ra0, rB1, rC01
 
1264
           #if KB > 128
 
1265
              movaps 384(pB0), rB0
 
1266
           #elif KB == 128 && defined(BETA1)
 
1267
           #endif
 
1268
           vfmaddps rC11, ra1, rB1, rC11
 
1269
           #if KB > 128
 
1270
              movaps 384(pB0,ldb), rB1
 
1271
           #elif KB == 128 && defined(BETA1)
 
1272
           #endif
 
1273
           vfmaddps rC02, ra0, rB2, rC02
 
1274
           #if KB == 128 && defined(BETA1)
 
1275
           #endif
 
1276
           vfmaddps rC12, ra1, rB2, rC12
 
1277
           #if KB > 128
 
1278
              movaps 384(pB0,ldb,2), rB2
 
1279
           #elif KB == 128 && defined(BETA1)
 
1280
           #endif
 
1281
           vfmaddps rC03, ra0, rB3, rC03
 
1282
           #if KB == 128 && defined(BETA1)
 
1283
           #endif
 
1284
           vfmaddps rC13, ra1, rB3, rC13
 
1285
           #if KB > 128
 
1286
              movaps 384(pB0,ldb3), rB3
 
1287
           #elif KB == 128 && defined(BETA1)
 
1288
           #endif
 
1289
        #endif
 
1290
        #if KB > 128
 
1291
           vfmaddps rC00, rA0, rB0, rC00
 
1292
           #if KB > 132
 
1293
              movaps 400(pA0), ra0
 
1294
           #endif
 
1295
           vfmaddps rC10, rA1, rB0, rC10
 
1296
           #if KB > 132
 
1297
              movaps 400(pA0,lda), ra1
 
1298
           #endif
 
1299
           vfmaddps rC01, rA0, rB1, rC01
 
1300
           #if KB > 132
 
1301
              movaps 400(pB0), rB0
 
1302
           #elif KB == 132 && defined(BETA1)
 
1303
           #endif
 
1304
           vfmaddps rC11, rA1, rB1, rC11
 
1305
           #if KB > 132
 
1306
              movaps 400(pB0,ldb), rB1
 
1307
           #elif KB == 132 && defined(BETA1)
 
1308
           #endif
 
1309
           vfmaddps rC02, rA0, rB2, rC02
 
1310
           #if KB == 132 && defined(BETA0)
 
1311
           #endif
 
1312
           vfmaddps rC12, rA1, rB2, rC12
 
1313
           #if KB > 132
 
1314
              movaps 400(pB0,ldb,2), rB2
 
1315
           #elif KB == 132 && defined(BETA1)
 
1316
           #endif
 
1317
           vfmaddps rC03, rA0, rB3, rC03
 
1318
           #if KB == 132 && defined(BETA1)
 
1319
           #endif
 
1320
           vfmaddps rC13, rA1, rB3, rC13
 
1321
           #if KB > 132
 
1322
              movaps 400(pB0,ldb3), rB3
 
1323
           #elif KB == 132 && defined(BETA0)
 
1324
           #endif
 
1325
        #endif
 
1326
        #if KB > 132
 
1327
           vfmaddps rC00, ra0, rB0, rC00
 
1328
           #if KB > 136
 
1329
              movaps 416(pA0), rA0
 
1330
           #endif
 
1331
           vfmaddps rC10, ra1, rB0, rC10
 
1332
           #if KB > 136
 
1333
              movaps 416(pA0,lda), rA1
 
1334
           #endif
 
1335
           vfmaddps rC01, ra0, rB1, rC01
 
1336
           #if KB > 136
 
1337
              movaps 416(pB0), rB0
 
1338
           #elif KB == 136 && defined(BETA1)
 
1339
           #endif
 
1340
           vfmaddps rC11, ra1, rB1, rC11
 
1341
           #if KB > 136
 
1342
              movaps 416(pB0,ldb), rB1
 
1343
           #elif KB == 136 && defined(BETA1)
 
1344
           #endif
 
1345
           vfmaddps rC02, ra0, rB2, rC02
 
1346
           #if KB == 136 && defined(BETA1)
 
1347
           #endif
 
1348
           vfmaddps rC12, ra1, rB2, rC12
 
1349
           #if KB > 136
 
1350
              movaps 416(pB0,ldb,2), rB2
 
1351
           #elif KB == 136 && defined(BETA1)
 
1352
           #endif
 
1353
           vfmaddps rC03, ra0, rB3, rC03
 
1354
           #if KB == 136 && defined(BETA1)
 
1355
           #endif
 
1356
           vfmaddps rC13, ra1, rB3, rC13
 
1357
           #if KB > 136
 
1358
              movaps 416(pB0,ldb3), rB3
 
1359
           #elif KB == 136 && defined(BETA1)
 
1360
           #endif
 
1361
        #endif
 
1362
        #if KB > 136
 
1363
           vfmaddps rC00, rA0, rB0, rC00
 
1364
           #if KB > 140
 
1365
              movaps 432(pA0), ra0
 
1366
           #endif
 
1367
           vfmaddps rC10, rA1, rB0, rC10
 
1368
           #if KB > 140
 
1369
              movaps 432(pA0,lda), ra1
 
1370
           #endif
 
1371
           vfmaddps rC01, rA0, rB1, rC01
 
1372
           #if KB > 140
 
1373
              movaps 432(pB0), rB0
 
1374
           #elif KB == 140 && defined(BETA1)
 
1375
           #endif
 
1376
           vfmaddps rC11, rA1, rB1, rC11
 
1377
           #if KB > 140
 
1378
              movaps 432(pB0,ldb), rB1
 
1379
           #elif KB == 140 && defined(BETA1)
 
1380
           #endif
 
1381
           vfmaddps rC02, rA0, rB2, rC02
 
1382
           #if KB == 140 && defined(BETA0)
 
1383
           #endif
 
1384
           vfmaddps rC12, rA1, rB2, rC12
 
1385
           #if KB > 140
 
1386
              movaps 432(pB0,ldb,2), rB2
 
1387
           #elif KB == 140 && defined(BETA1)
 
1388
           #endif
 
1389
           vfmaddps rC03, rA0, rB3, rC03
 
1390
           #if KB == 140 && defined(BETA1)
 
1391
           #endif
 
1392
           vfmaddps rC13, rA1, rB3, rC13
 
1393
           #if KB > 140
 
1394
              movaps 432(pB0,ldb3), rB3
 
1395
           #elif KB == 140 && defined(BETA0)
 
1396
           #endif
 
1397
        #endif
 
1398
        #if KB > 140
 
1399
           vfmaddps rC00, ra0, rB0, rC00
 
1400
           #if KB > 144
 
1401
              movaps 448(pA0), rA0
 
1402
           #endif
 
1403
           vfmaddps rC10, ra1, rB0, rC10
 
1404
           #if KB > 144
 
1405
              movaps 448(pA0,lda), rA1
 
1406
           #endif
 
1407
           vfmaddps rC01, ra0, rB1, rC01
 
1408
           #if KB > 144
 
1409
              movaps 448(pB0), rB0
 
1410
           #elif KB == 144 && defined(BETA1)
 
1411
           #endif
 
1412
           vfmaddps rC11, ra1, rB1, rC11
 
1413
           #if KB > 144
 
1414
              movaps 448(pB0,ldb), rB1
 
1415
           #elif KB == 144 && defined(BETA1)
 
1416
           #endif
 
1417
           vfmaddps rC02, ra0, rB2, rC02
 
1418
           #if KB == 144 && defined(BETA1)
 
1419
           #endif
 
1420
           vfmaddps rC12, ra1, rB2, rC12
 
1421
           #if KB > 144
 
1422
              movaps 448(pB0,ldb,2), rB2
 
1423
           #elif KB == 144 && defined(BETA1)
 
1424
           #endif
 
1425
           vfmaddps rC03, ra0, rB3, rC03
 
1426
           #if KB == 144 && defined(BETA1)
 
1427
           #endif
 
1428
           vfmaddps rC13, ra1, rB3, rC13
 
1429
           #if KB > 144
 
1430
              movaps 448(pB0,ldb3), rB3
 
1431
           #elif KB == 144 && defined(BETA1)
 
1432
           #endif
 
1433
        #endif
 
1434
        #if KB > 144
 
1435
           vfmaddps rC00, rA0, rB0, rC00
 
1436
           #if KB > 148
 
1437
              movaps 464(pA0), ra0
 
1438
           #endif
 
1439
           vfmaddps rC10, rA1, rB0, rC10
 
1440
           #if KB > 148
 
1441
              movaps 464(pA0,lda), ra1
 
1442
           #endif
 
1443
           vfmaddps rC01, rA0, rB1, rC01
 
1444
           #if KB > 148
 
1445
              movaps 464(pB0), rB0
 
1446
           #elif KB == 148 && defined(BETA1)
 
1447
           #endif
 
1448
           vfmaddps rC11, rA1, rB1, rC11
 
1449
           #if KB > 148
 
1450
              movaps 464(pB0,ldb), rB1
 
1451
           #elif KB == 148 && defined(BETA1)
 
1452
           #endif
 
1453
           vfmaddps rC02, rA0, rB2, rC02
 
1454
           #if KB == 148 && defined(BETA0)
 
1455
           #endif
 
1456
           vfmaddps rC12, rA1, rB2, rC12
 
1457
           #if KB > 148
 
1458
              movaps 464(pB0,ldb,2), rB2
 
1459
           #elif KB == 148 && defined(BETA1)
 
1460
           #endif
 
1461
           vfmaddps rC03, rA0, rB3, rC03
 
1462
           #if KB == 148 && defined(BETA1)
 
1463
           #endif
 
1464
           vfmaddps rC13, rA1, rB3, rC13
 
1465
           #if KB > 148
 
1466
              movaps 464(pB0,ldb3), rB3
 
1467
           #elif KB == 148 && defined(BETA0)
 
1468
           #endif
 
1469
        #endif
 
1470
        #if KB > 148
 
1471
           vfmaddps rC00, ra0, rB0, rC00
 
1472
           #if KB > 152
 
1473
              movaps 480(pA0), rA0
 
1474
           #endif
 
1475
           vfmaddps rC10, ra1, rB0, rC10
 
1476
           #if KB > 152
 
1477
              movaps 480(pA0,lda), rA1
 
1478
           #endif
 
1479
           vfmaddps rC01, ra0, rB1, rC01
 
1480
           #if KB > 152
 
1481
              movaps 480(pB0), rB0
 
1482
           #elif KB == 152 && defined(BETA1)
 
1483
           #endif
 
1484
           vfmaddps rC11, ra1, rB1, rC11
 
1485
           #if KB > 152
 
1486
              movaps 480(pB0,ldb), rB1
 
1487
           #elif KB == 152 && defined(BETA1)
 
1488
           #endif
 
1489
           vfmaddps rC02, ra0, rB2, rC02
 
1490
           #if KB == 152 && defined(BETA1)
 
1491
           #endif
 
1492
           vfmaddps rC12, ra1, rB2, rC12
 
1493
           #if KB > 152
 
1494
              movaps 480(pB0,ldb,2), rB2
 
1495
           #elif KB == 152 && defined(BETA1)
 
1496
           #endif
 
1497
           vfmaddps rC03, ra0, rB3, rC03
 
1498
           #if KB == 152 && defined(BETA1)
 
1499
           #endif
 
1500
           vfmaddps rC13, ra1, rB3, rC13
 
1501
           #if KB > 152
 
1502
              movaps 480(pB0,ldb3), rB3
 
1503
           #elif KB == 152 && defined(BETA1)
 
1504
           #endif
 
1505
        #endif
 
1506
        #if KB > 152
 
1507
           vfmaddps rC00, rA0, rB0, rC00
 
1508
           #if KB > 156
 
1509
              movaps 496(pA0), ra0
 
1510
           #endif
 
1511
           vfmaddps rC10, rA1, rB0, rC10
 
1512
           #if KB > 156
 
1513
              movaps 496(pA0,lda), ra1
 
1514
           #endif
 
1515
           vfmaddps rC01, rA0, rB1, rC01
 
1516
           #if KB > 156
 
1517
              movaps 496(pB0), rB0
 
1518
           #elif KB == 156 && defined(BETA1)
 
1519
           #endif
 
1520
           vfmaddps rC11, rA1, rB1, rC11
 
1521
           #if KB > 156
 
1522
              movaps 496(pB0,ldb), rB1
 
1523
           #elif KB == 156 && defined(BETA1)
 
1524
           #endif
 
1525
           vfmaddps rC02, rA0, rB2, rC02
 
1526
           #if KB == 156 && defined(BETA0)
 
1527
           #endif
 
1528
           vfmaddps rC12, rA1, rB2, rC12
 
1529
           #if KB > 156
 
1530
              movaps 496(pB0,ldb,2), rB2
 
1531
           #elif KB == 156 && defined(BETA1)
 
1532
           #endif
 
1533
           vfmaddps rC03, rA0, rB3, rC03
 
1534
           #if KB == 156 && defined(BETA1)
 
1535
           #endif
 
1536
           vfmaddps rC13, rA1, rB3, rC13
 
1537
           #if KB > 156
 
1538
              movaps 496(pB0,ldb3), rB3
 
1539
           #elif KB == 156 && defined(BETA0)
 
1540
           #endif
 
1541
        #endif
 
1542
        #if KB > 156
 
1543
           vfmaddps rC00, ra0, rB0, rC00
 
1544
           #if KB > 160
 
1545
              movaps 512(pA0), rA0
 
1546
           #endif
 
1547
           vfmaddps rC10, ra1, rB0, rC10
 
1548
           #if KB > 160
 
1549
              movaps 512(pA0,lda), rA1
 
1550
           #endif
 
1551
           vfmaddps rC01, ra0, rB1, rC01
 
1552
           #if KB > 160
 
1553
              movaps 512(pB0), rB0
 
1554
           #elif KB == 160 && defined(BETA1)
 
1555
           #endif
 
1556
           vfmaddps rC11, ra1, rB1, rC11
 
1557
           #if KB > 160
 
1558
              movaps 512(pB0,ldb), rB1
 
1559
           #elif KB == 160 && defined(BETA1)
 
1560
           #endif
 
1561
           vfmaddps rC02, ra0, rB2, rC02
 
1562
           #if KB == 160 && defined(BETA1)
 
1563
           #endif
 
1564
           vfmaddps rC12, ra1, rB2, rC12
 
1565
           #if KB > 160
 
1566
              movaps 512(pB0,ldb,2), rB2
 
1567
           #elif KB == 160 && defined(BETA1)
 
1568
           #endif
 
1569
           vfmaddps rC03, ra0, rB3, rC03
 
1570
           #if KB == 160 && defined(BETA1)
 
1571
           #endif
 
1572
           vfmaddps rC13, ra1, rB3, rC13
 
1573
           #if KB > 160
 
1574
              movaps 512(pB0,ldb3), rB3
 
1575
           #elif KB == 160 && defined(BETA1)
 
1576
           #endif
 
1577
        #endif
 
1578
        #if KB > 160
 
1579
           vfmaddps rC00, rA0, rB0, rC00
 
1580
           #if KB > 164
 
1581
              movaps 528(pA0), ra0
 
1582
           #endif
 
1583
           vfmaddps rC10, rA1, rB0, rC10
 
1584
           #if KB > 164
 
1585
              movaps 528(pA0,lda), ra1
 
1586
           #endif
 
1587
           vfmaddps rC01, rA0, rB1, rC01
 
1588
           #if KB > 164
 
1589
              movaps 528(pB0), rB0
 
1590
           #elif KB == 164 && defined(BETA1)
 
1591
           #endif
 
1592
           vfmaddps rC11, rA1, rB1, rC11
 
1593
           #if KB > 164
 
1594
              movaps 528(pB0,ldb), rB1
 
1595
           #elif KB == 164 && defined(BETA1)
 
1596
           #endif
 
1597
           vfmaddps rC02, rA0, rB2, rC02
 
1598
           #if KB == 164 && defined(BETA0)
 
1599
           #endif
 
1600
           vfmaddps rC12, rA1, rB2, rC12
 
1601
           #if KB > 164
 
1602
              movaps 528(pB0,ldb,2), rB2
 
1603
           #elif KB == 164 && defined(BETA1)
 
1604
           #endif
 
1605
           vfmaddps rC03, rA0, rB3, rC03
 
1606
           #if KB == 164 && defined(BETA1)
 
1607
           #endif
 
1608
           vfmaddps rC13, rA1, rB3, rC13
 
1609
           #if KB > 164
 
1610
              movaps 528(pB0,ldb3), rB3
 
1611
           #elif KB == 164 && defined(BETA0)
 
1612
           #endif
 
1613
        #endif
 
1614
        #if KB > 164
 
1615
           vfmaddps rC00, ra0, rB0, rC00
 
1616
           #if KB > 168
 
1617
              movaps 544(pA0), rA0
 
1618
           #endif
 
1619
           vfmaddps rC10, ra1, rB0, rC10
 
1620
           #if KB > 168
 
1621
              movaps 544(pA0,lda), rA1
 
1622
           #endif
 
1623
           vfmaddps rC01, ra0, rB1, rC01
 
1624
           #if KB > 168
 
1625
              movaps 544(pB0), rB0
 
1626
           #elif KB == 168 && defined(BETA1)
 
1627
           #endif
 
1628
           vfmaddps rC11, ra1, rB1, rC11
 
1629
           #if KB > 168
 
1630
              movaps 544(pB0,ldb), rB1
 
1631
           #elif KB == 168 && defined(BETA1)
 
1632
           #endif
 
1633
           vfmaddps rC02, ra0, rB2, rC02
 
1634
           #if KB == 168 && defined(BETA1)
 
1635
           #endif
 
1636
           vfmaddps rC12, ra1, rB2, rC12
 
1637
           #if KB > 168
 
1638
              movaps 544(pB0,ldb,2), rB2
 
1639
           #elif KB == 168 && defined(BETA1)
 
1640
           #endif
 
1641
           vfmaddps rC03, ra0, rB3, rC03
 
1642
           #if KB == 168 && defined(BETA1)
 
1643
           #endif
 
1644
           vfmaddps rC13, ra1, rB3, rC13
 
1645
           #if KB > 168
 
1646
              movaps 544(pB0,ldb3), rB3
 
1647
           #elif KB == 168 && defined(BETA1)
 
1648
           #endif
 
1649
        #endif
 
1650
        #if KB > 168
 
1651
           vfmaddps rC00, rA0, rB0, rC00
 
1652
           #if KB > 172
 
1653
              movaps 560(pA0), ra0
 
1654
           #endif
 
1655
           vfmaddps rC10, rA1, rB0, rC10
 
1656
           #if KB > 172
 
1657
              movaps 560(pA0,lda), ra1
 
1658
           #endif
 
1659
           vfmaddps rC01, rA0, rB1, rC01
 
1660
           #if KB > 172
 
1661
              movaps 560(pB0), rB0
 
1662
           #elif KB == 172 && defined(BETA1)
 
1663
           #endif
 
1664
           vfmaddps rC11, rA1, rB1, rC11
 
1665
           #if KB > 172
 
1666
              movaps 560(pB0,ldb), rB1
 
1667
           #elif KB == 172 && defined(BETA1)
 
1668
           #endif
 
1669
           vfmaddps rC02, rA0, rB2, rC02
 
1670
           #if KB == 172 && defined(BETA0)
 
1671
           #endif
 
1672
           vfmaddps rC12, rA1, rB2, rC12
 
1673
           #if KB > 172
 
1674
              movaps 560(pB0,ldb,2), rB2
 
1675
           #elif KB == 172 && defined(BETA1)
 
1676
           #endif
 
1677
           vfmaddps rC03, rA0, rB3, rC03
 
1678
           #if KB == 172 && defined(BETA1)
 
1679
           #endif
 
1680
           vfmaddps rC13, rA1, rB3, rC13
 
1681
           #if KB > 172
 
1682
              movaps 560(pB0,ldb3), rB3
 
1683
           #elif KB == 172 && defined(BETA0)
 
1684
           #endif
 
1685
        #endif
 
1686
        #if KB > 172
 
1687
           vfmaddps rC00, ra0, rB0, rC00
 
1688
           #if KB > 176
 
1689
              movaps 576(pA0), rA0
 
1690
           #endif
 
1691
           vfmaddps rC10, ra1, rB0, rC10
 
1692
           #if KB > 176
 
1693
              movaps 576(pA0,lda), rA1
 
1694
           #endif
 
1695
           vfmaddps rC01, ra0, rB1, rC01
 
1696
           #if KB > 176
 
1697
              movaps 576(pB0), rB0
 
1698
           #elif KB == 176 && defined(BETA1)
 
1699
           #endif
 
1700
           vfmaddps rC11, ra1, rB1, rC11
 
1701
           #if KB > 176
 
1702
              movaps 576(pB0,ldb), rB1
 
1703
           #elif KB == 176 && defined(BETA1)
 
1704
           #endif
 
1705
           vfmaddps rC02, ra0, rB2, rC02
 
1706
           #if KB == 176 && defined(BETA1)
 
1707
           #endif
 
1708
           vfmaddps rC12, ra1, rB2, rC12
 
1709
           #if KB > 176
 
1710
              movaps 576(pB0,ldb,2), rB2
 
1711
           #elif KB == 176 && defined(BETA1)
 
1712
           #endif
 
1713
           vfmaddps rC03, ra0, rB3, rC03
 
1714
           #if KB == 176 && defined(BETA1)
 
1715
           #endif
 
1716
           vfmaddps rC13, ra1, rB3, rC13
 
1717
           #if KB > 176
 
1718
              movaps 576(pB0,ldb3), rB3
 
1719
           #elif KB == 176 && defined(BETA1)
 
1720
           #endif
 
1721
        #endif
 
1722
        #if KB > 176
 
1723
           vfmaddps rC00, rA0, rB0, rC00
 
1724
           #if KB > 180
 
1725
              movaps 592(pA0), ra0
 
1726
           #endif
 
1727
           vfmaddps rC10, rA1, rB0, rC10
 
1728
           #if KB > 180
 
1729
              movaps 592(pA0,lda), ra1
 
1730
           #endif
 
1731
           vfmaddps rC01, rA0, rB1, rC01
 
1732
           #if KB > 180
 
1733
              movaps 592(pB0), rB0
 
1734
           #elif KB == 180 && defined(BETA1)
 
1735
           #endif
 
1736
           vfmaddps rC11, rA1, rB1, rC11
 
1737
           #if KB > 180
 
1738
              movaps 592(pB0,ldb), rB1
 
1739
           #elif KB == 180 && defined(BETA1)
 
1740
           #endif
 
1741
           vfmaddps rC02, rA0, rB2, rC02
 
1742
           #if KB == 180 && defined(BETA0)
 
1743
           #endif
 
1744
           vfmaddps rC12, rA1, rB2, rC12
 
1745
           #if KB > 180
 
1746
              movaps 592(pB0,ldb,2), rB2
 
1747
           #elif KB == 180 && defined(BETA1)
 
1748
           #endif
 
1749
           vfmaddps rC03, rA0, rB3, rC03
 
1750
           #if KB == 180 && defined(BETA1)
 
1751
           #endif
 
1752
           vfmaddps rC13, rA1, rB3, rC13
 
1753
           #if KB > 180
 
1754
              movaps 592(pB0,ldb3), rB3
 
1755
           #elif KB == 180 && defined(BETA0)
 
1756
           #endif
 
1757
        #endif
 
1758
        #if KB > 180
 
1759
           vfmaddps rC00, ra0, rB0, rC00
 
1760
           #if KB > 184
 
1761
              movaps 608(pA0), rA0
 
1762
           #endif
 
1763
           vfmaddps rC10, ra1, rB0, rC10
 
1764
           #if KB > 184
 
1765
              movaps 608(pA0,lda), rA1
 
1766
           #endif
 
1767
           vfmaddps rC01, ra0, rB1, rC01
 
1768
           #if KB > 184
 
1769
              movaps 608(pB0), rB0
 
1770
           #elif KB == 184 && defined(BETA1)
 
1771
           #endif
 
1772
           vfmaddps rC11, ra1, rB1, rC11
 
1773
           #if KB > 184
 
1774
              movaps 608(pB0,ldb), rB1
 
1775
           #elif KB == 184 && defined(BETA1)
 
1776
           #endif
 
1777
           vfmaddps rC02, ra0, rB2, rC02
 
1778
           #if KB == 184 && defined(BETA1)
 
1779
           #endif
 
1780
           vfmaddps rC12, ra1, rB2, rC12
 
1781
           #if KB > 184
 
1782
              movaps 608(pB0,ldb,2), rB2
 
1783
           #elif KB == 184 && defined(BETA1)
 
1784
           #endif
 
1785
           vfmaddps rC03, ra0, rB3, rC03
 
1786
           #if KB == 184 && defined(BETA1)
 
1787
           #endif
 
1788
           vfmaddps rC13, ra1, rB3, rC13
 
1789
           #if KB > 184
 
1790
              movaps 608(pB0,ldb3), rB3
 
1791
           #elif KB == 184 && defined(BETA1)
 
1792
           #endif
 
1793
        #endif
 
1794
        #if KB > 184
 
1795
           vfmaddps rC00, rA0, rB0, rC00
 
1796
           #if KB > 188
 
1797
              movaps 624(pA0), ra0
 
1798
           #endif
 
1799
           vfmaddps rC10, rA1, rB0, rC10
 
1800
           #if KB > 188
 
1801
              movaps 624(pA0,lda), ra1
 
1802
           #endif
 
1803
           vfmaddps rC01, rA0, rB1, rC01
 
1804
           #if KB > 188
 
1805
              movaps 624(pB0), rB0
 
1806
           #elif KB == 188 && defined(BETA1)
 
1807
           #endif
 
1808
           vfmaddps rC11, rA1, rB1, rC11
 
1809
           #if KB > 188
 
1810
              movaps 624(pB0,ldb), rB1
 
1811
           #elif KB == 188 && defined(BETA1)
 
1812
           #endif
 
1813
           vfmaddps rC02, rA0, rB2, rC02
 
1814
           #if KB == 188 && defined(BETA0)
 
1815
           #endif
 
1816
           vfmaddps rC12, rA1, rB2, rC12
 
1817
           #if KB > 188
 
1818
              movaps 624(pB0,ldb,2), rB2
 
1819
           #elif KB == 188 && defined(BETA1)
 
1820
           #endif
 
1821
           vfmaddps rC03, rA0, rB3, rC03
 
1822
           #if KB == 188 && defined(BETA1)
 
1823
           #endif
 
1824
           vfmaddps rC13, rA1, rB3, rC13
 
1825
           #if KB > 188
 
1826
              movaps 624(pB0,ldb3), rB3
 
1827
           #elif KB == 188 && defined(BETA0)
 
1828
           #endif
 
1829
        #endif
 
1830
        #if KB > 188
 
1831
           vfmaddps rC00, ra0, rB0, rC00
 
1832
           #if KB > 192
 
1833
              movaps 640(pA0), rA0
 
1834
           #endif
 
1835
           vfmaddps rC10, ra1, rB0, rC10
 
1836
           #if KB > 192
 
1837
              movaps 640(pA0,lda), rA1
 
1838
           #endif
 
1839
           vfmaddps rC01, ra0, rB1, rC01
 
1840
           #if KB > 192
 
1841
              movaps 640(pB0), rB0
 
1842
           #elif KB == 192 && defined(BETA1)
 
1843
           #endif
 
1844
           vfmaddps rC11, ra1, rB1, rC11
 
1845
           #if KB > 192
 
1846
              movaps 640(pB0,ldb), rB1
 
1847
           #elif KB == 192 && defined(BETA1)
 
1848
           #endif
 
1849
           vfmaddps rC02, ra0, rB2, rC02
 
1850
           #if KB == 192 && defined(BETA1)
 
1851
           #endif
 
1852
           vfmaddps rC12, ra1, rB2, rC12
 
1853
           #if KB > 192
 
1854
              movaps 640(pB0,ldb,2), rB2
 
1855
           #elif KB == 192 && defined(BETA1)
 
1856
           #endif
 
1857
           vfmaddps rC03, ra0, rB3, rC03
 
1858
           #if KB == 192 && defined(BETA1)
 
1859
           #endif
 
1860
           vfmaddps rC13, ra1, rB3, rC13
 
1861
           #if KB > 192
 
1862
              movaps 640(pB0,ldb3), rB3
 
1863
           #elif KB == 192 && defined(BETA1)
 
1864
           #endif
 
1865
        #endif
 
1866
        #if KB > 192
 
1867
           vfmaddps rC00, rA0, rB0, rC00
 
1868
           #if KB > 196
 
1869
              movaps 656(pA0), ra0
 
1870
           #endif
 
1871
           vfmaddps rC10, rA1, rB0, rC10
 
1872
           #if KB > 196
 
1873
              movaps 656(pA0,lda), ra1
 
1874
           #endif
 
1875
           vfmaddps rC01, rA0, rB1, rC01
 
1876
           #if KB > 196
 
1877
              movaps 656(pB0), rB0
 
1878
           #elif KB == 196 && defined(BETA1)
 
1879
           #endif
 
1880
           vfmaddps rC11, rA1, rB1, rC11
 
1881
           #if KB > 196
 
1882
              movaps 656(pB0,ldb), rB1
 
1883
           #elif KB == 196 && defined(BETA1)
 
1884
           #endif
 
1885
           vfmaddps rC02, rA0, rB2, rC02
 
1886
           #if KB == 196 && defined(BETA0)
 
1887
           #endif
 
1888
           vfmaddps rC12, rA1, rB2, rC12
 
1889
           #if KB > 196
 
1890
              movaps 656(pB0,ldb,2), rB2
 
1891
           #elif KB == 196 && defined(BETA1)
 
1892
           #endif
 
1893
           vfmaddps rC03, rA0, rB3, rC03
 
1894
           #if KB == 196 && defined(BETA1)
 
1895
           #endif
 
1896
           vfmaddps rC13, rA1, rB3, rC13
 
1897
           #if KB > 196
 
1898
              movaps 656(pB0,ldb3), rB3
 
1899
           #elif KB == 196 && defined(BETA0)
 
1900
           #endif
 
1901
        #endif
 
1902
        #if KB > 196
 
1903
           vfmaddps rC00, ra0, rB0, rC00
 
1904
           #if KB > 200
 
1905
              movaps 672(pA0), rA0
 
1906
           #endif
 
1907
           vfmaddps rC10, ra1, rB0, rC10
 
1908
           #if KB > 200
 
1909
              movaps 672(pA0,lda), rA1
 
1910
           #endif
 
1911
           vfmaddps rC01, ra0, rB1, rC01
 
1912
           #if KB > 200
 
1913
              movaps 672(pB0), rB0
 
1914
           #elif KB == 200 && defined(BETA1)
 
1915
           #endif
 
1916
           vfmaddps rC11, ra1, rB1, rC11
 
1917
           #if KB > 200
 
1918
              movaps 672(pB0,ldb), rB1
 
1919
           #elif KB == 200 && defined(BETA1)
 
1920
           #endif
 
1921
           vfmaddps rC02, ra0, rB2, rC02
 
1922
           #if KB == 200 && defined(BETA1)
 
1923
           #endif
 
1924
           vfmaddps rC12, ra1, rB2, rC12
 
1925
           #if KB > 200
 
1926
              movaps 672(pB0,ldb,2), rB2
 
1927
           #elif KB == 200 && defined(BETA1)
 
1928
           #endif
 
1929
           vfmaddps rC03, ra0, rB3, rC03
 
1930
           #if KB == 200 && defined(BETA1)
 
1931
           #endif
 
1932
           vfmaddps rC13, ra1, rB3, rC13
 
1933
           #if KB > 200
 
1934
              movaps 672(pB0,ldb3), rB3
 
1935
           #elif KB == 200 && defined(BETA1)
 
1936
           #endif
 
1937
        #endif
 
1938
        #if KB > 200
 
1939
           vfmaddps rC00, rA0, rB0, rC00
 
1940
           #if KB > 204
 
1941
              movaps 688(pA0), ra0
 
1942
           #endif
 
1943
           vfmaddps rC10, rA1, rB0, rC10
 
1944
           #if KB > 204
 
1945
              movaps 688(pA0,lda), ra1
 
1946
           #endif
 
1947
           vfmaddps rC01, rA0, rB1, rC01
 
1948
           #if KB > 204
 
1949
              movaps 688(pB0), rB0
 
1950
           #elif KB == 204 && defined(BETA1)
 
1951
           #endif
 
1952
           vfmaddps rC11, rA1, rB1, rC11
 
1953
           #if KB > 204
 
1954
              movaps 688(pB0,ldb), rB1
 
1955
           #elif KB == 204 && defined(BETA1)
 
1956
           #endif
 
1957
           vfmaddps rC02, rA0, rB2, rC02
 
1958
           #if KB == 204 && defined(BETA0)
 
1959
           #endif
 
1960
           vfmaddps rC12, rA1, rB2, rC12
 
1961
           #if KB > 204
 
1962
              movaps 688(pB0,ldb,2), rB2
 
1963
           #elif KB == 204 && defined(BETA1)
 
1964
           #endif
 
1965
           vfmaddps rC03, rA0, rB3, rC03
 
1966
           #if KB == 204 && defined(BETA1)
 
1967
           #endif
 
1968
           vfmaddps rC13, rA1, rB3, rC13
 
1969
           #if KB > 204
 
1970
              movaps 688(pB0,ldb3), rB3
 
1971
           #elif KB == 204 && defined(BETA0)
 
1972
           #endif
 
1973
        #endif
 
1974
        #if KB > 204
 
1975
           vfmaddps rC00, ra0, rB0, rC00
 
1976
           #if KB > 208
 
1977
              movaps 704(pA0), rA0
 
1978
           #endif
 
1979
           vfmaddps rC10, ra1, rB0, rC10
 
1980
           #if KB > 208
 
1981
              movaps 704(pA0,lda), rA1
 
1982
           #endif
 
1983
           vfmaddps rC01, ra0, rB1, rC01
 
1984
           #if KB > 208
 
1985
              movaps 704(pB0), rB0
 
1986
           #elif KB == 208 && defined(BETA1)
 
1987
           #endif
 
1988
           vfmaddps rC11, ra1, rB1, rC11
 
1989
           #if KB > 208
 
1990
              movaps 704(pB0,ldb), rB1
 
1991
           #elif KB == 208 && defined(BETA1)
 
1992
           #endif
 
1993
           vfmaddps rC02, ra0, rB2, rC02
 
1994
           #if KB == 208 && defined(BETA1)
 
1995
           #endif
 
1996
           vfmaddps rC12, ra1, rB2, rC12
 
1997
           #if KB > 208
 
1998
              movaps 704(pB0,ldb,2), rB2
 
1999
           #elif KB == 208 && defined(BETA1)
 
2000
           #endif
 
2001
           vfmaddps rC03, ra0, rB3, rC03
 
2002
           #if KB == 208 && defined(BETA1)
 
2003
           #endif
 
2004
           vfmaddps rC13, ra1, rB3, rC13
 
2005
           #if KB > 208
 
2006
              movaps 704(pB0,ldb3), rB3
 
2007
           #elif KB == 208 && defined(BETA1)
 
2008
           #endif
 
2009
        #endif
 
2010
        #if KB > 208
 
2011
           vfmaddps rC00, rA0, rB0, rC00
 
2012
           #if KB > 212
 
2013
              movaps 720(pA0), ra0
 
2014
           #endif
 
2015
           vfmaddps rC10, rA1, rB0, rC10
 
2016
           #if KB > 212
 
2017
              movaps 720(pA0,lda), ra1
 
2018
           #endif
 
2019
           vfmaddps rC01, rA0, rB1, rC01
 
2020
           #if KB > 212
 
2021
              movaps 720(pB0), rB0
 
2022
           #elif KB == 212 && defined(BETA1)
 
2023
           #endif
 
2024
           vfmaddps rC11, rA1, rB1, rC11
 
2025
           #if KB > 212
 
2026
              movaps 720(pB0,ldb), rB1
 
2027
           #elif KB == 212 && defined(BETA1)
 
2028
           #endif
 
2029
           vfmaddps rC02, rA0, rB2, rC02
 
2030
           #if KB == 212 && defined(BETA0)
 
2031
           #endif
 
2032
           vfmaddps rC12, rA1, rB2, rC12
 
2033
           #if KB > 212
 
2034
              movaps 720(pB0,ldb,2), rB2
 
2035
           #elif KB == 212 && defined(BETA1)
 
2036
           #endif
 
2037
           vfmaddps rC03, rA0, rB3, rC03
 
2038
           #if KB == 212 && defined(BETA1)
 
2039
           #endif
 
2040
           vfmaddps rC13, rA1, rB3, rC13
 
2041
           #if KB > 212
 
2042
              movaps 720(pB0,ldb3), rB3
 
2043
           #elif KB == 212 && defined(BETA0)
 
2044
           #endif
 
2045
        #endif
 
2046
        #if KB > 212
 
2047
           vfmaddps rC00, ra0, rB0, rC00
 
2048
           #if KB > 216
 
2049
              movaps 736(pA0), rA0
 
2050
           #endif
 
2051
           vfmaddps rC10, ra1, rB0, rC10
 
2052
           #if KB > 216
 
2053
              movaps 736(pA0,lda), rA1
 
2054
           #endif
 
2055
           vfmaddps rC01, ra0, rB1, rC01
 
2056
           #if KB > 216
 
2057
              movaps 736(pB0), rB0
 
2058
           #elif KB == 216 && defined(BETA1)
 
2059
           #endif
 
2060
           vfmaddps rC11, ra1, rB1, rC11
 
2061
           #if KB > 216
 
2062
              movaps 736(pB0,ldb), rB1
 
2063
           #elif KB == 216 && defined(BETA1)
 
2064
           #endif
 
2065
           vfmaddps rC02, ra0, rB2, rC02
 
2066
           #if KB == 216 && defined(BETA1)
 
2067
           #endif
 
2068
           vfmaddps rC12, ra1, rB2, rC12
 
2069
           #if KB > 216
 
2070
              movaps 736(pB0,ldb,2), rB2
 
2071
           #elif KB == 216 && defined(BETA1)
 
2072
           #endif
 
2073
           vfmaddps rC03, ra0, rB3, rC03
 
2074
           #if KB == 216 && defined(BETA1)
 
2075
           #endif
 
2076
           vfmaddps rC13, ra1, rB3, rC13
 
2077
           #if KB > 216
 
2078
              movaps 736(pB0,ldb3), rB3
 
2079
           #elif KB == 216 && defined(BETA1)
 
2080
           #endif
 
2081
        #endif
 
2082
        #if KB > 216
 
2083
           vfmaddps rC00, rA0, rB0, rC00
 
2084
           #if KB > 220
 
2085
              movaps 752(pA0), ra0
 
2086
           #endif
 
2087
           vfmaddps rC10, rA1, rB0, rC10
 
2088
           #if KB > 220
 
2089
              movaps 752(pA0,lda), ra1
 
2090
           #endif
 
2091
           vfmaddps rC01, rA0, rB1, rC01
 
2092
           #if KB > 220
 
2093
              movaps 752(pB0), rB0
 
2094
           #elif KB == 220 && defined(BETA1)
 
2095
           #endif
 
2096
           vfmaddps rC11, rA1, rB1, rC11
 
2097
           #if KB > 220
 
2098
              movaps 752(pB0,ldb), rB1
 
2099
           #elif KB == 220 && defined(BETA1)
 
2100
           #endif
 
2101
           vfmaddps rC02, rA0, rB2, rC02
 
2102
           #if KB == 220 && defined(BETA0)
 
2103
           #endif
 
2104
           vfmaddps rC12, rA1, rB2, rC12
 
2105
           #if KB > 220
 
2106
              movaps 752(pB0,ldb,2), rB2
 
2107
           #elif KB == 220 && defined(BETA1)
 
2108
           #endif
 
2109
           vfmaddps rC03, rA0, rB3, rC03
 
2110
           #if KB == 220 && defined(BETA1)
 
2111
           #endif
 
2112
           vfmaddps rC13, rA1, rB3, rC13
 
2113
           #if KB > 220
 
2114
              movaps 752(pB0,ldb3), rB3
 
2115
           #elif KB == 220 && defined(BETA0)
 
2116
           #endif
 
2117
        #endif
 
2118
        #if KB > 220
 
2119
           vfmaddps rC00, ra0, rB0, rC00
 
2120
           #if KB > 224
 
2121
              movaps 768(pA0), rA0
 
2122
           #endif
 
2123
           vfmaddps rC10, ra1, rB0, rC10
 
2124
           #if KB > 224
 
2125
              movaps 768(pA0,lda), rA1
 
2126
           #endif
 
2127
           vfmaddps rC01, ra0, rB1, rC01
 
2128
           #if KB > 224
 
2129
              movaps 768(pB0), rB0
 
2130
           #elif KB == 224 && defined(BETA1)
 
2131
           #endif
 
2132
           vfmaddps rC11, ra1, rB1, rC11
 
2133
           #if KB > 224
 
2134
              movaps 768(pB0,ldb), rB1
 
2135
           #elif KB == 224 && defined(BETA1)
 
2136
           #endif
 
2137
           vfmaddps rC02, ra0, rB2, rC02
 
2138
           #if KB == 224 && defined(BETA1)
 
2139
           #endif
 
2140
           vfmaddps rC12, ra1, rB2, rC12
 
2141
           #if KB > 224
 
2142
              movaps 768(pB0,ldb,2), rB2
 
2143
           #elif KB == 224 && defined(BETA1)
 
2144
           #endif
 
2145
           vfmaddps rC03, ra0, rB3, rC03
 
2146
           #if KB == 224 && defined(BETA1)
 
2147
           #endif
 
2148
           vfmaddps rC13, ra1, rB3, rC13
 
2149
           #if KB > 224
 
2150
              movaps 768(pB0,ldb3), rB3
 
2151
           #elif KB == 224 && defined(BETA1)
 
2152
           #endif
 
2153
        #endif
 
2154
        #if KB > 224
 
2155
           vfmaddps rC00, rA0, rB0, rC00
 
2156
           #if KB > 228
 
2157
              movaps 784(pA0), ra0
 
2158
           #endif
 
2159
           vfmaddps rC10, rA1, rB0, rC10
 
2160
           #if KB > 228
 
2161
              movaps 784(pA0,lda), ra1
 
2162
           #endif
 
2163
           vfmaddps rC01, rA0, rB1, rC01
 
2164
           #if KB > 228
 
2165
              movaps 784(pB0), rB0
 
2166
           #elif KB == 228 && defined(BETA1)
 
2167
           #endif
 
2168
           vfmaddps rC11, rA1, rB1, rC11
 
2169
           #if KB > 228
 
2170
              movaps 784(pB0,ldb), rB1
 
2171
           #elif KB == 228 && defined(BETA1)
 
2172
           #endif
 
2173
           vfmaddps rC02, rA0, rB2, rC02
 
2174
           #if KB == 228 && defined(BETA0)
 
2175
           #endif
 
2176
           vfmaddps rC12, rA1, rB2, rC12
 
2177
           #if KB > 228
 
2178
              movaps 784(pB0,ldb,2), rB2
 
2179
           #elif KB == 228 && defined(BETA1)
 
2180
           #endif
 
2181
           vfmaddps rC03, rA0, rB3, rC03
 
2182
           #if KB == 228 && defined(BETA1)
 
2183
           #endif
 
2184
           vfmaddps rC13, rA1, rB3, rC13
 
2185
           #if KB > 228
 
2186
              movaps 784(pB0,ldb3), rB3
 
2187
           #elif KB == 228 && defined(BETA0)
 
2188
           #endif
 
2189
        #endif
 
2190
        #if KB > 228
 
2191
           vfmaddps rC00, ra0, rB0, rC00
 
2192
           #if KB > 232
 
2193
              movaps 800(pA0), rA0
 
2194
           #endif
 
2195
           vfmaddps rC10, ra1, rB0, rC10
 
2196
           #if KB > 232
 
2197
              movaps 800(pA0,lda), rA1
 
2198
           #endif
 
2199
           vfmaddps rC01, ra0, rB1, rC01
 
2200
           #if KB > 232
 
2201
              movaps 800(pB0), rB0
 
2202
           #elif KB == 232 && defined(BETA1)
 
2203
           #endif
 
2204
           vfmaddps rC11, ra1, rB1, rC11
 
2205
           #if KB > 232
 
2206
              movaps 800(pB0,ldb), rB1
 
2207
           #elif KB == 232 && defined(BETA1)
 
2208
           #endif
 
2209
           vfmaddps rC02, ra0, rB2, rC02
 
2210
           #if KB == 232 && defined(BETA1)
 
2211
           #endif
 
2212
           vfmaddps rC12, ra1, rB2, rC12
 
2213
           #if KB > 232
 
2214
              movaps 800(pB0,ldb,2), rB2
 
2215
           #elif KB == 232 && defined(BETA1)
 
2216
           #endif
 
2217
           vfmaddps rC03, ra0, rB3, rC03
 
2218
           #if KB == 232 && defined(BETA1)
 
2219
           #endif
 
2220
           vfmaddps rC13, ra1, rB3, rC13
 
2221
           #if KB > 232
 
2222
              movaps 800(pB0,ldb3), rB3
 
2223
           #elif KB == 232 && defined(BETA1)
 
2224
           #endif
 
2225
        #endif
 
2226
        #if KB > 232
 
2227
           vfmaddps rC00, rA0, rB0, rC00
 
2228
           #if KB > 236
 
2229
              movaps 816(pA0), ra0
 
2230
           #endif
 
2231
           vfmaddps rC10, rA1, rB0, rC10
 
2232
           #if KB > 236
 
2233
              movaps 816(pA0,lda), ra1
 
2234
           #endif
 
2235
           vfmaddps rC01, rA0, rB1, rC01
 
2236
           #if KB > 236
 
2237
              movaps 816(pB0), rB0
 
2238
           #elif KB == 236 && defined(BETA1)
 
2239
           #endif
 
2240
           vfmaddps rC11, rA1, rB1, rC11
 
2241
           #if KB > 236
 
2242
              movaps 816(pB0,ldb), rB1
 
2243
           #elif KB == 236 && defined(BETA1)
 
2244
           #endif
 
2245
           vfmaddps rC02, rA0, rB2, rC02
 
2246
           #if KB == 236 && defined(BETA0)
 
2247
           #endif
 
2248
           vfmaddps rC12, rA1, rB2, rC12
 
2249
           #if KB > 236
 
2250
              movaps 816(pB0,ldb,2), rB2
 
2251
           #elif KB == 236 && defined(BETA1)
 
2252
           #endif
 
2253
           vfmaddps rC03, rA0, rB3, rC03
 
2254
           #if KB == 236 && defined(BETA1)
 
2255
           #endif
 
2256
           vfmaddps rC13, rA1, rB3, rC13
 
2257
           #if KB > 236
 
2258
              movaps 816(pB0,ldb3), rB3
 
2259
           #elif KB == 236 && defined(BETA0)
 
2260
           #endif
 
2261
        #endif
 
2262
        #if KB > 236
 
2263
           vfmaddps rC00, ra0, rB0, rC00
 
2264
           #if KB > 240
 
2265
              movaps 832(pA0), rA0
 
2266
           #endif
 
2267
           vfmaddps rC10, ra1, rB0, rC10
 
2268
           #if KB > 240
 
2269
              movaps 832(pA0,lda), rA1
 
2270
           #endif
 
2271
           vfmaddps rC01, ra0, rB1, rC01
 
2272
           #if KB > 240
 
2273
              movaps 832(pB0), rB0
 
2274
           #elif KB == 240 && defined(BETA1)
 
2275
           #endif
 
2276
           vfmaddps rC11, ra1, rB1, rC11
 
2277
           #if KB > 240
 
2278
              movaps 832(pB0,ldb), rB1
 
2279
           #elif KB == 240 && defined(BETA1)
 
2280
           #endif
 
2281
           vfmaddps rC02, ra0, rB2, rC02
 
2282
           #if KB == 240 && defined(BETA1)
 
2283
           #endif
 
2284
           vfmaddps rC12, ra1, rB2, rC12
 
2285
           #if KB > 240
 
2286
              movaps 832(pB0,ldb,2), rB2
 
2287
           #elif KB == 240 && defined(BETA1)
 
2288
           #endif
 
2289
           vfmaddps rC03, ra0, rB3, rC03
 
2290
           #if KB == 240 && defined(BETA1)
 
2291
           #endif
 
2292
           vfmaddps rC13, ra1, rB3, rC13
 
2293
           #if KB > 240
 
2294
              movaps 832(pB0,ldb3), rB3
 
2295
           #elif KB == 240 && defined(BETA1)
 
2296
           #endif
 
2297
        #endif
 
2298
        #if KB > 240
 
2299
           vfmaddps rC00, rA0, rB0, rC00
 
2300
           #if KB > 244
 
2301
              movaps 848(pA0), ra0
 
2302
           #endif
 
2303
           vfmaddps rC10, rA1, rB0, rC10
 
2304
           #if KB > 244
 
2305
              movaps 848(pA0,lda), ra1
 
2306
           #endif
 
2307
           vfmaddps rC01, rA0, rB1, rC01
 
2308
           #if KB > 244
 
2309
              movaps 848(pB0), rB0
 
2310
           #elif KB == 244 && defined(BETA1)
 
2311
           #endif
 
2312
           vfmaddps rC11, rA1, rB1, rC11
 
2313
           #if KB > 244
 
2314
              movaps 848(pB0,ldb), rB1
 
2315
           #elif KB == 244 && defined(BETA1)
 
2316
           #endif
 
2317
           vfmaddps rC02, rA0, rB2, rC02
 
2318
           #if KB == 244 && defined(BETA0)
 
2319
           #endif
 
2320
           vfmaddps rC12, rA1, rB2, rC12
 
2321
           #if KB > 244
 
2322
              movaps 848(pB0,ldb,2), rB2
 
2323
           #elif KB == 244 && defined(BETA1)
 
2324
           #endif
 
2325
           vfmaddps rC03, rA0, rB3, rC03
 
2326
           #if KB == 244 && defined(BETA1)
 
2327
           #endif
 
2328
           vfmaddps rC13, rA1, rB3, rC13
 
2329
           #if KB > 244
 
2330
              movaps 848(pB0,ldb3), rB3
 
2331
           #elif KB == 244 && defined(BETA0)
 
2332
           #endif
 
2333
        #endif
 
2334
        #if KB > 244
 
2335
           vfmaddps rC00, ra0, rB0, rC00
 
2336
           #if KB > 248
 
2337
              movaps 864(pA0), rA0
 
2338
           #endif
 
2339
           vfmaddps rC10, ra1, rB0, rC10
 
2340
           #if KB > 248
 
2341
              movaps 864(pA0,lda), rA1
 
2342
           #endif
 
2343
           vfmaddps rC01, ra0, rB1, rC01
 
2344
           #if KB > 248
 
2345
              movaps 864(pB0), rB0
 
2346
           #elif KB == 248 && defined(BETA1)
 
2347
           #endif
 
2348
           vfmaddps rC11, ra1, rB1, rC11
 
2349
           #if KB > 248
 
2350
              movaps 864(pB0,ldb), rB1
 
2351
           #elif KB == 248 && defined(BETA1)
 
2352
           #endif
 
2353
           vfmaddps rC02, ra0, rB2, rC02
 
2354
           #if KB == 248 && defined(BETA1)
 
2355
           #endif
 
2356
           vfmaddps rC12, ra1, rB2, rC12
 
2357
           #if KB > 248
 
2358
              movaps 864(pB0,ldb,2), rB2
 
2359
           #elif KB == 248 && defined(BETA1)
 
2360
           #endif
 
2361
           vfmaddps rC03, ra0, rB3, rC03
 
2362
           #if KB == 248 && defined(BETA1)
 
2363
           #endif
 
2364
           vfmaddps rC13, ra1, rB3, rC13
 
2365
           #if KB > 248
 
2366
              movaps 864(pB0,ldb3), rB3
 
2367
           #elif KB == 248 && defined(BETA1)
 
2368
           #endif
 
2369
        #endif
 
2370
        #if KB > 248
 
2371
           vfmaddps rC00, rA0, rB0, rC00
 
2372
           #if KB > 252
 
2373
              movaps 880(pA0), ra0
 
2374
           #endif
 
2375
           vfmaddps rC10, rA1, rB0, rC10
 
2376
           #if KB > 252
 
2377
              movaps 880(pA0,lda), ra1
 
2378
           #endif
 
2379
           vfmaddps rC01, rA0, rB1, rC01
 
2380
           #if KB > 252
 
2381
              movaps 880(pB0), rB0
 
2382
           #elif KB == 252 && defined(BETA1)
 
2383
           #endif
 
2384
           vfmaddps rC11, rA1, rB1, rC11
 
2385
           #if KB > 252
 
2386
              movaps 880(pB0,ldb), rB1
 
2387
           #elif KB == 252 && defined(BETA1)
 
2388
           #endif
 
2389
           vfmaddps rC02, rA0, rB2, rC02
 
2390
           #if KB == 252 && defined(BETA0)
 
2391
           #endif
 
2392
           vfmaddps rC12, rA1, rB2, rC12
 
2393
           #if KB > 252
 
2394
              movaps 880(pB0,ldb,2), rB2
 
2395
           #elif KB == 252 && defined(BETA1)
 
2396
           #endif
 
2397
           vfmaddps rC03, rA0, rB3, rC03
 
2398
           #if KB == 252 && defined(BETA1)
 
2399
           #endif
 
2400
           vfmaddps rC13, rA1, rB3, rC13
 
2401
           #if KB > 252
 
2402
              movaps 880(pB0,ldb3), rB3
 
2403
           #elif KB == 252 && defined(BETA0)
 
2404
           #endif
 
2405
        #endif
 
2406
        #if KB > 252
 
2407
           vfmaddps rC00, ra0, rB0, rC00
 
2408
           #if KB > 256
 
2409
              movaps 896(pA0), rA0
 
2410
           #endif
 
2411
           vfmaddps rC10, ra1, rB0, rC10
 
2412
           #if KB > 256
 
2413
              movaps 896(pA0,lda), rA1
 
2414
           #endif
 
2415
           vfmaddps rC01, ra0, rB1, rC01
 
2416
           #if KB > 256
 
2417
              movaps 896(pB0), rB0
 
2418
           #elif KB == 256 && defined(BETA1)
 
2419
           #endif
 
2420
           vfmaddps rC11, ra1, rB1, rC11
 
2421
           #if KB > 256
 
2422
              movaps 896(pB0,ldb), rB1
 
2423
           #elif KB == 256 && defined(BETA1)
 
2424
           #endif
 
2425
           vfmaddps rC02, ra0, rB2, rC02
 
2426
           #if KB == 256 && defined(BETA1)
 
2427
           #endif
 
2428
           vfmaddps rC12, ra1, rB2, rC12
 
2429
           #if KB > 256
 
2430
              movaps 896(pB0,ldb,2), rB2
 
2431
           #elif KB == 256 && defined(BETA1)
 
2432
           #endif
 
2433
           vfmaddps rC03, ra0, rB3, rC03
 
2434
           #if KB == 256 && defined(BETA1)
 
2435
           #endif
 
2436
           vfmaddps rC13, ra1, rB3, rC13
 
2437
           #if KB > 256
 
2438
              movaps 896(pB0,ldb3), rB3
 
2439
           #elif KB == 256 && defined(BETA1)
 
2440
           #endif
 
2441
        #endif
 
2442
/*
 
2443
 *       Add in original C if necessary
 
2444
 */
 
2445
         #ifdef BETA1
 
2446
            addss (pC0), rC00
 
2447
            addss CMUL(4)(pC0), rC10
 
2448
            addss (pC0,ldc), rC01
 
2449
            addss CMUL(4)(pC0,ldc), rC11
 
2450
            addss (pC0,ldc,2), rC02
 
2451
            addss CMUL(4)(pC0,ldc,2), rC12
 
2452
            addss (pC0,ldc3), rC03
 
2453
            addss CMUL(4)(pC0,ldc3), rC13
 
2454
         #elif defined(BETAX)
 
2455
            movaps BETAOFF(%rsp), rA0
 
2456
            xorps ra0, ra0
 
2457
            vfmaddss ra0, (pC0), rA0, rB0
 
2458
            vfmaddss ra0, CMUL(4)(pC0), rA0, rB1
 
2459
            unpcklps rB1, rB0                   /* rB0={0,0,c10,c00} */
 
2460
            vfmaddss ra0, (pC0,ldc), rA0, rB2
 
2461
            vfmaddss ra0, CMUL(4)(pC0,ldc), rA0, rB3
 
2462
            unpcklps rB3, rB2                   /* rB2={0,0,c11,c01} */
 
2463
            movlhps  rB2, rB0                   /* rB0={c11,c01,c10,c00} */
 
2464
            vfmaddss ra0, (pC0,ldc,2), rA0, rB1
 
2465
            vfmaddss ra0, CMUL(4)(pC0,ldc,2), rA0, rB3
 
2466
            unpcklps rB3, rB1                   /* rB1={0,0,c12,c02} */
 
2467
            vfmaddss ra0, (pC0,ldc3), rA0, rA1
 
2468
            vfmaddss ra0, CMUL(4)(pC0,ldc3), rA0, ra1
 
2469
            unpcklps ra1, rA1                   /* rA1={0,0,c13,c03} */
 
2470
            movlhps  rA1, rB1                   /* rB1={c13,c03,c12,c02} */
 
2471
         #endif
 
2472
/*
 
2473
 *       K-loop finished, sum up vectors
 
2474
 */
 
2475
         prefetcht1 (pfA)
 
2476
         haddps rC10, rC00    /* rC00 = {c10cd, c10ab, c00cd, c00ab} */
 
2477
         add $64, pfA
 
2478
         haddps rC11, rC01    /* rC01 = {c11cd, c11ab, c01cd, c01ab} */
 
2479
         haddps rC12, rC02    /* rC02 = {c12cd, c12ab, c02cd, c02ab} */
 
2480
         haddps rC13, rC03    /* rC03 = {c13cd, c13ab, c03cd, c03ab} */
 
2481
         haddps rC01, rC00    /* rC00 = {c11a-d, c01a-d, c10a-d, c00a-d} */
 
2482
         haddps rC03, rC02    /* rC02 = {c13a-d, c03a-d, c12a-d, c02a-d} */
 
2483
         #ifdef BETAX
 
2484
            addps rB0, rC00
 
2485
            addps rB1, rC02
 
2486
         #endif
 
2487
 
 
2488
                                        /* rC00 = {c11, c01, c10, c00} */
 
2489
                                        /* rC02 = {c13, c03, c12, c02} */
 
2490
         movss rC00, (pC0)
 
2491
         pshufd $0xB1, rC00, rC01       /* rC01 = {C01, c11, c00, c10} */
 
2492
         movss rC02, (pC0,ldc,2)
 
2493
         pshufd $0xB1, rC02, rC03       /* rC03 = {C03, c13, c02, c12} */
 
2494
         movss rC01, CMUL(4)(pC0)
 
2495
         movhlps rC00, rC00             /* rC00 = {c11, c01, c11, c01} */
 
2496
         movss rC03, CMUL(4)(pC0,ldc,2)
 
2497
         movhlps rC02, rC02             /* rC02 = {c13, c03, c13, c03} */
 
2498
         movss rC00, (pC0,ldc)
 
2499
         movhlps rC01, rC01             /* rC01 = {c01, c11, c01, c11} */
 
2500
         movss rC02, (pC0,ldc3)
 
2501
         movhlps rC03, rC03             /* rC03 = {c03, c13, c03, c13} */
 
2502
         movss rC01, CMUL(4)(pC0,ldc)
 
2503
         movss rC03, CMUL(4)(pC0,ldc3)
 
2504
 
 
2505
         lea (pA0,lda,2), pA0
 
2506
         add $2*CMUL(4), pC0
 
2507
 
 
2508
      sub $2, MM
 
2509
      jnz MNLOOP
 
2510
 
 
2511
      mov MM0, MM
 
2512
      sub incAn, pA0
 
2513
      add incCn, pC0
 
2514
      lea (pB0, ldb, 4), pB0
 
2515
   sub $4, NN
 
2516
   jnz MNLOOP
 
2517
 
 
2518
/* DONE: */
 
2519
        movq    -8(%rsp), %rbp
 
2520
        movq    -16(%rsp), %rbx
 
2521
        movq    -24(%rsp), %r12
 
2522
        movq    -32(%rsp), %r13
 
2523
        movq    -40(%rsp), %r14
 
2524
        movq    -48(%rsp), %r15
 
2525
        ret