Subversion Repositories shark

Rev

Rev 2 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 pj 1
/*
2
 * Copyright (c) 1997-1999 Massachusetts Institute of Technology
3
 *
4
 * This program is free software; you can redistribute it and/or modify
5
 * it under the terms of the GNU General Public License as published by
6
 * the Free Software Foundation; either version 2 of the License, or
7
 * (at your option) any later version.
8
 *
9
 * This program is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
 * GNU General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU General Public License
15
 * along with this program; if not, write to the Free Software
16
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
 *
18
 */
19
 
20
/* This file was automatically generated --- DO NOT EDIT */
21
/* Generated on Tue May 18 13:55:27 EDT 1999 */
22
 
23
#include <ports/fftw-int.h>
24
#include <ports/fftw.h>
25
 
26
/* Generated by: ./genfft -magic-alignment-check -magic-twiddle-load-all -magic-variables 4 -magic-loopi -twiddle 64 */
27
 
28
/*
29
 * This function contains 1038 FP additions, 500 FP multiplications,
30
 * (or, 808 additions, 270 multiplications, 230 fused multiply/add),
31
 * 162 stack variables, and 256 memory accesses
32
 */
33
static const fftw_real K290284677 = FFTW_KONST(+0.290284677254462367636192375817395274691476278);
34
static const fftw_real K956940335 = FFTW_KONST(+0.956940335732208864935797886980269969482849206);
35
static const fftw_real K881921264 = FFTW_KONST(+0.881921264348355029712756863660388349508442621);
36
static const fftw_real K471396736 = FFTW_KONST(+0.471396736825997648556387625905254377657460319);
37
static const fftw_real K555570233 = FFTW_KONST(+0.555570233019602224742830813948532874374937191);
38
static const fftw_real K831469612 = FFTW_KONST(+0.831469612302545237078788377617905756738560812);
39
static const fftw_real K773010453 = FFTW_KONST(+0.773010453362736960810906609758469800971041293);
40
static const fftw_real K634393284 = FFTW_KONST(+0.634393284163645498215171613225493370675687095);
41
static const fftw_real K098017140 = FFTW_KONST(+0.098017140329560601994195563888641845861136673);
42
static const fftw_real K995184726 = FFTW_KONST(+0.995184726672196886244836953109479921575474869);
43
static const fftw_real K980785280 = FFTW_KONST(+0.980785280403230449126182236134239036973933731);
44
static const fftw_real K195090322 = FFTW_KONST(+0.195090322016128267848284868477022240927691618);
45
static const fftw_real K707106781 = FFTW_KONST(+0.707106781186547524400844362104849039284835938);
46
static const fftw_real K923879532 = FFTW_KONST(+0.923879532511286756128183189396788286822416626);
47
static const fftw_real K382683432 = FFTW_KONST(+0.382683432365089771728459984030398866761344562);
48
 
49
/*
50
 * Generator Id's :
51
 * $Id: ftw_64.c,v 1.1.1.1 2002-03-29 14:12:57 pj Exp $
52
 * $Id: ftw_64.c,v 1.1.1.1 2002-03-29 14:12:57 pj Exp $
53
 * $Id: ftw_64.c,v 1.1.1.1 2002-03-29 14:12:57 pj Exp $
54
 */
55
 
56
void fftw_twiddle_64(fftw_complex *A, const fftw_complex *W, int iostride, int m, int dist)
57
{
58
     int i;
59
     fftw_complex *inout;
60
     inout = A;
61
     for (i = m; i > 0; i = i - 1, inout = inout + dist, W = W + 63) {
62
          fftw_real tmp19;
63
          fftw_real tmp791;
64
          fftw_real tmp1109;
65
          fftw_real tmp1139;
66
          fftw_real tmp1047;
67
          fftw_real tmp1077;
68
          fftw_real tmp383;
69
          fftw_real tmp655;
70
          fftw_real tmp66;
71
          fftw_real tmp800;
72
          fftw_real tmp908;
73
          fftw_real tmp956;
74
          fftw_real tmp406;
75
          fftw_real tmp608;
76
          fftw_real tmp662;
77
          fftw_real tmp744;
78
          fftw_real tmp42;
79
          fftw_real tmp1076;
80
          fftw_real tmp794;
81
          fftw_real tmp1042;
82
          fftw_real tmp394;
83
          fftw_real tmp1106;
84
          fftw_real tmp658;
85
          fftw_real tmp1138;
86
          fftw_real tmp329;
87
          fftw_real tmp983;
88
          fftw_real tmp863;
89
          fftw_real tmp927;
90
          fftw_real tmp990;
91
          fftw_real tmp1026;
92
          fftw_real tmp880;
93
          fftw_real tmp930;
94
          fftw_real tmp535;
95
          fftw_real tmp703;
96
          fftw_real tmp576;
97
          fftw_real tmp714;
98
          fftw_real tmp579;
99
          fftw_real tmp704;
100
          fftw_real tmp546;
101
          fftw_real tmp715;
102
          fftw_real tmp376;
103
          fftw_real tmp991;
104
          fftw_real tmp868;
105
          fftw_real tmp882;
106
          fftw_real tmp986;
107
          fftw_real tmp1027;
108
          fftw_real tmp873;
109
          fftw_real tmp881;
110
          fftw_real tmp558;
111
          fftw_real tmp582;
112
          fftw_real tmp708;
113
          fftw_real tmp718;
114
          fftw_real tmp569;
115
          fftw_real tmp581;
116
          fftw_real tmp711;
117
          fftw_real tmp717;
118
          fftw_real tmp89;
119
          fftw_real tmp805;
120
          fftw_real tmp909;
121
          fftw_real tmp957;
122
          fftw_real tmp417;
123
          fftw_real tmp609;
124
          fftw_real tmp665;
125
          fftw_real tmp745;
126
          fftw_real tmp161;
127
          fftw_real tmp184;
128
          fftw_real tmp965;
129
          fftw_real tmp823;
130
          fftw_real tmp915;
131
          fftw_real tmp966;
132
          fftw_real tmp967;
133
          fftw_real tmp968;
134
          fftw_real tmp828;
135
          fftw_real tmp916;
136
          fftw_real tmp451;
137
          fftw_real tmp678;
138
          fftw_real tmp468;
139
          fftw_real tmp675;
140
          fftw_real tmp471;
141
          fftw_real tmp679;
142
          fftw_real tmp462;
143
          fftw_real tmp676;
144
          fftw_real tmp114;
145
          fftw_real tmp137;
146
          fftw_real tmp963;
147
          fftw_real tmp812;
148
          fftw_real tmp912;
149
          fftw_real tmp960;
150
          fftw_real tmp961;
151
          fftw_real tmp962;
152
          fftw_real tmp817;
153
          fftw_real tmp913;
154
          fftw_real tmp424;
155
          fftw_real tmp668;
156
          fftw_real tmp441;
157
          fftw_real tmp671;
158
          fftw_real tmp444;
159
          fftw_real tmp669;
160
          fftw_real tmp435;
161
          fftw_real tmp672;
162
          fftw_real tmp234;
163
          fftw_real tmp977;
164
          fftw_real tmp836;
165
          fftw_real tmp923;
166
          fftw_real tmp974;
167
          fftw_real tmp1021;
168
          fftw_real tmp853;
169
          fftw_real tmp920;
170
          fftw_real tmp480;
171
          fftw_real tmp684;
172
          fftw_real tmp521;
173
          fftw_real tmp695;
174
          fftw_real tmp524;
175
          fftw_real tmp685;
176
          fftw_real tmp491;
177
          fftw_real tmp696;
178
          fftw_real tmp281;
179
          fftw_real tmp975;
180
          fftw_real tmp841;
181
          fftw_real tmp855;
182
          fftw_real tmp980;
183
          fftw_real tmp1022;
184
          fftw_real tmp846;
185
          fftw_real tmp854;
186
          fftw_real tmp503;
187
          fftw_real tmp527;
188
          fftw_real tmp689;
189
          fftw_real tmp699;
190
          fftw_real tmp514;
191
          fftw_real tmp526;
192
          fftw_real tmp692;
193
          fftw_real tmp698;
194
          ASSERT_ALIGNED_DOUBLE();
195
          {
196
               fftw_real tmp1;
197
               fftw_real tmp1045;
198
               fftw_real tmp6;
199
               fftw_real tmp1044;
200
               fftw_real tmp12;
201
               fftw_real tmp380;
202
               fftw_real tmp17;
203
               fftw_real tmp381;
204
               ASSERT_ALIGNED_DOUBLE();
205
               tmp1 = c_re(inout[0]);
206
               tmp1045 = c_im(inout[0]);
207
               {
208
                    fftw_real tmp3;
209
                    fftw_real tmp5;
210
                    fftw_real tmp2;
211
                    fftw_real tmp4;
212
                    ASSERT_ALIGNED_DOUBLE();
213
                    tmp3 = c_re(inout[32 * iostride]);
214
                    tmp5 = c_im(inout[32 * iostride]);
215
                    tmp2 = c_re(W[31]);
216
                    tmp4 = c_im(W[31]);
217
                    tmp6 = (tmp2 * tmp3) - (tmp4 * tmp5);
218
                    tmp1044 = (tmp4 * tmp3) + (tmp2 * tmp5);
219
               }
220
               {
221
                    fftw_real tmp9;
222
                    fftw_real tmp11;
223
                    fftw_real tmp8;
224
                    fftw_real tmp10;
225
                    ASSERT_ALIGNED_DOUBLE();
226
                    tmp9 = c_re(inout[16 * iostride]);
227
                    tmp11 = c_im(inout[16 * iostride]);
228
                    tmp8 = c_re(W[15]);
229
                    tmp10 = c_im(W[15]);
230
                    tmp12 = (tmp8 * tmp9) - (tmp10 * tmp11);
231
                    tmp380 = (tmp10 * tmp9) + (tmp8 * tmp11);
232
               }
233
               {
234
                    fftw_real tmp14;
235
                    fftw_real tmp16;
236
                    fftw_real tmp13;
237
                    fftw_real tmp15;
238
                    ASSERT_ALIGNED_DOUBLE();
239
                    tmp14 = c_re(inout[48 * iostride]);
240
                    tmp16 = c_im(inout[48 * iostride]);
241
                    tmp13 = c_re(W[47]);
242
                    tmp15 = c_im(W[47]);
243
                    tmp17 = (tmp13 * tmp14) - (tmp15 * tmp16);
244
                    tmp381 = (tmp15 * tmp14) + (tmp13 * tmp16);
245
               }
246
               {
247
                    fftw_real tmp7;
248
                    fftw_real tmp18;
249
                    fftw_real tmp1107;
250
                    fftw_real tmp1108;
251
                    ASSERT_ALIGNED_DOUBLE();
252
                    tmp7 = tmp1 + tmp6;
253
                    tmp18 = tmp12 + tmp17;
254
                    tmp19 = tmp7 + tmp18;
255
                    tmp791 = tmp7 - tmp18;
256
                    tmp1107 = tmp1045 - tmp1044;
257
                    tmp1108 = tmp12 - tmp17;
258
                    tmp1109 = tmp1107 - tmp1108;
259
                    tmp1139 = tmp1108 + tmp1107;
260
               }
261
               {
262
                    fftw_real tmp1043;
263
                    fftw_real tmp1046;
264
                    fftw_real tmp379;
265
                    fftw_real tmp382;
266
                    ASSERT_ALIGNED_DOUBLE();
267
                    tmp1043 = tmp380 + tmp381;
268
                    tmp1046 = tmp1044 + tmp1045;
269
                    tmp1047 = tmp1043 + tmp1046;
270
                    tmp1077 = tmp1046 - tmp1043;
271
                    tmp379 = tmp1 - tmp6;
272
                    tmp382 = tmp380 - tmp381;
273
                    tmp383 = tmp379 - tmp382;
274
                    tmp655 = tmp379 + tmp382;
275
               }
276
          }
277
          {
278
               fftw_real tmp54;
279
               fftw_real tmp401;
280
               fftw_real tmp398;
281
               fftw_real tmp796;
282
               fftw_real tmp65;
283
               fftw_real tmp399;
284
               fftw_real tmp404;
285
               fftw_real tmp797;
286
               fftw_real tmp798;
287
               fftw_real tmp799;
288
               ASSERT_ALIGNED_DOUBLE();
289
               {
290
                    fftw_real tmp48;
291
                    fftw_real tmp396;
292
                    fftw_real tmp53;
293
                    fftw_real tmp397;
294
                    ASSERT_ALIGNED_DOUBLE();
295
                    {
296
                         fftw_real tmp45;
297
                         fftw_real tmp47;
298
                         fftw_real tmp44;
299
                         fftw_real tmp46;
300
                         ASSERT_ALIGNED_DOUBLE();
301
                         tmp45 = c_re(inout[4 * iostride]);
302
                         tmp47 = c_im(inout[4 * iostride]);
303
                         tmp44 = c_re(W[3]);
304
                         tmp46 = c_im(W[3]);
305
                         tmp48 = (tmp44 * tmp45) - (tmp46 * tmp47);
306
                         tmp396 = (tmp46 * tmp45) + (tmp44 * tmp47);
307
                    }
308
                    {
309
                         fftw_real tmp50;
310
                         fftw_real tmp52;
311
                         fftw_real tmp49;
312
                         fftw_real tmp51;
313
                         ASSERT_ALIGNED_DOUBLE();
314
                         tmp50 = c_re(inout[36 * iostride]);
315
                         tmp52 = c_im(inout[36 * iostride]);
316
                         tmp49 = c_re(W[35]);
317
                         tmp51 = c_im(W[35]);
318
                         tmp53 = (tmp49 * tmp50) - (tmp51 * tmp52);
319
                         tmp397 = (tmp51 * tmp50) + (tmp49 * tmp52);
320
                    }
321
                    tmp54 = tmp48 + tmp53;
322
                    tmp401 = tmp48 - tmp53;
323
                    tmp398 = tmp396 - tmp397;
324
                    tmp796 = tmp396 + tmp397;
325
               }
326
               {
327
                    fftw_real tmp59;
328
                    fftw_real tmp402;
329
                    fftw_real tmp64;
330
                    fftw_real tmp403;
331
                    ASSERT_ALIGNED_DOUBLE();
332
                    {
333
                         fftw_real tmp56;
334
                         fftw_real tmp58;
335
                         fftw_real tmp55;
336
                         fftw_real tmp57;
337
                         ASSERT_ALIGNED_DOUBLE();
338
                         tmp56 = c_re(inout[20 * iostride]);
339
                         tmp58 = c_im(inout[20 * iostride]);
340
                         tmp55 = c_re(W[19]);
341
                         tmp57 = c_im(W[19]);
342
                         tmp59 = (tmp55 * tmp56) - (tmp57 * tmp58);
343
                         tmp402 = (tmp57 * tmp56) + (tmp55 * tmp58);
344
                    }
345
                    {
346
                         fftw_real tmp61;
347
                         fftw_real tmp63;
348
                         fftw_real tmp60;
349
                         fftw_real tmp62;
350
                         ASSERT_ALIGNED_DOUBLE();
351
                         tmp61 = c_re(inout[52 * iostride]);
352
                         tmp63 = c_im(inout[52 * iostride]);
353
                         tmp60 = c_re(W[51]);
354
                         tmp62 = c_im(W[51]);
355
                         tmp64 = (tmp60 * tmp61) - (tmp62 * tmp63);
356
                         tmp403 = (tmp62 * tmp61) + (tmp60 * tmp63);
357
                    }
358
                    tmp65 = tmp59 + tmp64;
359
                    tmp399 = tmp59 - tmp64;
360
                    tmp404 = tmp402 - tmp403;
361
                    tmp797 = tmp402 + tmp403;
362
               }
363
               tmp66 = tmp54 + tmp65;
364
               tmp798 = tmp796 - tmp797;
365
               tmp799 = tmp54 - tmp65;
366
               tmp800 = tmp798 - tmp799;
367
               tmp908 = tmp799 + tmp798;
368
               tmp956 = tmp796 + tmp797;
369
               {
370
                    fftw_real tmp400;
371
                    fftw_real tmp405;
372
                    fftw_real tmp660;
373
                    fftw_real tmp661;
374
                    ASSERT_ALIGNED_DOUBLE();
375
                    tmp400 = tmp398 + tmp399;
376
                    tmp405 = tmp401 - tmp404;
377
                    tmp406 = (K382683432 * tmp400) - (K923879532 * tmp405);
378
                    tmp608 = (K923879532 * tmp400) + (K382683432 * tmp405);
379
                    tmp660 = tmp398 - tmp399;
380
                    tmp661 = tmp401 + tmp404;
381
                    tmp662 = (K923879532 * tmp660) - (K382683432 * tmp661);
382
                    tmp744 = (K382683432 * tmp660) + (K923879532 * tmp661);
383
               }
384
          }
385
          {
386
               fftw_real tmp24;
387
               fftw_real tmp384;
388
               fftw_real tmp29;
389
               fftw_real tmp385;
390
               fftw_real tmp386;
391
               fftw_real tmp387;
392
               fftw_real tmp35;
393
               fftw_real tmp390;
394
               fftw_real tmp40;
395
               fftw_real tmp391;
396
               fftw_real tmp389;
397
               fftw_real tmp392;
398
               ASSERT_ALIGNED_DOUBLE();
399
               {
400
                    fftw_real tmp21;
401
                    fftw_real tmp23;
402
                    fftw_real tmp20;
403
                    fftw_real tmp22;
404
                    ASSERT_ALIGNED_DOUBLE();
405
                    tmp21 = c_re(inout[8 * iostride]);
406
                    tmp23 = c_im(inout[8 * iostride]);
407
                    tmp20 = c_re(W[7]);
408
                    tmp22 = c_im(W[7]);
409
                    tmp24 = (tmp20 * tmp21) - (tmp22 * tmp23);
410
                    tmp384 = (tmp22 * tmp21) + (tmp20 * tmp23);
411
               }
412
               {
413
                    fftw_real tmp26;
414
                    fftw_real tmp28;
415
                    fftw_real tmp25;
416
                    fftw_real tmp27;
417
                    ASSERT_ALIGNED_DOUBLE();
418
                    tmp26 = c_re(inout[40 * iostride]);
419
                    tmp28 = c_im(inout[40 * iostride]);
420
                    tmp25 = c_re(W[39]);
421
                    tmp27 = c_im(W[39]);
422
                    tmp29 = (tmp25 * tmp26) - (tmp27 * tmp28);
423
                    tmp385 = (tmp27 * tmp26) + (tmp25 * tmp28);
424
               }
425
               tmp386 = tmp384 - tmp385;
426
               tmp387 = tmp24 - tmp29;
427
               {
428
                    fftw_real tmp32;
429
                    fftw_real tmp34;
430
                    fftw_real tmp31;
431
                    fftw_real tmp33;
432
                    ASSERT_ALIGNED_DOUBLE();
433
                    tmp32 = c_re(inout[56 * iostride]);
434
                    tmp34 = c_im(inout[56 * iostride]);
435
                    tmp31 = c_re(W[55]);
436
                    tmp33 = c_im(W[55]);
437
                    tmp35 = (tmp31 * tmp32) - (tmp33 * tmp34);
438
                    tmp390 = (tmp33 * tmp32) + (tmp31 * tmp34);
439
               }
440
               {
441
                    fftw_real tmp37;
442
                    fftw_real tmp39;
443
                    fftw_real tmp36;
444
                    fftw_real tmp38;
445
                    ASSERT_ALIGNED_DOUBLE();
446
                    tmp37 = c_re(inout[24 * iostride]);
447
                    tmp39 = c_im(inout[24 * iostride]);
448
                    tmp36 = c_re(W[23]);
449
                    tmp38 = c_im(W[23]);
450
                    tmp40 = (tmp36 * tmp37) - (tmp38 * tmp39);
451
                    tmp391 = (tmp38 * tmp37) + (tmp36 * tmp39);
452
               }
453
               tmp389 = tmp35 - tmp40;
454
               tmp392 = tmp390 - tmp391;
455
               {
456
                    fftw_real tmp30;
457
                    fftw_real tmp41;
458
                    fftw_real tmp792;
459
                    fftw_real tmp793;
460
                    ASSERT_ALIGNED_DOUBLE();
461
                    tmp30 = tmp24 + tmp29;
462
                    tmp41 = tmp35 + tmp40;
463
                    tmp42 = tmp30 + tmp41;
464
                    tmp1076 = tmp41 - tmp30;
465
                    tmp792 = tmp384 + tmp385;
466
                    tmp793 = tmp390 + tmp391;
467
                    tmp794 = tmp792 - tmp793;
468
                    tmp1042 = tmp792 + tmp793;
469
               }
470
               {
471
                    fftw_real tmp388;
472
                    fftw_real tmp393;
473
                    fftw_real tmp656;
474
                    fftw_real tmp657;
475
                    ASSERT_ALIGNED_DOUBLE();
476
                    tmp388 = tmp386 - tmp387;
477
                    tmp393 = tmp389 + tmp392;
478
                    tmp394 = K707106781 * (tmp388 - tmp393);
479
                    tmp1106 = K707106781 * (tmp388 + tmp393);
480
                    tmp656 = tmp387 + tmp386;
481
                    tmp657 = tmp389 - tmp392;
482
                    tmp658 = K707106781 * (tmp656 + tmp657);
483
                    tmp1138 = K707106781 * (tmp657 - tmp656);
484
               }
485
          }
486
          {
487
               fftw_real tmp287;
488
               fftw_real tmp572;
489
               fftw_real tmp292;
490
               fftw_real tmp573;
491
               fftw_real tmp293;
492
               fftw_real tmp876;
493
               fftw_real tmp327;
494
               fftw_real tmp541;
495
               fftw_real tmp544;
496
               fftw_real tmp861;
497
               fftw_real tmp298;
498
               fftw_real tmp532;
499
               fftw_real tmp303;
500
               fftw_real tmp533;
501
               fftw_real tmp304;
502
               fftw_real tmp877;
503
               fftw_real tmp316;
504
               fftw_real tmp539;
505
               fftw_real tmp538;
506
               fftw_real tmp860;
507
               ASSERT_ALIGNED_DOUBLE();
508
               {
509
                    fftw_real tmp284;
510
                    fftw_real tmp286;
511
                    fftw_real tmp283;
512
                    fftw_real tmp285;
513
                    ASSERT_ALIGNED_DOUBLE();
514
                    tmp284 = c_re(inout[63 * iostride]);
515
                    tmp286 = c_im(inout[63 * iostride]);
516
                    tmp283 = c_re(W[62]);
517
                    tmp285 = c_im(W[62]);
518
                    tmp287 = (tmp283 * tmp284) - (tmp285 * tmp286);
519
                    tmp572 = (tmp285 * tmp284) + (tmp283 * tmp286);
520
               }
521
               {
522
                    fftw_real tmp289;
523
                    fftw_real tmp291;
524
                    fftw_real tmp288;
525
                    fftw_real tmp290;
526
                    ASSERT_ALIGNED_DOUBLE();
527
                    tmp289 = c_re(inout[31 * iostride]);
528
                    tmp291 = c_im(inout[31 * iostride]);
529
                    tmp288 = c_re(W[30]);
530
                    tmp290 = c_im(W[30]);
531
                    tmp292 = (tmp288 * tmp289) - (tmp290 * tmp291);
532
                    tmp573 = (tmp290 * tmp289) + (tmp288 * tmp291);
533
               }
534
               tmp293 = tmp287 + tmp292;
535
               tmp876 = tmp572 + tmp573;
536
               {
537
                    fftw_real tmp321;
538
                    fftw_real tmp542;
539
                    fftw_real tmp326;
540
                    fftw_real tmp543;
541
                    ASSERT_ALIGNED_DOUBLE();
542
                    {
543
                         fftw_real tmp318;
544
                         fftw_real tmp320;
545
                         fftw_real tmp317;
546
                         fftw_real tmp319;
547
                         ASSERT_ALIGNED_DOUBLE();
548
                         tmp318 = c_re(inout[55 * iostride]);
549
                         tmp320 = c_im(inout[55 * iostride]);
550
                         tmp317 = c_re(W[54]);
551
                         tmp319 = c_im(W[54]);
552
                         tmp321 = (tmp317 * tmp318) - (tmp319 * tmp320);
553
                         tmp542 = (tmp319 * tmp318) + (tmp317 * tmp320);
554
                    }
555
                    {
556
                         fftw_real tmp323;
557
                         fftw_real tmp325;
558
                         fftw_real tmp322;
559
                         fftw_real tmp324;
560
                         ASSERT_ALIGNED_DOUBLE();
561
                         tmp323 = c_re(inout[23 * iostride]);
562
                         tmp325 = c_im(inout[23 * iostride]);
563
                         tmp322 = c_re(W[22]);
564
                         tmp324 = c_im(W[22]);
565
                         tmp326 = (tmp322 * tmp323) - (tmp324 * tmp325);
566
                         tmp543 = (tmp324 * tmp323) + (tmp322 * tmp325);
567
                    }
568
                    tmp327 = tmp321 + tmp326;
569
                    tmp541 = tmp321 - tmp326;
570
                    tmp544 = tmp542 - tmp543;
571
                    tmp861 = tmp542 + tmp543;
572
               }
573
               {
574
                    fftw_real tmp295;
575
                    fftw_real tmp297;
576
                    fftw_real tmp294;
577
                    fftw_real tmp296;
578
                    ASSERT_ALIGNED_DOUBLE();
579
                    tmp295 = c_re(inout[15 * iostride]);
580
                    tmp297 = c_im(inout[15 * iostride]);
581
                    tmp294 = c_re(W[14]);
582
                    tmp296 = c_im(W[14]);
583
                    tmp298 = (tmp294 * tmp295) - (tmp296 * tmp297);
584
                    tmp532 = (tmp296 * tmp295) + (tmp294 * tmp297);
585
               }
586
               {
587
                    fftw_real tmp300;
588
                    fftw_real tmp302;
589
                    fftw_real tmp299;
590
                    fftw_real tmp301;
591
                    ASSERT_ALIGNED_DOUBLE();
592
                    tmp300 = c_re(inout[47 * iostride]);
593
                    tmp302 = c_im(inout[47 * iostride]);
594
                    tmp299 = c_re(W[46]);
595
                    tmp301 = c_im(W[46]);
596
                    tmp303 = (tmp299 * tmp300) - (tmp301 * tmp302);
597
                    tmp533 = (tmp301 * tmp300) + (tmp299 * tmp302);
598
               }
599
               tmp304 = tmp298 + tmp303;
600
               tmp877 = tmp532 + tmp533;
601
               {
602
                    fftw_real tmp310;
603
                    fftw_real tmp536;
604
                    fftw_real tmp315;
605
                    fftw_real tmp537;
606
                    ASSERT_ALIGNED_DOUBLE();
607
                    {
608
                         fftw_real tmp307;
609
                         fftw_real tmp309;
610
                         fftw_real tmp306;
611
                         fftw_real tmp308;
612
                         ASSERT_ALIGNED_DOUBLE();
613
                         tmp307 = c_re(inout[7 * iostride]);
614
                         tmp309 = c_im(inout[7 * iostride]);
615
                         tmp306 = c_re(W[6]);
616
                         tmp308 = c_im(W[6]);
617
                         tmp310 = (tmp306 * tmp307) - (tmp308 * tmp309);
618
                         tmp536 = (tmp308 * tmp307) + (tmp306 * tmp309);
619
                    }
620
                    {
621
                         fftw_real tmp312;
622
                         fftw_real tmp314;
623
                         fftw_real tmp311;
624
                         fftw_real tmp313;
625
                         ASSERT_ALIGNED_DOUBLE();
626
                         tmp312 = c_re(inout[39 * iostride]);
627
                         tmp314 = c_im(inout[39 * iostride]);
628
                         tmp311 = c_re(W[38]);
629
                         tmp313 = c_im(W[38]);
630
                         tmp315 = (tmp311 * tmp312) - (tmp313 * tmp314);
631
                         tmp537 = (tmp313 * tmp312) + (tmp311 * tmp314);
632
                    }
633
                    tmp316 = tmp310 + tmp315;
634
                    tmp539 = tmp310 - tmp315;
635
                    tmp538 = tmp536 - tmp537;
636
                    tmp860 = tmp536 + tmp537;
637
               }
638
               {
639
                    fftw_real tmp305;
640
                    fftw_real tmp328;
641
                    fftw_real tmp859;
642
                    fftw_real tmp862;
643
                    ASSERT_ALIGNED_DOUBLE();
644
                    tmp305 = tmp293 + tmp304;
645
                    tmp328 = tmp316 + tmp327;
646
                    tmp329 = tmp305 + tmp328;
647
                    tmp983 = tmp305 - tmp328;
648
                    tmp859 = tmp293 - tmp304;
649
                    tmp862 = tmp860 - tmp861;
650
                    tmp863 = tmp859 - tmp862;
651
                    tmp927 = tmp859 + tmp862;
652
               }
653
               {
654
                    fftw_real tmp988;
655
                    fftw_real tmp989;
656
                    fftw_real tmp878;
657
                    fftw_real tmp879;
658
                    ASSERT_ALIGNED_DOUBLE();
659
                    tmp988 = tmp876 + tmp877;
660
                    tmp989 = tmp860 + tmp861;
661
                    tmp990 = tmp988 - tmp989;
662
                    tmp1026 = tmp988 + tmp989;
663
                    tmp878 = tmp876 - tmp877;
664
                    tmp879 = tmp327 - tmp316;
665
                    tmp880 = tmp878 - tmp879;
666
                    tmp930 = tmp878 + tmp879;
667
               }
668
               {
669
                    fftw_real tmp531;
670
                    fftw_real tmp534;
671
                    fftw_real tmp574;
672
                    fftw_real tmp575;
673
                    ASSERT_ALIGNED_DOUBLE();
674
                    tmp531 = tmp287 - tmp292;
675
                    tmp534 = tmp532 - tmp533;
676
                    tmp535 = tmp531 - tmp534;
677
                    tmp703 = tmp531 + tmp534;
678
                    tmp574 = tmp572 - tmp573;
679
                    tmp575 = tmp298 - tmp303;
680
                    tmp576 = tmp574 + tmp575;
681
                    tmp714 = tmp574 - tmp575;
682
               }
683
               {
684
                    fftw_real tmp577;
685
                    fftw_real tmp578;
686
                    fftw_real tmp540;
687
                    fftw_real tmp545;
688
                    ASSERT_ALIGNED_DOUBLE();
689
                    tmp577 = tmp541 - tmp544;
690
                    tmp578 = tmp539 + tmp538;
691
                    tmp579 = K707106781 * (tmp577 - tmp578);
692
                    tmp704 = K707106781 * (tmp578 + tmp577);
693
                    tmp540 = tmp538 - tmp539;
694
                    tmp545 = tmp541 + tmp544;
695
                    tmp546 = K707106781 * (tmp540 - tmp545);
696
                    tmp715 = K707106781 * (tmp540 + tmp545);
697
               }
698
          }
699
          {
700
               fftw_real tmp340;
701
               fftw_real tmp553;
702
               fftw_real tmp550;
703
               fftw_real tmp864;
704
               fftw_real tmp374;
705
               fftw_real tmp562;
706
               fftw_real tmp567;
707
               fftw_real tmp871;
708
               fftw_real tmp351;
709
               fftw_real tmp551;
710
               fftw_real tmp556;
711
               fftw_real tmp865;
712
               fftw_real tmp363;
713
               fftw_real tmp564;
714
               fftw_real tmp561;
715
               fftw_real tmp870;
716
               ASSERT_ALIGNED_DOUBLE();
717
               {
718
                    fftw_real tmp334;
719
                    fftw_real tmp548;
720
                    fftw_real tmp339;
721
                    fftw_real tmp549;
722
                    ASSERT_ALIGNED_DOUBLE();
723
                    {
724
                         fftw_real tmp331;
725
                         fftw_real tmp333;
726
                         fftw_real tmp330;
727
                         fftw_real tmp332;
728
                         ASSERT_ALIGNED_DOUBLE();
729
                         tmp331 = c_re(inout[3 * iostride]);
730
                         tmp333 = c_im(inout[3 * iostride]);
731
                         tmp330 = c_re(W[2]);
732
                         tmp332 = c_im(W[2]);
733
                         tmp334 = (tmp330 * tmp331) - (tmp332 * tmp333);
734
                         tmp548 = (tmp332 * tmp331) + (tmp330 * tmp333);
735
                    }
736
                    {
737
                         fftw_real tmp336;
738
                         fftw_real tmp338;
739
                         fftw_real tmp335;
740
                         fftw_real tmp337;
741
                         ASSERT_ALIGNED_DOUBLE();
742
                         tmp336 = c_re(inout[35 * iostride]);
743
                         tmp338 = c_im(inout[35 * iostride]);
744
                         tmp335 = c_re(W[34]);
745
                         tmp337 = c_im(W[34]);
746
                         tmp339 = (tmp335 * tmp336) - (tmp337 * tmp338);
747
                         tmp549 = (tmp337 * tmp336) + (tmp335 * tmp338);
748
                    }
749
                    tmp340 = tmp334 + tmp339;
750
                    tmp553 = tmp334 - tmp339;
751
                    tmp550 = tmp548 - tmp549;
752
                    tmp864 = tmp548 + tmp549;
753
               }
754
               {
755
                    fftw_real tmp368;
756
                    fftw_real tmp565;
757
                    fftw_real tmp373;
758
                    fftw_real tmp566;
759
                    ASSERT_ALIGNED_DOUBLE();
760
                    {
761
                         fftw_real tmp365;
762
                         fftw_real tmp367;
763
                         fftw_real tmp364;
764
                         fftw_real tmp366;
765
                         ASSERT_ALIGNED_DOUBLE();
766
                         tmp365 = c_re(inout[11 * iostride]);
767
                         tmp367 = c_im(inout[11 * iostride]);
768
                         tmp364 = c_re(W[10]);
769
                         tmp366 = c_im(W[10]);
770
                         tmp368 = (tmp364 * tmp365) - (tmp366 * tmp367);
771
                         tmp565 = (tmp366 * tmp365) + (tmp364 * tmp367);
772
                    }
773
                    {
774
                         fftw_real tmp370;
775
                         fftw_real tmp372;
776
                         fftw_real tmp369;
777
                         fftw_real tmp371;
778
                         ASSERT_ALIGNED_DOUBLE();
779
                         tmp370 = c_re(inout[43 * iostride]);
780
                         tmp372 = c_im(inout[43 * iostride]);
781
                         tmp369 = c_re(W[42]);
782
                         tmp371 = c_im(W[42]);
783
                         tmp373 = (tmp369 * tmp370) - (tmp371 * tmp372);
784
                         tmp566 = (tmp371 * tmp370) + (tmp369 * tmp372);
785
                    }
786
                    tmp374 = tmp368 + tmp373;
787
                    tmp562 = tmp368 - tmp373;
788
                    tmp567 = tmp565 - tmp566;
789
                    tmp871 = tmp565 + tmp566;
790
               }
791
               {
792
                    fftw_real tmp345;
793
                    fftw_real tmp554;
794
                    fftw_real tmp350;
795
                    fftw_real tmp555;
796
                    ASSERT_ALIGNED_DOUBLE();
797
                    {
798
                         fftw_real tmp342;
799
                         fftw_real tmp344;
800
                         fftw_real tmp341;
801
                         fftw_real tmp343;
802
                         ASSERT_ALIGNED_DOUBLE();
803
                         tmp342 = c_re(inout[19 * iostride]);
804
                         tmp344 = c_im(inout[19 * iostride]);
805
                         tmp341 = c_re(W[18]);
806
                         tmp343 = c_im(W[18]);
807
                         tmp345 = (tmp341 * tmp342) - (tmp343 * tmp344);
808
                         tmp554 = (tmp343 * tmp342) + (tmp341 * tmp344);
809
                    }
810
                    {
811
                         fftw_real tmp347;
812
                         fftw_real tmp349;
813
                         fftw_real tmp346;
814
                         fftw_real tmp348;
815
                         ASSERT_ALIGNED_DOUBLE();
816
                         tmp347 = c_re(inout[51 * iostride]);
817
                         tmp349 = c_im(inout[51 * iostride]);
818
                         tmp346 = c_re(W[50]);
819
                         tmp348 = c_im(W[50]);
820
                         tmp350 = (tmp346 * tmp347) - (tmp348 * tmp349);
821
                         tmp555 = (tmp348 * tmp347) + (tmp346 * tmp349);
822
                    }
823
                    tmp351 = tmp345 + tmp350;
824
                    tmp551 = tmp345 - tmp350;
825
                    tmp556 = tmp554 - tmp555;
826
                    tmp865 = tmp554 + tmp555;
827
               }
828
               {
829
                    fftw_real tmp357;
830
                    fftw_real tmp559;
831
                    fftw_real tmp362;
832
                    fftw_real tmp560;
833
                    ASSERT_ALIGNED_DOUBLE();
834
                    {
835
                         fftw_real tmp354;
836
                         fftw_real tmp356;
837
                         fftw_real tmp353;
838
                         fftw_real tmp355;
839
                         ASSERT_ALIGNED_DOUBLE();
840
                         tmp354 = c_re(inout[59 * iostride]);
841
                         tmp356 = c_im(inout[59 * iostride]);
842
                         tmp353 = c_re(W[58]);
843
                         tmp355 = c_im(W[58]);
844
                         tmp357 = (tmp353 * tmp354) - (tmp355 * tmp356);
845
                         tmp559 = (tmp355 * tmp354) + (tmp353 * tmp356);
846
                    }
847
                    {
848
                         fftw_real tmp359;
849
                         fftw_real tmp361;
850
                         fftw_real tmp358;
851
                         fftw_real tmp360;
852
                         ASSERT_ALIGNED_DOUBLE();
853
                         tmp359 = c_re(inout[27 * iostride]);
854
                         tmp361 = c_im(inout[27 * iostride]);
855
                         tmp358 = c_re(W[26]);
856
                         tmp360 = c_im(W[26]);
857
                         tmp362 = (tmp358 * tmp359) - (tmp360 * tmp361);
858
                         tmp560 = (tmp360 * tmp359) + (tmp358 * tmp361);
859
                    }
860
                    tmp363 = tmp357 + tmp362;
861
                    tmp564 = tmp357 - tmp362;
862
                    tmp561 = tmp559 - tmp560;
863
                    tmp870 = tmp559 + tmp560;
864
               }
865
               {
866
                    fftw_real tmp352;
867
                    fftw_real tmp375;
868
                    fftw_real tmp866;
869
                    fftw_real tmp867;
870
                    ASSERT_ALIGNED_DOUBLE();
871
                    tmp352 = tmp340 + tmp351;
872
                    tmp375 = tmp363 + tmp374;
873
                    tmp376 = tmp352 + tmp375;
874
                    tmp991 = tmp375 - tmp352;
875
                    tmp866 = tmp864 - tmp865;
876
                    tmp867 = tmp340 - tmp351;
877
                    tmp868 = tmp866 - tmp867;
878
                    tmp882 = tmp867 + tmp866;
879
               }
880
               {
881
                    fftw_real tmp984;
882
                    fftw_real tmp985;
883
                    fftw_real tmp869;
884
                    fftw_real tmp872;
885
                    ASSERT_ALIGNED_DOUBLE();
886
                    tmp984 = tmp864 + tmp865;
887
                    tmp985 = tmp870 + tmp871;
888
                    tmp986 = tmp984 - tmp985;
889
                    tmp1027 = tmp984 + tmp985;
890
                    tmp869 = tmp363 - tmp374;
891
                    tmp872 = tmp870 - tmp871;
892
                    tmp873 = tmp869 + tmp872;
893
                    tmp881 = tmp869 - tmp872;
894
               }
895
               {
896
                    fftw_real tmp552;
897
                    fftw_real tmp557;
898
                    fftw_real tmp706;
899
                    fftw_real tmp707;
900
                    ASSERT_ALIGNED_DOUBLE();
901
                    tmp552 = tmp550 + tmp551;
902
                    tmp557 = tmp553 - tmp556;
903
                    tmp558 = (K382683432 * tmp552) - (K923879532 * tmp557);
904
                    tmp582 = (K923879532 * tmp552) + (K382683432 * tmp557);
905
                    tmp706 = tmp550 - tmp551;
906
                    tmp707 = tmp553 + tmp556;
907
                    tmp708 = (K923879532 * tmp706) - (K382683432 * tmp707);
908
                    tmp718 = (K382683432 * tmp706) + (K923879532 * tmp707);
909
               }
910
               {
911
                    fftw_real tmp563;
912
                    fftw_real tmp568;
913
                    fftw_real tmp709;
914
                    fftw_real tmp710;
915
                    ASSERT_ALIGNED_DOUBLE();
916
                    tmp563 = tmp561 + tmp562;
917
                    tmp568 = tmp564 - tmp567;
918
                    tmp569 = (K382683432 * tmp563) + (K923879532 * tmp568);
919
                    tmp581 = (K382683432 * tmp568) - (K923879532 * tmp563);
920
                    tmp709 = tmp561 - tmp562;
921
                    tmp710 = tmp564 + tmp567;
922
                    tmp711 = (K923879532 * tmp709) + (K382683432 * tmp710);
923
                    tmp717 = (K923879532 * tmp710) - (K382683432 * tmp709);
924
               }
925
          }
926
          {
927
               fftw_real tmp77;
928
               fftw_real tmp412;
929
               fftw_real tmp409;
930
               fftw_real tmp802;
931
               fftw_real tmp88;
932
               fftw_real tmp410;
933
               fftw_real tmp415;
934
               fftw_real tmp803;
935
               fftw_real tmp801;
936
               fftw_real tmp804;
937
               ASSERT_ALIGNED_DOUBLE();
938
               {
939
                    fftw_real tmp71;
940
                    fftw_real tmp407;
941
                    fftw_real tmp76;
942
                    fftw_real tmp408;
943
                    ASSERT_ALIGNED_DOUBLE();
944
                    {
945
                         fftw_real tmp68;
946
                         fftw_real tmp70;
947
                         fftw_real tmp67;
948
                         fftw_real tmp69;
949
                         ASSERT_ALIGNED_DOUBLE();
950
                         tmp68 = c_re(inout[60 * iostride]);
951
                         tmp70 = c_im(inout[60 * iostride]);
952
                         tmp67 = c_re(W[59]);
953
                         tmp69 = c_im(W[59]);
954
                         tmp71 = (tmp67 * tmp68) - (tmp69 * tmp70);
955
                         tmp407 = (tmp69 * tmp68) + (tmp67 * tmp70);
956
                    }
957
                    {
958
                         fftw_real tmp73;
959
                         fftw_real tmp75;
960
                         fftw_real tmp72;
961
                         fftw_real tmp74;
962
                         ASSERT_ALIGNED_DOUBLE();
963
                         tmp73 = c_re(inout[28 * iostride]);
964
                         tmp75 = c_im(inout[28 * iostride]);
965
                         tmp72 = c_re(W[27]);
966
                         tmp74 = c_im(W[27]);
967
                         tmp76 = (tmp72 * tmp73) - (tmp74 * tmp75);
968
                         tmp408 = (tmp74 * tmp73) + (tmp72 * tmp75);
969
                    }
970
                    tmp77 = tmp71 + tmp76;
971
                    tmp412 = tmp71 - tmp76;
972
                    tmp409 = tmp407 - tmp408;
973
                    tmp802 = tmp407 + tmp408;
974
               }
975
               {
976
                    fftw_real tmp82;
977
                    fftw_real tmp413;
978
                    fftw_real tmp87;
979
                    fftw_real tmp414;
980
                    ASSERT_ALIGNED_DOUBLE();
981
                    {
982
                         fftw_real tmp79;
983
                         fftw_real tmp81;
984
                         fftw_real tmp78;
985
                         fftw_real tmp80;
986
                         ASSERT_ALIGNED_DOUBLE();
987
                         tmp79 = c_re(inout[12 * iostride]);
988
                         tmp81 = c_im(inout[12 * iostride]);
989
                         tmp78 = c_re(W[11]);
990
                         tmp80 = c_im(W[11]);
991
                         tmp82 = (tmp78 * tmp79) - (tmp80 * tmp81);
992
                         tmp413 = (tmp80 * tmp79) + (tmp78 * tmp81);
993
                    }
994
                    {
995
                         fftw_real tmp84;
996
                         fftw_real tmp86;
997
                         fftw_real tmp83;
998
                         fftw_real tmp85;
999
                         ASSERT_ALIGNED_DOUBLE();
1000
                         tmp84 = c_re(inout[44 * iostride]);
1001
                         tmp86 = c_im(inout[44 * iostride]);
1002
                         tmp83 = c_re(W[43]);
1003
                         tmp85 = c_im(W[43]);
1004
                         tmp87 = (tmp83 * tmp84) - (tmp85 * tmp86);
1005
                         tmp414 = (tmp85 * tmp84) + (tmp83 * tmp86);
1006
                    }
1007
                    tmp88 = tmp82 + tmp87;
1008
                    tmp410 = tmp82 - tmp87;
1009
                    tmp415 = tmp413 - tmp414;
1010
                    tmp803 = tmp413 + tmp414;
1011
               }
1012
               tmp89 = tmp77 + tmp88;
1013
               tmp801 = tmp77 - tmp88;
1014
               tmp804 = tmp802 - tmp803;
1015
               tmp805 = tmp801 + tmp804;
1016
               tmp909 = tmp801 - tmp804;
1017
               tmp957 = tmp802 + tmp803;
1018
               {
1019
                    fftw_real tmp411;
1020
                    fftw_real tmp416;
1021
                    fftw_real tmp663;
1022
                    fftw_real tmp664;
1023
                    ASSERT_ALIGNED_DOUBLE();
1024
                    tmp411 = tmp409 + tmp410;
1025
                    tmp416 = tmp412 - tmp415;
1026
                    tmp417 = (K382683432 * tmp411) + (K923879532 * tmp416);
1027
                    tmp609 = (K382683432 * tmp416) - (K923879532 * tmp411);
1028
                    tmp663 = tmp409 - tmp410;
1029
                    tmp664 = tmp412 + tmp415;
1030
                    tmp665 = (K923879532 * tmp663) + (K382683432 * tmp664);
1031
                    tmp745 = (K923879532 * tmp664) - (K382683432 * tmp663);
1032
               }
1033
          }
1034
          {
1035
               fftw_real tmp143;
1036
               fftw_real tmp447;
1037
               fftw_real tmp148;
1038
               fftw_real tmp448;
1039
               fftw_real tmp149;
1040
               fftw_real tmp819;
1041
               fftw_real tmp183;
1042
               fftw_real tmp452;
1043
               fftw_real tmp455;
1044
               fftw_real tmp826;
1045
               fftw_real tmp154;
1046
               fftw_real tmp465;
1047
               fftw_real tmp159;
1048
               fftw_real tmp466;
1049
               fftw_real tmp160;
1050
               fftw_real tmp820;
1051
               fftw_real tmp172;
1052
               fftw_real tmp457;
1053
               fftw_real tmp460;
1054
               fftw_real tmp825;
1055
               ASSERT_ALIGNED_DOUBLE();
1056
               {
1057
                    fftw_real tmp140;
1058
                    fftw_real tmp142;
1059
                    fftw_real tmp139;
1060
                    fftw_real tmp141;
1061
                    ASSERT_ALIGNED_DOUBLE();
1062
                    tmp140 = c_re(inout[62 * iostride]);
1063
                    tmp142 = c_im(inout[62 * iostride]);
1064
                    tmp139 = c_re(W[61]);
1065
                    tmp141 = c_im(W[61]);
1066
                    tmp143 = (tmp139 * tmp140) - (tmp141 * tmp142);
1067
                    tmp447 = (tmp141 * tmp140) + (tmp139 * tmp142);
1068
               }
1069
               {
1070
                    fftw_real tmp145;
1071
                    fftw_real tmp147;
1072
                    fftw_real tmp144;
1073
                    fftw_real tmp146;
1074
                    ASSERT_ALIGNED_DOUBLE();
1075
                    tmp145 = c_re(inout[30 * iostride]);
1076
                    tmp147 = c_im(inout[30 * iostride]);
1077
                    tmp144 = c_re(W[29]);
1078
                    tmp146 = c_im(W[29]);
1079
                    tmp148 = (tmp144 * tmp145) - (tmp146 * tmp147);
1080
                    tmp448 = (tmp146 * tmp145) + (tmp144 * tmp147);
1081
               }
1082
               tmp149 = tmp143 + tmp148;
1083
               tmp819 = tmp447 + tmp448;
1084
               {
1085
                    fftw_real tmp177;
1086
                    fftw_real tmp453;
1087
                    fftw_real tmp182;
1088
                    fftw_real tmp454;
1089
                    ASSERT_ALIGNED_DOUBLE();
1090
                    {
1091
                         fftw_real tmp174;
1092
                         fftw_real tmp176;
1093
                         fftw_real tmp173;
1094
                         fftw_real tmp175;
1095
                         ASSERT_ALIGNED_DOUBLE();
1096
                         tmp174 = c_re(inout[54 * iostride]);
1097
                         tmp176 = c_im(inout[54 * iostride]);
1098
                         tmp173 = c_re(W[53]);
1099
                         tmp175 = c_im(W[53]);
1100
                         tmp177 = (tmp173 * tmp174) - (tmp175 * tmp176);
1101
                         tmp453 = (tmp175 * tmp174) + (tmp173 * tmp176);
1102
                    }
1103
                    {
1104
                         fftw_real tmp179;
1105
                         fftw_real tmp181;
1106
                         fftw_real tmp178;
1107
                         fftw_real tmp180;
1108
                         ASSERT_ALIGNED_DOUBLE();
1109
                         tmp179 = c_re(inout[22 * iostride]);
1110
                         tmp181 = c_im(inout[22 * iostride]);
1111
                         tmp178 = c_re(W[21]);
1112
                         tmp180 = c_im(W[21]);
1113
                         tmp182 = (tmp178 * tmp179) - (tmp180 * tmp181);
1114
                         tmp454 = (tmp180 * tmp179) + (tmp178 * tmp181);
1115
                    }
1116
                    tmp183 = tmp177 + tmp182;
1117
                    tmp452 = tmp177 - tmp182;
1118
                    tmp455 = tmp453 - tmp454;
1119
                    tmp826 = tmp453 + tmp454;
1120
               }
1121
               {
1122
                    fftw_real tmp151;
1123
                    fftw_real tmp153;
1124
                    fftw_real tmp150;
1125
                    fftw_real tmp152;
1126
                    ASSERT_ALIGNED_DOUBLE();
1127
                    tmp151 = c_re(inout[14 * iostride]);
1128
                    tmp153 = c_im(inout[14 * iostride]);
1129
                    tmp150 = c_re(W[13]);
1130
                    tmp152 = c_im(W[13]);
1131
                    tmp154 = (tmp150 * tmp151) - (tmp152 * tmp153);
1132
                    tmp465 = (tmp152 * tmp151) + (tmp150 * tmp153);
1133
               }
1134
               {
1135
                    fftw_real tmp156;
1136
                    fftw_real tmp158;
1137
                    fftw_real tmp155;
1138
                    fftw_real tmp157;
1139
                    ASSERT_ALIGNED_DOUBLE();
1140
                    tmp156 = c_re(inout[46 * iostride]);
1141
                    tmp158 = c_im(inout[46 * iostride]);
1142
                    tmp155 = c_re(W[45]);
1143
                    tmp157 = c_im(W[45]);
1144
                    tmp159 = (tmp155 * tmp156) - (tmp157 * tmp158);
1145
                    tmp466 = (tmp157 * tmp156) + (tmp155 * tmp158);
1146
               }
1147
               tmp160 = tmp154 + tmp159;
1148
               tmp820 = tmp465 + tmp466;
1149
               {
1150
                    fftw_real tmp166;
1151
                    fftw_real tmp458;
1152
                    fftw_real tmp171;
1153
                    fftw_real tmp459;
1154
                    ASSERT_ALIGNED_DOUBLE();
1155
                    {
1156
                         fftw_real tmp163;
1157
                         fftw_real tmp165;
1158
                         fftw_real tmp162;
1159
                         fftw_real tmp164;
1160
                         ASSERT_ALIGNED_DOUBLE();
1161
                         tmp163 = c_re(inout[6 * iostride]);
1162
                         tmp165 = c_im(inout[6 * iostride]);
1163
                         tmp162 = c_re(W[5]);
1164
                         tmp164 = c_im(W[5]);
1165
                         tmp166 = (tmp162 * tmp163) - (tmp164 * tmp165);
1166
                         tmp458 = (tmp164 * tmp163) + (tmp162 * tmp165);
1167
                    }
1168
                    {
1169
                         fftw_real tmp168;
1170
                         fftw_real tmp170;
1171
                         fftw_real tmp167;
1172
                         fftw_real tmp169;
1173
                         ASSERT_ALIGNED_DOUBLE();
1174
                         tmp168 = c_re(inout[38 * iostride]);
1175
                         tmp170 = c_im(inout[38 * iostride]);
1176
                         tmp167 = c_re(W[37]);
1177
                         tmp169 = c_im(W[37]);
1178
                         tmp171 = (tmp167 * tmp168) - (tmp169 * tmp170);
1179
                         tmp459 = (tmp169 * tmp168) + (tmp167 * tmp170);
1180
                    }
1181
                    tmp172 = tmp166 + tmp171;
1182
                    tmp457 = tmp166 - tmp171;
1183
                    tmp460 = tmp458 - tmp459;
1184
                    tmp825 = tmp458 + tmp459;
1185
               }
1186
               {
1187
                    fftw_real tmp821;
1188
                    fftw_real tmp822;
1189
                    fftw_real tmp824;
1190
                    fftw_real tmp827;
1191
                    ASSERT_ALIGNED_DOUBLE();
1192
                    tmp161 = tmp149 + tmp160;
1193
                    tmp184 = tmp172 + tmp183;
1194
                    tmp965 = tmp161 - tmp184;
1195
                    tmp821 = tmp819 - tmp820;
1196
                    tmp822 = tmp183 - tmp172;
1197
                    tmp823 = tmp821 - tmp822;
1198
                    tmp915 = tmp821 + tmp822;
1199
                    tmp966 = tmp819 + tmp820;
1200
                    tmp967 = tmp825 + tmp826;
1201
                    tmp968 = tmp966 - tmp967;
1202
                    tmp824 = tmp149 - tmp160;
1203
                    tmp827 = tmp825 - tmp826;
1204
                    tmp828 = tmp824 - tmp827;
1205
                    tmp916 = tmp824 + tmp827;
1206
               }
1207
               {
1208
                    fftw_real tmp449;
1209
                    fftw_real tmp450;
1210
                    fftw_real tmp464;
1211
                    fftw_real tmp467;
1212
                    ASSERT_ALIGNED_DOUBLE();
1213
                    tmp449 = tmp447 - tmp448;
1214
                    tmp450 = tmp154 - tmp159;
1215
                    tmp451 = tmp449 + tmp450;
1216
                    tmp678 = tmp449 - tmp450;
1217
                    tmp464 = tmp143 - tmp148;
1218
                    tmp467 = tmp465 - tmp466;
1219
                    tmp468 = tmp464 - tmp467;
1220
                    tmp675 = tmp464 + tmp467;
1221
               }
1222
               {
1223
                    fftw_real tmp469;
1224
                    fftw_real tmp470;
1225
                    fftw_real tmp456;
1226
                    fftw_real tmp461;
1227
                    ASSERT_ALIGNED_DOUBLE();
1228
                    tmp469 = tmp460 - tmp457;
1229
                    tmp470 = tmp452 + tmp455;
1230
                    tmp471 = K707106781 * (tmp469 - tmp470);
1231
                    tmp679 = K707106781 * (tmp469 + tmp470);
1232
                    tmp456 = tmp452 - tmp455;
1233
                    tmp461 = tmp457 + tmp460;
1234
                    tmp462 = K707106781 * (tmp456 - tmp461);
1235
                    tmp676 = K707106781 * (tmp461 + tmp456);
1236
               }
1237
          }
1238
          {
1239
               fftw_real tmp96;
1240
               fftw_real tmp420;
1241
               fftw_real tmp101;
1242
               fftw_real tmp421;
1243
               fftw_real tmp102;
1244
               fftw_real tmp808;
1245
               fftw_real tmp136;
1246
               fftw_real tmp425;
1247
               fftw_real tmp428;
1248
               fftw_real tmp815;
1249
               fftw_real tmp107;
1250
               fftw_real tmp438;
1251
               fftw_real tmp112;
1252
               fftw_real tmp439;
1253
               fftw_real tmp113;
1254
               fftw_real tmp809;
1255
               fftw_real tmp125;
1256
               fftw_real tmp430;
1257
               fftw_real tmp433;
1258
               fftw_real tmp814;
1259
               ASSERT_ALIGNED_DOUBLE();
1260
               {
1261
                    fftw_real tmp93;
1262
                    fftw_real tmp95;
1263
                    fftw_real tmp92;
1264
                    fftw_real tmp94;
1265
                    ASSERT_ALIGNED_DOUBLE();
1266
                    tmp93 = c_re(inout[2 * iostride]);
1267
                    tmp95 = c_im(inout[2 * iostride]);
1268
                    tmp92 = c_re(W[1]);
1269
                    tmp94 = c_im(W[1]);
1270
                    tmp96 = (tmp92 * tmp93) - (tmp94 * tmp95);
1271
                    tmp420 = (tmp94 * tmp93) + (tmp92 * tmp95);
1272
               }
1273
               {
1274
                    fftw_real tmp98;
1275
                    fftw_real tmp100;
1276
                    fftw_real tmp97;
1277
                    fftw_real tmp99;
1278
                    ASSERT_ALIGNED_DOUBLE();
1279
                    tmp98 = c_re(inout[34 * iostride]);
1280
                    tmp100 = c_im(inout[34 * iostride]);
1281
                    tmp97 = c_re(W[33]);
1282
                    tmp99 = c_im(W[33]);
1283
                    tmp101 = (tmp97 * tmp98) - (tmp99 * tmp100);
1284
                    tmp421 = (tmp99 * tmp98) + (tmp97 * tmp100);
1285
               }
1286
               tmp102 = tmp96 + tmp101;
1287
               tmp808 = tmp420 + tmp421;
1288
               {
1289
                    fftw_real tmp130;
1290
                    fftw_real tmp426;
1291
                    fftw_real tmp135;
1292
                    fftw_real tmp427;
1293
                    ASSERT_ALIGNED_DOUBLE();
1294
                    {
1295
                         fftw_real tmp127;
1296
                         fftw_real tmp129;
1297
                         fftw_real tmp126;
1298
                         fftw_real tmp128;
1299
                         ASSERT_ALIGNED_DOUBLE();
1300
                         tmp127 = c_re(inout[58 * iostride]);
1301
                         tmp129 = c_im(inout[58 * iostride]);
1302
                         tmp126 = c_re(W[57]);
1303
                         tmp128 = c_im(W[57]);
1304
                         tmp130 = (tmp126 * tmp127) - (tmp128 * tmp129);
1305
                         tmp426 = (tmp128 * tmp127) + (tmp126 * tmp129);
1306
                    }
1307
                    {
1308
                         fftw_real tmp132;
1309
                         fftw_real tmp134;
1310
                         fftw_real tmp131;
1311
                         fftw_real tmp133;
1312
                         ASSERT_ALIGNED_DOUBLE();
1313
                         tmp132 = c_re(inout[26 * iostride]);
1314
                         tmp134 = c_im(inout[26 * iostride]);
1315
                         tmp131 = c_re(W[25]);
1316
                         tmp133 = c_im(W[25]);
1317
                         tmp135 = (tmp131 * tmp132) - (tmp133 * tmp134);
1318
                         tmp427 = (tmp133 * tmp132) + (tmp131 * tmp134);
1319
                    }
1320
                    tmp136 = tmp130 + tmp135;
1321
                    tmp425 = tmp130 - tmp135;
1322
                    tmp428 = tmp426 - tmp427;
1323
                    tmp815 = tmp426 + tmp427;
1324
               }
1325
               {
1326
                    fftw_real tmp104;
1327
                    fftw_real tmp106;
1328
                    fftw_real tmp103;
1329
                    fftw_real tmp105;
1330
                    ASSERT_ALIGNED_DOUBLE();
1331
                    tmp104 = c_re(inout[18 * iostride]);
1332
                    tmp106 = c_im(inout[18 * iostride]);
1333
                    tmp103 = c_re(W[17]);
1334
                    tmp105 = c_im(W[17]);
1335
                    tmp107 = (tmp103 * tmp104) - (tmp105 * tmp106);
1336
                    tmp438 = (tmp105 * tmp104) + (tmp103 * tmp106);
1337
               }
1338
               {
1339
                    fftw_real tmp109;
1340
                    fftw_real tmp111;
1341
                    fftw_real tmp108;
1342
                    fftw_real tmp110;
1343
                    ASSERT_ALIGNED_DOUBLE();
1344
                    tmp109 = c_re(inout[50 * iostride]);
1345
                    tmp111 = c_im(inout[50 * iostride]);
1346
                    tmp108 = c_re(W[49]);
1347
                    tmp110 = c_im(W[49]);
1348
                    tmp112 = (tmp108 * tmp109) - (tmp110 * tmp111);
1349
                    tmp439 = (tmp110 * tmp109) + (tmp108 * tmp111);
1350
               }
1351
               tmp113 = tmp107 + tmp112;
1352
               tmp809 = tmp438 + tmp439;
1353
               {
1354
                    fftw_real tmp119;
1355
                    fftw_real tmp431;
1356
                    fftw_real tmp124;
1357
                    fftw_real tmp432;
1358
                    ASSERT_ALIGNED_DOUBLE();
1359
                    {
1360
                         fftw_real tmp116;
1361
                         fftw_real tmp118;
1362
                         fftw_real tmp115;
1363
                         fftw_real tmp117;
1364
                         ASSERT_ALIGNED_DOUBLE();
1365
                         tmp116 = c_re(inout[10 * iostride]);
1366
                         tmp118 = c_im(inout[10 * iostride]);
1367
                         tmp115 = c_re(W[9]);
1368
                         tmp117 = c_im(W[9]);
1369
                         tmp119 = (tmp115 * tmp116) - (tmp117 * tmp118);
1370
                         tmp431 = (tmp117 * tmp116) + (tmp115 * tmp118);
1371
                    }
1372
                    {
1373
                         fftw_real tmp121;
1374
                         fftw_real tmp123;
1375
                         fftw_real tmp120;
1376
                         fftw_real tmp122;
1377
                         ASSERT_ALIGNED_DOUBLE();
1378
                         tmp121 = c_re(inout[42 * iostride]);
1379
                         tmp123 = c_im(inout[42 * iostride]);
1380
                         tmp120 = c_re(W[41]);
1381
                         tmp122 = c_im(W[41]);
1382
                         tmp124 = (tmp120 * tmp121) - (tmp122 * tmp123);
1383
                         tmp432 = (tmp122 * tmp121) + (tmp120 * tmp123);
1384
                    }
1385
                    tmp125 = tmp119 + tmp124;
1386
                    tmp430 = tmp119 - tmp124;
1387
                    tmp433 = tmp431 - tmp432;
1388
                    tmp814 = tmp431 + tmp432;
1389
               }
1390
               {
1391
                    fftw_real tmp810;
1392
                    fftw_real tmp811;
1393
                    fftw_real tmp813;
1394
                    fftw_real tmp816;
1395
                    ASSERT_ALIGNED_DOUBLE();
1396
                    tmp114 = tmp102 + tmp113;
1397
                    tmp137 = tmp125 + tmp136;
1398
                    tmp963 = tmp114 - tmp137;
1399
                    tmp810 = tmp808 - tmp809;
1400
                    tmp811 = tmp136 - tmp125;
1401
                    tmp812 = tmp810 - tmp811;
1402
                    tmp912 = tmp810 + tmp811;
1403
                    tmp960 = tmp808 + tmp809;
1404
                    tmp961 = tmp814 + tmp815;
1405
                    tmp962 = tmp960 - tmp961;
1406
                    tmp813 = tmp102 - tmp113;
1407
                    tmp816 = tmp814 - tmp815;
1408
                    tmp817 = tmp813 - tmp816;
1409
                    tmp913 = tmp813 + tmp816;
1410
               }
1411
               {
1412
                    fftw_real tmp422;
1413
                    fftw_real tmp423;
1414
                    fftw_real tmp437;
1415
                    fftw_real tmp440;
1416
                    ASSERT_ALIGNED_DOUBLE();
1417
                    tmp422 = tmp420 - tmp421;
1418
                    tmp423 = tmp107 - tmp112;
1419
                    tmp424 = tmp422 + tmp423;
1420
                    tmp668 = tmp422 - tmp423;
1421
                    tmp437 = tmp96 - tmp101;
1422
                    tmp440 = tmp438 - tmp439;
1423
                    tmp441 = tmp437 - tmp440;
1424
                    tmp671 = tmp437 + tmp440;
1425
               }
1426
               {
1427
                    fftw_real tmp442;
1428
                    fftw_real tmp443;
1429
                    fftw_real tmp429;
1430
                    fftw_real tmp434;
1431
                    ASSERT_ALIGNED_DOUBLE();
1432
                    tmp442 = tmp433 - tmp430;
1433
                    tmp443 = tmp425 + tmp428;
1434
                    tmp444 = K707106781 * (tmp442 - tmp443);
1435
                    tmp669 = K707106781 * (tmp442 + tmp443);
1436
                    tmp429 = tmp425 - tmp428;
1437
                    tmp434 = tmp430 + tmp433;
1438
                    tmp435 = K707106781 * (tmp429 - tmp434);
1439
                    tmp672 = K707106781 * (tmp434 + tmp429);
1440
               }
1441
          }
1442
          {
1443
               fftw_real tmp192;
1444
               fftw_real tmp476;
1445
               fftw_real tmp197;
1446
               fftw_real tmp477;
1447
               fftw_real tmp198;
1448
               fftw_real tmp832;
1449
               fftw_real tmp232;
1450
               fftw_real tmp481;
1451
               fftw_real tmp484;
1452
               fftw_real tmp851;
1453
               fftw_real tmp203;
1454
               fftw_real tmp518;
1455
               fftw_real tmp208;
1456
               fftw_real tmp519;
1457
               fftw_real tmp209;
1458
               fftw_real tmp833;
1459
               fftw_real tmp221;
1460
               fftw_real tmp486;
1461
               fftw_real tmp489;
1462
               fftw_real tmp850;
1463
               ASSERT_ALIGNED_DOUBLE();
1464
               {
1465
                    fftw_real tmp189;
1466
                    fftw_real tmp191;
1467
                    fftw_real tmp188;
1468
                    fftw_real tmp190;
1469
                    ASSERT_ALIGNED_DOUBLE();
1470
                    tmp189 = c_re(inout[iostride]);
1471
                    tmp191 = c_im(inout[iostride]);
1472
                    tmp188 = c_re(W[0]);
1473
                    tmp190 = c_im(W[0]);
1474
                    tmp192 = (tmp188 * tmp189) - (tmp190 * tmp191);
1475
                    tmp476 = (tmp190 * tmp189) + (tmp188 * tmp191);
1476
               }
1477
               {
1478
                    fftw_real tmp194;
1479
                    fftw_real tmp196;
1480
                    fftw_real tmp193;
1481
                    fftw_real tmp195;
1482
                    ASSERT_ALIGNED_DOUBLE();
1483
                    tmp194 = c_re(inout[33 * iostride]);
1484
                    tmp196 = c_im(inout[33 * iostride]);
1485
                    tmp193 = c_re(W[32]);
1486
                    tmp195 = c_im(W[32]);
1487
                    tmp197 = (tmp193 * tmp194) - (tmp195 * tmp196);
1488
                    tmp477 = (tmp195 * tmp194) + (tmp193 * tmp196);
1489
               }
1490
               tmp198 = tmp192 + tmp197;
1491
               tmp832 = tmp476 + tmp477;
1492
               {
1493
                    fftw_real tmp226;
1494
                    fftw_real tmp482;
1495
                    fftw_real tmp231;
1496
                    fftw_real tmp483;
1497
                    ASSERT_ALIGNED_DOUBLE();
1498
                    {
1499
                         fftw_real tmp223;
1500
                         fftw_real tmp225;
1501
                         fftw_real tmp222;
1502
                         fftw_real tmp224;
1503
                         ASSERT_ALIGNED_DOUBLE();
1504
                         tmp223 = c_re(inout[57 * iostride]);
1505
                         tmp225 = c_im(inout[57 * iostride]);
1506
                         tmp222 = c_re(W[56]);
1507
                         tmp224 = c_im(W[56]);
1508
                         tmp226 = (tmp222 * tmp223) - (tmp224 * tmp225);
1509
                         tmp482 = (tmp224 * tmp223) + (tmp222 * tmp225);
1510
                    }
1511
                    {
1512
                         fftw_real tmp228;
1513
                         fftw_real tmp230;
1514
                         fftw_real tmp227;
1515
                         fftw_real tmp229;
1516
                         ASSERT_ALIGNED_DOUBLE();
1517
                         tmp228 = c_re(inout[25 * iostride]);
1518
                         tmp230 = c_im(inout[25 * iostride]);
1519
                         tmp227 = c_re(W[24]);
1520
                         tmp229 = c_im(W[24]);
1521
                         tmp231 = (tmp227 * tmp228) - (tmp229 * tmp230);
1522
                         tmp483 = (tmp229 * tmp228) + (tmp227 * tmp230);
1523
                    }
1524
                    tmp232 = tmp226 + tmp231;
1525
                    tmp481 = tmp226 - tmp231;
1526
                    tmp484 = tmp482 - tmp483;
1527
                    tmp851 = tmp482 + tmp483;
1528
               }
1529
               {
1530
                    fftw_real tmp200;
1531
                    fftw_real tmp202;
1532
                    fftw_real tmp199;
1533
                    fftw_real tmp201;
1534
                    ASSERT_ALIGNED_DOUBLE();
1535
                    tmp200 = c_re(inout[17 * iostride]);
1536
                    tmp202 = c_im(inout[17 * iostride]);
1537
                    tmp199 = c_re(W[16]);
1538
                    tmp201 = c_im(W[16]);
1539
                    tmp203 = (tmp199 * tmp200) - (tmp201 * tmp202);
1540
                    tmp518 = (tmp201 * tmp200) + (tmp199 * tmp202);
1541
               }
1542
               {
1543
                    fftw_real tmp205;
1544
                    fftw_real tmp207;
1545
                    fftw_real tmp204;
1546
                    fftw_real tmp206;
1547
                    ASSERT_ALIGNED_DOUBLE();
1548
                    tmp205 = c_re(inout[49 * iostride]);
1549
                    tmp207 = c_im(inout[49 * iostride]);
1550
                    tmp204 = c_re(W[48]);
1551
                    tmp206 = c_im(W[48]);
1552
                    tmp208 = (tmp204 * tmp205) - (tmp206 * tmp207);
1553
                    tmp519 = (tmp206 * tmp205) + (tmp204 * tmp207);
1554
               }
1555
               tmp209 = tmp203 + tmp208;
1556
               tmp833 = tmp518 + tmp519;
1557
               {
1558
                    fftw_real tmp215;
1559
                    fftw_real tmp487;
1560
                    fftw_real tmp220;
1561
                    fftw_real tmp488;
1562
                    ASSERT_ALIGNED_DOUBLE();
1563
                    {
1564
                         fftw_real tmp212;
1565
                         fftw_real tmp214;
1566
                         fftw_real tmp211;
1567
                         fftw_real tmp213;
1568
                         ASSERT_ALIGNED_DOUBLE();
1569
                         tmp212 = c_re(inout[9 * iostride]);
1570
                         tmp214 = c_im(inout[9 * iostride]);
1571
                         tmp211 = c_re(W[8]);
1572
                         tmp213 = c_im(W[8]);
1573
                         tmp215 = (tmp211 * tmp212) - (tmp213 * tmp214);
1574
                         tmp487 = (tmp213 * tmp212) + (tmp211 * tmp214);
1575
                    }
1576
                    {
1577
                         fftw_real tmp217;
1578
                         fftw_real tmp219;
1579
                         fftw_real tmp216;
1580
                         fftw_real tmp218;
1581
                         ASSERT_ALIGNED_DOUBLE();
1582
                         tmp217 = c_re(inout[41 * iostride]);
1583
                         tmp219 = c_im(inout[41 * iostride]);
1584
                         tmp216 = c_re(W[40]);
1585
                         tmp218 = c_im(W[40]);
1586
                         tmp220 = (tmp216 * tmp217) - (tmp218 * tmp219);
1587
                         tmp488 = (tmp218 * tmp217) + (tmp216 * tmp219);
1588
                    }
1589
                    tmp221 = tmp215 + tmp220;
1590
                    tmp486 = tmp215 - tmp220;
1591
                    tmp489 = tmp487 - tmp488;
1592
                    tmp850 = tmp487 + tmp488;
1593
               }
1594
               {
1595
                    fftw_real tmp210;
1596
                    fftw_real tmp233;
1597
                    fftw_real tmp834;
1598
                    fftw_real tmp835;
1599
                    ASSERT_ALIGNED_DOUBLE();
1600
                    tmp210 = tmp198 + tmp209;
1601
                    tmp233 = tmp221 + tmp232;
1602
                    tmp234 = tmp210 + tmp233;
1603
                    tmp977 = tmp210 - tmp233;
1604
                    tmp834 = tmp832 - tmp833;
1605
                    tmp835 = tmp232 - tmp221;
1606
                    tmp836 = tmp834 - tmp835;
1607
                    tmp923 = tmp834 + tmp835;
1608
               }
1609
               {
1610
                    fftw_real tmp972;
1611
                    fftw_real tmp973;
1612
                    fftw_real tmp849;
1613
                    fftw_real tmp852;
1614
                    ASSERT_ALIGNED_DOUBLE();
1615
                    tmp972 = tmp832 + tmp833;
1616
                    tmp973 = tmp850 + tmp851;
1617
                    tmp974 = tmp972 - tmp973;
1618
                    tmp1021 = tmp972 + tmp973;
1619
                    tmp849 = tmp198 - tmp209;
1620
                    tmp852 = tmp850 - tmp851;
1621
                    tmp853 = tmp849 - tmp852;
1622
                    tmp920 = tmp849 + tmp852;
1623
               }
1624
               {
1625
                    fftw_real tmp478;
1626
                    fftw_real tmp479;
1627
                    fftw_real tmp517;
1628
                    fftw_real tmp520;
1629
                    ASSERT_ALIGNED_DOUBLE();
1630
                    tmp478 = tmp476 - tmp477;
1631
                    tmp479 = tmp203 - tmp208;
1632
                    tmp480 = tmp478 + tmp479;
1633
                    tmp684 = tmp478 - tmp479;
1634
                    tmp517 = tmp192 - tmp197;
1635
                    tmp520 = tmp518 - tmp519;
1636
                    tmp521 = tmp517 - tmp520;
1637
                    tmp695 = tmp517 + tmp520;
1638
               }
1639
               {
1640
                    fftw_real tmp522;
1641
                    fftw_real tmp523;
1642
                    fftw_real tmp485;
1643
                    fftw_real tmp490;
1644
                    ASSERT_ALIGNED_DOUBLE();
1645
                    tmp522 = tmp489 - tmp486;
1646
                    tmp523 = tmp481 + tmp484;
1647
                    tmp524 = K707106781 * (tmp522 - tmp523);
1648
                    tmp685 = K707106781 * (tmp522 + tmp523);
1649
                    tmp485 = tmp481 - tmp484;
1650
                    tmp490 = tmp486 + tmp489;
1651
                    tmp491 = K707106781 * (tmp485 - tmp490);
1652
                    tmp696 = K707106781 * (tmp490 + tmp485);
1653
               }
1654
          }
1655
          {
1656
               fftw_real tmp245;
1657
               fftw_real tmp509;
1658
               fftw_real tmp506;
1659
               fftw_real tmp843;
1660
               fftw_real tmp279;
1661
               fftw_real tmp501;
1662
               fftw_real tmp496;
1663
               fftw_real tmp839;
1664
               fftw_real tmp256;
1665
               fftw_real tmp507;
1666
               fftw_real tmp512;
1667
               fftw_real tmp844;
1668
               fftw_real tmp268;
1669
               fftw_real tmp493;
1670
               fftw_real tmp500;
1671
               fftw_real tmp838;
1672
               ASSERT_ALIGNED_DOUBLE();
1673
               {
1674
                    fftw_real tmp239;
1675
                    fftw_real tmp504;
1676
                    fftw_real tmp244;
1677
                    fftw_real tmp505;
1678
                    ASSERT_ALIGNED_DOUBLE();
1679
                    {
1680
                         fftw_real tmp236;
1681
                         fftw_real tmp238;
1682
                         fftw_real tmp235;
1683
                         fftw_real tmp237;
1684
                         ASSERT_ALIGNED_DOUBLE();
1685
                         tmp236 = c_re(inout[5 * iostride]);
1686
                         tmp238 = c_im(inout[5 * iostride]);
1687
                         tmp235 = c_re(W[4]);
1688
                         tmp237 = c_im(W[4]);
1689
                         tmp239 = (tmp235 * tmp236) - (tmp237 * tmp238);
1690
                         tmp504 = (tmp237 * tmp236) + (tmp235 * tmp238);
1691
                    }
1692
                    {
1693
                         fftw_real tmp241;
1694
                         fftw_real tmp243;
1695
                         fftw_real tmp240;
1696
                         fftw_real tmp242;
1697
                         ASSERT_ALIGNED_DOUBLE();
1698
                         tmp241 = c_re(inout[37 * iostride]);
1699
                         tmp243 = c_im(inout[37 * iostride]);
1700
                         tmp240 = c_re(W[36]);
1701
                         tmp242 = c_im(W[36]);
1702
                         tmp244 = (tmp240 * tmp241) - (tmp242 * tmp243);
1703
                         tmp505 = (tmp242 * tmp241) + (tmp240 * tmp243);
1704
                    }
1705
                    tmp245 = tmp239 + tmp244;
1706
                    tmp509 = tmp239 - tmp244;
1707
                    tmp506 = tmp504 - tmp505;
1708
                    tmp843 = tmp504 + tmp505;
1709
               }
1710
               {
1711
                    fftw_real tmp273;
1712
                    fftw_real tmp494;
1713
                    fftw_real tmp278;
1714
                    fftw_real tmp495;
1715
                    ASSERT_ALIGNED_DOUBLE();
1716
                    {
1717
                         fftw_real tmp270;
1718
                         fftw_real tmp272;
1719
                         fftw_real tmp269;
1720
                         fftw_real tmp271;
1721
                         ASSERT_ALIGNED_DOUBLE();
1722
                         tmp270 = c_re(inout[13 * iostride]);
1723
                         tmp272 = c_im(inout[13 * iostride]);
1724
                         tmp269 = c_re(W[12]);
1725
                         tmp271 = c_im(W[12]);
1726
                         tmp273 = (tmp269 * tmp270) - (tmp271 * tmp272);
1727
                         tmp494 = (tmp271 * tmp270) + (tmp269 * tmp272);
1728
                    }
1729
                    {
1730
                         fftw_real tmp275;
1731
                         fftw_real tmp277;
1732
                         fftw_real tmp274;
1733
                         fftw_real tmp276;
1734
                         ASSERT_ALIGNED_DOUBLE();
1735
                         tmp275 = c_re(inout[45 * iostride]);
1736
                         tmp277 = c_im(inout[45 * iostride]);
1737
                         tmp274 = c_re(W[44]);
1738
                         tmp276 = c_im(W[44]);
1739
                         tmp278 = (tmp274 * tmp275) - (tmp276 * tmp277);
1740
                         tmp495 = (tmp276 * tmp275) + (tmp274 * tmp277);
1741
                    }
1742
                    tmp279 = tmp273 + tmp278;
1743
                    tmp501 = tmp273 - tmp278;
1744
                    tmp496 = tmp494 - tmp495;
1745
                    tmp839 = tmp494 + tmp495;
1746
               }
1747
               {
1748
                    fftw_real tmp250;
1749
                    fftw_real tmp510;
1750
                    fftw_real tmp255;
1751
                    fftw_real tmp511;
1752
                    ASSERT_ALIGNED_DOUBLE();
1753
                    {
1754
                         fftw_real tmp247;
1755
                         fftw_real tmp249;
1756
                         fftw_real tmp246;
1757
                         fftw_real tmp248;
1758
                         ASSERT_ALIGNED_DOUBLE();
1759
                         tmp247 = c_re(inout[21 * iostride]);
1760
                         tmp249 = c_im(inout[21 * iostride]);
1761
                         tmp246 = c_re(W[20]);
1762
                         tmp248 = c_im(W[20]);
1763
                         tmp250 = (tmp246 * tmp247) - (tmp248 * tmp249);
1764
                         tmp510 = (tmp248 * tmp247) + (tmp246 * tmp249);
1765
                    }
1766
                    {
1767
                         fftw_real tmp252;
1768
                         fftw_real tmp254;
1769
                         fftw_real tmp251;
1770
                         fftw_real tmp253;
1771
                         ASSERT_ALIGNED_DOUBLE();
1772
                         tmp252 = c_re(inout[53 * iostride]);
1773
                         tmp254 = c_im(inout[53 * iostride]);
1774
                         tmp251 = c_re(W[52]);
1775
                         tmp253 = c_im(W[52]);
1776
                         tmp255 = (tmp251 * tmp252) - (tmp253 * tmp254);
1777
                         tmp511 = (tmp253 * tmp252) + (tmp251 * tmp254);
1778
                    }
1779
                    tmp256 = tmp250 + tmp255;
1780
                    tmp507 = tmp250 - tmp255;
1781
                    tmp512 = tmp510 - tmp511;
1782
                    tmp844 = tmp510 + tmp511;
1783
               }
1784
               {
1785
                    fftw_real tmp262;
1786
                    fftw_real tmp498;
1787
                    fftw_real tmp267;
1788
                    fftw_real tmp499;
1789
                    ASSERT_ALIGNED_DOUBLE();
1790
                    {
1791
                         fftw_real tmp259;
1792
                         fftw_real tmp261;
1793
                         fftw_real tmp258;
1794
                         fftw_real tmp260;
1795
                         ASSERT_ALIGNED_DOUBLE();
1796
                         tmp259 = c_re(inout[61 * iostride]);
1797
                         tmp261 = c_im(inout[61 * iostride]);
1798
                         tmp258 = c_re(W[60]);
1799
                         tmp260 = c_im(W[60]);
1800
                         tmp262 = (tmp258 * tmp259) - (tmp260 * tmp261);
1801
                         tmp498 = (tmp260 * tmp259) + (tmp258 * tmp261);
1802
                    }
1803
                    {
1804
                         fftw_real tmp264;
1805
                         fftw_real tmp266;
1806
                         fftw_real tmp263;
1807
                         fftw_real tmp265;
1808
                         ASSERT_ALIGNED_DOUBLE();
1809
                         tmp264 = c_re(inout[29 * iostride]);
1810
                         tmp266 = c_im(inout[29 * iostride]);
1811
                         tmp263 = c_re(W[28]);
1812
                         tmp265 = c_im(W[28]);
1813
                         tmp267 = (tmp263 * tmp264) - (tmp265 * tmp266);
1814
                         tmp499 = (tmp265 * tmp264) + (tmp263 * tmp266);
1815
                    }
1816
                    tmp268 = tmp262 + tmp267;
1817
                    tmp493 = tmp262 - tmp267;
1818
                    tmp500 = tmp498 - tmp499;
1819
                    tmp838 = tmp498 + tmp499;
1820
               }
1821
               {
1822
                    fftw_real tmp257;
1823
                    fftw_real tmp280;
1824
                    fftw_real tmp837;
1825
                    fftw_real tmp840;
1826
                    ASSERT_ALIGNED_DOUBLE();
1827
                    tmp257 = tmp245 + tmp256;
1828
                    tmp280 = tmp268 + tmp279;
1829
                    tmp281 = tmp257 + tmp280;
1830
                    tmp975 = tmp280 - tmp257;
1831
                    tmp837 = tmp268 - tmp279;
1832
                    tmp840 = tmp838 - tmp839;
1833
                    tmp841 = tmp837 - tmp840;
1834
                    tmp855 = tmp837 + tmp840;
1835
               }
1836
               {
1837
                    fftw_real tmp978;
1838
                    fftw_real tmp979;
1839
                    fftw_real tmp842;
1840
                    fftw_real tmp845;
1841
                    ASSERT_ALIGNED_DOUBLE();
1842
                    tmp978 = tmp843 + tmp844;
1843
                    tmp979 = tmp838 + tmp839;
1844
                    tmp980 = tmp978 - tmp979;
1845
                    tmp1022 = tmp978 + tmp979;
1846
                    tmp842 = tmp245 - tmp256;
1847
                    tmp845 = tmp843 - tmp844;
1848
                    tmp846 = tmp842 + tmp845;
1849
                    tmp854 = tmp845 - tmp842;
1850
               }
1851
               {
1852
                    fftw_real tmp497;
1853
                    fftw_real tmp502;
1854
                    fftw_real tmp687;
1855
                    fftw_real tmp688;
1856
                    ASSERT_ALIGNED_DOUBLE();
1857
                    tmp497 = tmp493 - tmp496;
1858
                    tmp502 = tmp500 + tmp501;
1859
                    tmp503 = (K382683432 * tmp497) - (K923879532 * tmp502);
1860
                    tmp527 = (K382683432 * tmp502) + (K923879532 * tmp497);
1861
                    tmp687 = tmp493 + tmp496;
1862
                    tmp688 = tmp500 - tmp501;
1863
                    tmp689 = (K923879532 * tmp687) - (K382683432 * tmp688);
1864
                    tmp699 = (K923879532 * tmp688) + (K382683432 * tmp687);
1865
               }
1866
               {
1867
                    fftw_real tmp508;
1868
                    fftw_real tmp513;
1869
                    fftw_real tmp690;
1870
                    fftw_real tmp691;
1871
                    ASSERT_ALIGNED_DOUBLE();
1872
                    tmp508 = tmp506 + tmp507;
1873
                    tmp513 = tmp509 - tmp512;
1874
                    tmp514 = (K923879532 * tmp508) + (K382683432 * tmp513);
1875
                    tmp526 = (K382683432 * tmp508) - (K923879532 * tmp513);
1876
                    tmp690 = tmp506 - tmp507;
1877
                    tmp691 = tmp509 + tmp512;
1878
                    tmp692 = (K382683432 * tmp690) + (K923879532 * tmp691);
1879
                    tmp698 = (K923879532 * tmp690) - (K382683432 * tmp691);
1880
               }
1881
          }
1882
          {
1883
               fftw_real tmp91;
1884
               fftw_real tmp1015;
1885
               fftw_real tmp1038;
1886
               fftw_real tmp1039;
1887
               fftw_real tmp1049;
1888
               fftw_real tmp1055;
1889
               fftw_real tmp186;
1890
               fftw_real tmp1054;
1891
               fftw_real tmp1024;
1892
               fftw_real tmp1032;
1893
               fftw_real tmp378;
1894
               fftw_real tmp1051;
1895
               fftw_real tmp1029;
1896
               fftw_real tmp1033;
1897
               fftw_real tmp1018;
1898
               fftw_real tmp1040;
1899
               ASSERT_ALIGNED_DOUBLE();
1900
               {
1901
                    fftw_real tmp43;
1902
                    fftw_real tmp90;
1903
                    fftw_real tmp1036;
1904
                    fftw_real tmp1037;
1905
                    ASSERT_ALIGNED_DOUBLE();
1906
                    tmp43 = tmp19 + tmp42;
1907
                    tmp90 = tmp66 + tmp89;
1908
                    tmp91 = tmp43 + tmp90;
1909
                    tmp1015 = tmp43 - tmp90;
1910
                    tmp1036 = tmp1021 + tmp1022;
1911
                    tmp1037 = tmp1026 + tmp1027;
1912
                    tmp1038 = tmp1036 - tmp1037;
1913
                    tmp1039 = tmp1036 + tmp1037;
1914
               }
1915
               {
1916
                    fftw_real tmp1041;
1917
                    fftw_real tmp1048;
1918
                    fftw_real tmp138;
1919
                    fftw_real tmp185;
1920
                    ASSERT_ALIGNED_DOUBLE();
1921
                    tmp1041 = tmp956 + tmp957;
1922
                    tmp1048 = tmp1042 + tmp1047;
1923
                    tmp1049 = tmp1041 + tmp1048;
1924
                    tmp1055 = tmp1048 - tmp1041;
1925
                    tmp138 = tmp114 + tmp137;
1926
                    tmp185 = tmp161 + tmp184;
1927
                    tmp186 = tmp138 + tmp185;
1928
                    tmp1054 = tmp185 - tmp138;
1929
               }
1930
               {
1931
                    fftw_real tmp1020;
1932
                    fftw_real tmp1023;
1933
                    fftw_real tmp282;
1934
                    fftw_real tmp377;
1935
                    ASSERT_ALIGNED_DOUBLE();
1936
                    tmp1020 = tmp234 - tmp281;
1937
                    tmp1023 = tmp1021 - tmp1022;
1938
                    tmp1024 = tmp1020 + tmp1023;
1939
                    tmp1032 = tmp1023 - tmp1020;
1940
                    tmp282 = tmp234 + tmp281;
1941
                    tmp377 = tmp329 + tmp376;
1942
                    tmp378 = tmp282 + tmp377;
1943
                    tmp1051 = tmp377 - tmp282;
1944
               }
1945
               {
1946
                    fftw_real tmp1025;
1947
                    fftw_real tmp1028;
1948
                    fftw_real tmp1016;
1949
                    fftw_real tmp1017;
1950
                    ASSERT_ALIGNED_DOUBLE();
1951
                    tmp1025 = tmp329 - tmp376;
1952
                    tmp1028 = tmp1026 - tmp1027;
1953
                    tmp1029 = tmp1025 - tmp1028;
1954
                    tmp1033 = tmp1025 + tmp1028;
1955
                    tmp1016 = tmp960 + tmp961;
1956
                    tmp1017 = tmp966 + tmp967;
1957
                    tmp1018 = tmp1016 - tmp1017;
1958
                    tmp1040 = tmp1016 + tmp1017;
1959
               }
1960
               {
1961
                    fftw_real tmp187;
1962
                    fftw_real tmp1035;
1963
                    fftw_real tmp1050;
1964
                    fftw_real tmp1052;
1965
                    ASSERT_ALIGNED_DOUBLE();
1966
                    tmp187 = tmp91 + tmp186;
1967
                    c_re(inout[32 * iostride]) = tmp187 - tmp378;
1968
                    c_re(inout[0]) = tmp187 + tmp378;
1969
                    tmp1035 = tmp91 - tmp186;
1970
                    c_re(inout[48 * iostride]) = tmp1035 - tmp1038;
1971
                    c_re(inout[16 * iostride]) = tmp1035 + tmp1038;
1972
                    {
1973
                         fftw_real tmp1019;
1974
                         fftw_real tmp1030;
1975
                         fftw_real tmp1057;
1976
                         fftw_real tmp1058;
1977
                         ASSERT_ALIGNED_DOUBLE();
1978
                         tmp1019 = tmp1015 + tmp1018;
1979
                         tmp1030 = K707106781 * (tmp1024 + tmp1029);
1980
                         c_re(inout[40 * iostride]) = tmp1019 - tmp1030;
1981
                         c_re(inout[8 * iostride]) = tmp1019 + tmp1030;
1982
                         tmp1057 = K707106781 * (tmp1029 - tmp1024);
1983
                         tmp1058 = tmp1055 - tmp1054;
1984
                         c_im(inout[24 * iostride]) = tmp1057 + tmp1058;
1985
                         c_im(inout[56 * iostride]) = tmp1058 - tmp1057;
1986
                    }
1987
                    tmp1050 = tmp1040 + tmp1049;
1988
                    c_im(inout[0]) = tmp1039 + tmp1050;
1989
                    c_im(inout[32 * iostride]) = tmp1050 - tmp1039;
1990
                    tmp1052 = tmp1049 - tmp1040;
1991
                    c_im(inout[16 * iostride]) = tmp1051 + tmp1052;
1992
                    c_im(inout[48 * iostride]) = tmp1052 - tmp1051;
1993
                    {
1994
                         fftw_real tmp1053;
1995
                         fftw_real tmp1056;
1996
                         fftw_real tmp1031;
1997
                         fftw_real tmp1034;
1998
                         ASSERT_ALIGNED_DOUBLE();
1999
                         tmp1053 = K707106781 * (tmp1032 + tmp1033);
2000
                         tmp1056 = tmp1054 + tmp1055;
2001
                         c_im(inout[8 * iostride]) = tmp1053 + tmp1056;
2002
                         c_im(inout[40 * iostride]) = tmp1056 - tmp1053;
2003
                         tmp1031 = tmp1015 - tmp1018;
2004
                         tmp1034 = K707106781 * (tmp1032 - tmp1033);
2005
                         c_re(inout[56 * iostride]) = tmp1031 - tmp1034;
2006
                         c_re(inout[24 * iostride]) = tmp1031 + tmp1034;
2007
                    }
2008
               }
2009
          }
2010
          {
2011
               fftw_real tmp959;
2012
               fftw_real tmp999;
2013
               fftw_real tmp1002;
2014
               fftw_real tmp1068;
2015
               fftw_real tmp970;
2016
               fftw_real tmp1060;
2017
               fftw_real tmp1063;
2018
               fftw_real tmp1069;
2019
               fftw_real tmp982;
2020
               fftw_real tmp996;
2021
               fftw_real tmp1006;
2022
               fftw_real tmp1012;
2023
               fftw_real tmp993;
2024
               fftw_real tmp997;
2025
               fftw_real tmp1009;
2026
               fftw_real tmp1013;
2027
               ASSERT_ALIGNED_DOUBLE();
2028
               {
2029
                    fftw_real tmp955;
2030
                    fftw_real tmp958;
2031
                    fftw_real tmp1000;
2032
                    fftw_real tmp1001;
2033
                    ASSERT_ALIGNED_DOUBLE();
2034
                    tmp955 = tmp19 - tmp42;
2035
                    tmp958 = tmp956 - tmp957;
2036
                    tmp959 = tmp955 - tmp958;
2037
                    tmp999 = tmp955 + tmp958;
2038
                    tmp1000 = tmp963 + tmp962;
2039
                    tmp1001 = tmp965 - tmp968;
2040
                    tmp1002 = K707106781 * (tmp1000 + tmp1001);
2041
                    tmp1068 = K707106781 * (tmp1001 - tmp1000);
2042
               }
2043
               {
2044
                    fftw_real tmp964;
2045
                    fftw_real tmp969;
2046
                    fftw_real tmp1061;
2047
                    fftw_real tmp1062;
2048
                    ASSERT_ALIGNED_DOUBLE();
2049
                    tmp964 = tmp962 - tmp963;
2050
                    tmp969 = tmp965 + tmp968;
2051
                    tmp970 = K707106781 * (tmp964 - tmp969);
2052
                    tmp1060 = K707106781 * (tmp964 + tmp969);
2053
                    tmp1061 = tmp89 - tmp66;
2054
                    tmp1062 = tmp1047 - tmp1042;
2055
                    tmp1063 = tmp1061 + tmp1062;
2056
                    tmp1069 = tmp1062 - tmp1061;
2057
               }
2058
               {
2059
                    fftw_real tmp976;
2060
                    fftw_real tmp981;
2061
                    fftw_real tmp1004;
2062
                    fftw_real tmp1005;
2063
                    ASSERT_ALIGNED_DOUBLE();
2064
                    tmp976 = tmp974 - tmp975;
2065
                    tmp981 = tmp977 - tmp980;
2066
                    tmp982 = (K923879532 * tmp976) + (K382683432 * tmp981);
2067
                    tmp996 = (K382683432 * tmp976) - (K923879532 * tmp981);
2068
                    tmp1004 = tmp974 + tmp975;
2069
                    tmp1005 = tmp977 + tmp980;
2070
                    tmp1006 = (K382683432 * tmp1004) + (K923879532 * tmp1005);
2071
                    tmp1012 = (K923879532 * tmp1004) - (K382683432 * tmp1005);
2072
               }
2073
               {
2074
                    fftw_real tmp987;
2075
                    fftw_real tmp992;
2076
                    fftw_real tmp1007;
2077
                    fftw_real tmp1008;
2078
                    ASSERT_ALIGNED_DOUBLE();
2079
                    tmp987 = tmp983 - tmp986;
2080
                    tmp992 = tmp990 - tmp991;
2081
                    tmp993 = (K382683432 * tmp987) - (K923879532 * tmp992);
2082
                    tmp997 = (K382683432 * tmp992) + (K923879532 * tmp987);
2083
                    tmp1007 = tmp983 + tmp986;
2084
                    tmp1008 = tmp990 + tmp991;
2085
                    tmp1009 = (K923879532 * tmp1007) - (K382683432 * tmp1008);
2086
                    tmp1013 = (K923879532 * tmp1008) + (K382683432 * tmp1007);
2087
               }
2088
               {
2089
                    fftw_real tmp971;
2090
                    fftw_real tmp994;
2091
                    fftw_real tmp995;
2092
                    fftw_real tmp998;
2093
                    ASSERT_ALIGNED_DOUBLE();
2094
                    tmp971 = tmp959 + tmp970;
2095
                    tmp994 = tmp982 + tmp993;
2096
                    c_re(inout[44 * iostride]) = tmp971 - tmp994;
2097
                    c_re(inout[12 * iostride]) = tmp971 + tmp994;
2098
                    tmp995 = tmp959 - tmp970;
2099
                    tmp998 = tmp996 - tmp997;
2100
                    c_re(inout[60 * iostride]) = tmp995 - tmp998;
2101
                    c_re(inout[28 * iostride]) = tmp995 + tmp998;
2102
               }
2103
               {
2104
                    fftw_real tmp1067;
2105
                    fftw_real tmp1070;
2106
                    fftw_real tmp1071;
2107
                    fftw_real tmp1072;
2108
                    ASSERT_ALIGNED_DOUBLE();
2109
                    tmp1067 = tmp996 + tmp997;
2110
                    tmp1070 = tmp1068 + tmp1069;
2111
                    c_im(inout[12 * iostride]) = tmp1067 + tmp1070;
2112
                    c_im(inout[44 * iostride]) = tmp1070 - tmp1067;
2113
                    tmp1071 = tmp993 - tmp982;
2114
                    tmp1072 = tmp1069 - tmp1068;
2115
                    c_im(inout[28 * iostride]) = tmp1071 + tmp1072;
2116
                    c_im(inout[60 * iostride]) = tmp1072 - tmp1071;
2117
               }
2118
               {
2119
                    fftw_real tmp1003;
2120
                    fftw_real tmp1010;
2121
                    fftw_real tmp1011;
2122
                    fftw_real tmp1014;
2123
                    ASSERT_ALIGNED_DOUBLE();
2124
                    tmp1003 = tmp999 + tmp1002;
2125
                    tmp1010 = tmp1006 + tmp1009;
2126
                    c_re(inout[36 * iostride]) = tmp1003 - tmp1010;
2127
                    c_re(inout[4 * iostride]) = tmp1003 + tmp1010;
2128
                    tmp1011 = tmp999 - tmp1002;
2129
                    tmp1014 = tmp1012 - tmp1013;
2130
                    c_re(inout[52 * iostride]) = tmp1011 - tmp1014;
2131
                    c_re(inout[20 * iostride]) = tmp1011 + tmp1014;
2132
               }
2133
               {
2134
                    fftw_real tmp1059;
2135
                    fftw_real tmp1064;
2136
                    fftw_real tmp1065;
2137
                    fftw_real tmp1066;
2138
                    ASSERT_ALIGNED_DOUBLE();
2139
                    tmp1059 = tmp1012 + tmp1013;
2140
                    tmp1064 = tmp1060 + tmp1063;
2141
                    c_im(inout[4 * iostride]) = tmp1059 + tmp1064;
2142
                    c_im(inout[36 * iostride]) = tmp1064 - tmp1059;
2143
                    tmp1065 = tmp1009 - tmp1006;
2144
                    tmp1066 = tmp1063 - tmp1060;
2145
                    c_im(inout[20 * iostride]) = tmp1065 + tmp1066;
2146
                    c_im(inout[52 * iostride]) = tmp1066 - tmp1065;
2147
               }
2148
          }
2149
          {
2150
               fftw_real tmp419;
2151
               fftw_real tmp591;
2152
               fftw_real tmp1155;
2153
               fftw_real tmp1161;
2154
               fftw_real tmp474;
2155
               fftw_real tmp1152;
2156
               fftw_real tmp594;
2157
               fftw_real tmp1160;
2158
               fftw_real tmp530;
2159
               fftw_real tmp588;
2160
               fftw_real tmp598;
2161
               fftw_real tmp604;
2162
               fftw_real tmp585;
2163
               fftw_real tmp589;
2164
               fftw_real tmp601;
2165
               fftw_real tmp605;
2166
               ASSERT_ALIGNED_DOUBLE();
2167
               {
2168
                    fftw_real tmp395;
2169
                    fftw_real tmp418;
2170
                    fftw_real tmp1153;
2171
                    fftw_real tmp1154;
2172
                    ASSERT_ALIGNED_DOUBLE();
2173
                    tmp395 = tmp383 - tmp394;
2174
                    tmp418 = tmp406 - tmp417;
2175
                    tmp419 = tmp395 - tmp418;
2176
                    tmp591 = tmp395 + tmp418;
2177
                    tmp1153 = tmp609 - tmp608;
2178
                    tmp1154 = tmp1139 - tmp1138;
2179
                    tmp1155 = tmp1153 + tmp1154;
2180
                    tmp1161 = tmp1154 - tmp1153;
2181
               }
2182
               {
2183
                    fftw_real tmp446;
2184
                    fftw_real tmp592;
2185
                    fftw_real tmp473;
2186
                    fftw_real tmp593;
2187
                    ASSERT_ALIGNED_DOUBLE();
2188
                    {
2189
                         fftw_real tmp436;
2190
                         fftw_real tmp445;
2191
                         fftw_real tmp463;
2192
                         fftw_real tmp472;
2193
                         ASSERT_ALIGNED_DOUBLE();
2194
                         tmp436 = tmp424 - tmp435;
2195
                         tmp445 = tmp441 - tmp444;
2196
                         tmp446 = (K195090322 * tmp436) - (K980785280 * tmp445);
2197
                         tmp592 = (K980785280 * tmp436) + (K195090322 * tmp445);
2198
                         tmp463 = tmp451 - tmp462;
2199
                         tmp472 = tmp468 - tmp471;
2200
                         tmp473 = (K195090322 * tmp463) + (K980785280 * tmp472);
2201
                         tmp593 = (K195090322 * tmp472) - (K980785280 * tmp463);
2202
                    }
2203
                    tmp474 = tmp446 - tmp473;
2204
                    tmp1152 = tmp446 + tmp473;
2205
                    tmp594 = tmp592 + tmp593;
2206
                    tmp1160 = tmp593 - tmp592;
2207
               }
2208
               {
2209
                    fftw_real tmp516;
2210
                    fftw_real tmp596;
2211
                    fftw_real tmp529;
2212
                    fftw_real tmp597;
2213
                    ASSERT_ALIGNED_DOUBLE();
2214
                    {
2215
                         fftw_real tmp492;
2216
                         fftw_real tmp515;
2217
                         fftw_real tmp525;
2218
                         fftw_real tmp528;
2219
                         ASSERT_ALIGNED_DOUBLE();
2220
                         tmp492 = tmp480 - tmp491;
2221
                         tmp515 = tmp503 - tmp514;
2222
                         tmp516 = tmp492 - tmp515;
2223
                         tmp596 = tmp492 + tmp515;
2224
                         tmp525 = tmp521 - tmp524;
2225
                         tmp528 = tmp526 - tmp527;
2226
                         tmp529 = tmp525 - tmp528;
2227
                         tmp597 = tmp525 + tmp528;
2228
                    }
2229
                    tmp530 = (K995184726 * tmp516) + (K098017140 * tmp529);
2230
                    tmp588 = (K098017140 * tmp516) - (K995184726 * tmp529);
2231
                    tmp598 = (K634393284 * tmp596) + (K773010453 * tmp597);
2232
                    tmp604 = (K773010453 * tmp596) - (K634393284 * tmp597);
2233
               }
2234
               {
2235
                    fftw_real tmp571;
2236
                    fftw_real tmp599;
2237
                    fftw_real tmp584;
2238
                    fftw_real tmp600;
2239
                    ASSERT_ALIGNED_DOUBLE();
2240
                    {
2241
                         fftw_real tmp547;
2242
                         fftw_real tmp570;
2243
                         fftw_real tmp580;
2244
                         fftw_real tmp583;
2245
                         ASSERT_ALIGNED_DOUBLE();
2246
                         tmp547 = tmp535 - tmp546;
2247
                         tmp570 = tmp558 - tmp569;
2248
                         tmp571 = tmp547 - tmp570;
2249
                         tmp599 = tmp547 + tmp570;
2250
                         tmp580 = tmp576 - tmp579;
2251
                         tmp583 = tmp581 - tmp582;
2252
                         tmp584 = tmp580 - tmp583;
2253
                         tmp600 = tmp580 + tmp583;
2254
                    }
2255
                    tmp585 = (K098017140 * tmp571) - (K995184726 * tmp584);
2256
                    tmp589 = (K098017140 * tmp584) + (K995184726 * tmp571);
2257
                    tmp601 = (K773010453 * tmp599) - (K634393284 * tmp600);
2258
                    tmp605 = (K773010453 * tmp600) + (K634393284 * tmp599);
2259
               }
2260
               {
2261
                    fftw_real tmp475;
2262
                    fftw_real tmp586;
2263
                    fftw_real tmp587;
2264
                    fftw_real tmp590;
2265
                    ASSERT_ALIGNED_DOUBLE();
2266
                    tmp475 = tmp419 + tmp474;
2267
                    tmp586 = tmp530 + tmp585;
2268
                    c_re(inout[47 * iostride]) = tmp475 - tmp586;
2269
                    c_re(inout[15 * iostride]) = tmp475 + tmp586;
2270
                    tmp587 = tmp419 - tmp474;
2271
                    tmp590 = tmp588 - tmp589;
2272
                    c_re(inout[63 * iostride]) = tmp587 - tmp590;
2273
                    c_re(inout[31 * iostride]) = tmp587 + tmp590;
2274
               }
2275
               {
2276
                    fftw_real tmp1159;
2277
                    fftw_real tmp1162;
2278
                    fftw_real tmp1163;
2279
                    fftw_real tmp1164;
2280
                    ASSERT_ALIGNED_DOUBLE();
2281
                    tmp1159 = tmp588 + tmp589;
2282
                    tmp1162 = tmp1160 + tmp1161;
2283
                    c_im(inout[15 * iostride]) = tmp1159 + tmp1162;
2284
                    c_im(inout[47 * iostride]) = tmp1162 - tmp1159;
2285
                    tmp1163 = tmp585 - tmp530;
2286
                    tmp1164 = tmp1161 - tmp1160;
2287
                    c_im(inout[31 * iostride]) = tmp1163 + tmp1164;
2288
                    c_im(inout[63 * iostride]) = tmp1164 - tmp1163;
2289
               }
2290
               {
2291
                    fftw_real tmp595;
2292
                    fftw_real tmp602;
2293
                    fftw_real tmp603;
2294
                    fftw_real tmp606;
2295
                    ASSERT_ALIGNED_DOUBLE();
2296
                    tmp595 = tmp591 + tmp594;
2297
                    tmp602 = tmp598 + tmp601;
2298
                    c_re(inout[39 * iostride]) = tmp595 - tmp602;
2299
                    c_re(inout[7 * iostride]) = tmp595 + tmp602;
2300
                    tmp603 = tmp591 - tmp594;
2301
                    tmp606 = tmp604 - tmp605;
2302
                    c_re(inout[55 * iostride]) = tmp603 - tmp606;
2303
                    c_re(inout[23 * iostride]) = tmp603 + tmp606;
2304
               }
2305
               {
2306
                    fftw_real tmp1151;
2307
                    fftw_real tmp1156;
2308
                    fftw_real tmp1157;
2309
                    fftw_real tmp1158;
2310
                    ASSERT_ALIGNED_DOUBLE();
2311
                    tmp1151 = tmp604 + tmp605;
2312
                    tmp1156 = tmp1152 + tmp1155;
2313
                    c_im(inout[7 * iostride]) = tmp1151 + tmp1156;
2314
                    c_im(inout[39 * iostride]) = tmp1156 - tmp1151;
2315
                    tmp1157 = tmp601 - tmp598;
2316
                    tmp1158 = tmp1155 - tmp1152;
2317
                    c_im(inout[23 * iostride]) = tmp1157 + tmp1158;
2318
                    c_im(inout[55 * iostride]) = tmp1158 - tmp1157;
2319
               }
2320
          }
2321
          {
2322
               fftw_real tmp611;
2323
               fftw_real tmp639;
2324
               fftw_real tmp1141;
2325
               fftw_real tmp1147;
2326
               fftw_real tmp618;
2327
               fftw_real tmp1136;
2328
               fftw_real tmp642;
2329
               fftw_real tmp1146;
2330
               fftw_real tmp626;
2331
               fftw_real tmp636;
2332
               fftw_real tmp646;
2333
               fftw_real tmp652;
2334
               fftw_real tmp633;
2335
               fftw_real tmp637;
2336
               fftw_real tmp649;
2337
               fftw_real tmp653;
2338
               ASSERT_ALIGNED_DOUBLE();
2339
               {
2340
                    fftw_real tmp607;
2341
                    fftw_real tmp610;
2342
                    fftw_real tmp1137;
2343
                    fftw_real tmp1140;
2344
                    ASSERT_ALIGNED_DOUBLE();
2345
                    tmp607 = tmp383 + tmp394;
2346
                    tmp610 = tmp608 + tmp609;
2347
                    tmp611 = tmp607 - tmp610;
2348
                    tmp639 = tmp607 + tmp610;
2349
                    tmp1137 = tmp406 + tmp417;
2350
                    tmp1140 = tmp1138 + tmp1139;
2351
                    tmp1141 = tmp1137 + tmp1140;
2352
                    tmp1147 = tmp1140 - tmp1137;
2353
               }
2354
               {
2355
                    fftw_real tmp614;
2356
                    fftw_real tmp640;
2357
                    fftw_real tmp617;
2358
                    fftw_real tmp641;
2359
                    ASSERT_ALIGNED_DOUBLE();
2360
                    {
2361
                         fftw_real tmp612;
2362
                         fftw_real tmp613;
2363
                         fftw_real tmp615;
2364
                         fftw_real tmp616;
2365
                         ASSERT_ALIGNED_DOUBLE();
2366
                         tmp612 = tmp424 + tmp435;
2367
                         tmp613 = tmp441 + tmp444;
2368
                         tmp614 = (K831469612 * tmp612) - (K555570233 * tmp613);
2369
                         tmp640 = (K555570233 * tmp612) + (K831469612 * tmp613);
2370
                         tmp615 = tmp451 + tmp462;
2371
                         tmp616 = tmp468 + tmp471;
2372
                         tmp617 = (K831469612 * tmp615) + (K555570233 * tmp616);
2373
                         tmp641 = (K831469612 * tmp616) - (K555570233 * tmp615);
2374
                    }
2375
                    tmp618 = tmp614 - tmp617;
2376
                    tmp1136 = tmp614 + tmp617;
2377
                    tmp642 = tmp640 + tmp641;
2378
                    tmp1146 = tmp641 - tmp640;
2379
               }
2380
               {
2381
                    fftw_real tmp622;
2382
                    fftw_real tmp644;
2383
                    fftw_real tmp625;
2384
                    fftw_real tmp645;
2385
                    ASSERT_ALIGNED_DOUBLE();
2386
                    {
2387
                         fftw_real tmp620;
2388
                         fftw_real tmp621;
2389
                         fftw_real tmp623;
2390
                         fftw_real tmp624;
2391
                         ASSERT_ALIGNED_DOUBLE();
2392
                         tmp620 = tmp521 + tmp524;
2393
                         tmp621 = tmp514 + tmp503;
2394
                         tmp622 = tmp620 - tmp621;
2395
                         tmp644 = tmp620 + tmp621;
2396
                         tmp623 = tmp480 + tmp491;
2397
                         tmp624 = tmp526 + tmp527;
2398
                         tmp625 = tmp623 - tmp624;
2399
                         tmp645 = tmp623 + tmp624;
2400
                    }
2401
                    tmp626 = (K471396736 * tmp622) + (K881921264 * tmp625);
2402
                    tmp636 = (K471396736 * tmp625) - (K881921264 * tmp622);
2403
                    tmp646 = (K956940335 * tmp644) + (K290284677 * tmp645);
2404
                    tmp652 = (K956940335 * tmp645) - (K290284677 * tmp644);
2405
               }
2406
               {
2407
                    fftw_real tmp629;
2408
                    fftw_real tmp647;
2409
                    fftw_real tmp632;
2410
                    fftw_real tmp648;
2411
                    ASSERT_ALIGNED_DOUBLE();
2412
                    {
2413
                         fftw_real tmp627;
2414
                         fftw_real tmp628;
2415
                         fftw_real tmp630;
2416
                         fftw_real tmp631;
2417
                         ASSERT_ALIGNED_DOUBLE();
2418
                         tmp627 = tmp535 + tmp546;
2419
                         tmp628 = tmp582 + tmp581;
2420
                         tmp629 = tmp627 - tmp628;
2421
                         tmp647 = tmp627 + tmp628;
2422
                         tmp630 = tmp576 + tmp579;
2423
                         tmp631 = tmp558 + tmp569;
2424
                         tmp632 = tmp630 - tmp631;
2425
                         tmp648 = tmp630 + tmp631;
2426
                    }
2427
                    tmp633 = (K471396736 * tmp629) - (K881921264 * tmp632);
2428
                    tmp637 = (K881921264 * tmp629) + (K471396736 * tmp632);
2429
                    tmp649 = (K956940335 * tmp647) - (K290284677 * tmp648);
2430
                    tmp653 = (K290284677 * tmp647) + (K956940335 * tmp648);
2431
               }
2432
               {
2433
                    fftw_real tmp619;
2434
                    fftw_real tmp634;
2435
                    fftw_real tmp635;
2436
                    fftw_real tmp638;
2437
                    ASSERT_ALIGNED_DOUBLE();
2438
                    tmp619 = tmp611 + tmp618;
2439
                    tmp634 = tmp626 + tmp633;
2440
                    c_re(inout[43 * iostride]) = tmp619 - tmp634;
2441
                    c_re(inout[11 * iostride]) = tmp619 + tmp634;
2442
                    tmp635 = tmp611 - tmp618;
2443
                    tmp638 = tmp636 - tmp637;
2444
                    c_re(inout[59 * iostride]) = tmp635 - tmp638;
2445
                    c_re(inout[27 * iostride]) = tmp635 + tmp638;
2446
               }
2447
               {
2448
                    fftw_real tmp1145;
2449
                    fftw_real tmp1148;
2450
                    fftw_real tmp1149;
2451
                    fftw_real tmp1150;
2452
                    ASSERT_ALIGNED_DOUBLE();
2453
                    tmp1145 = tmp636 + tmp637;
2454
                    tmp1148 = tmp1146 + tmp1147;
2455
                    c_im(inout[11 * iostride]) = tmp1145 + tmp1148;
2456
                    c_im(inout[43 * iostride]) = tmp1148 - tmp1145;
2457
                    tmp1149 = tmp633 - tmp626;
2458
                    tmp1150 = tmp1147 - tmp1146;
2459
                    c_im(inout[27 * iostride]) = tmp1149 + tmp1150;
2460
                    c_im(inout[59 * iostride]) = tmp1150 - tmp1149;
2461
               }
2462
               {
2463
                    fftw_real tmp643;
2464
                    fftw_real tmp650;
2465
                    fftw_real tmp651;
2466
                    fftw_real tmp654;
2467
                    ASSERT_ALIGNED_DOUBLE();
2468
                    tmp643 = tmp639 + tmp642;
2469
                    tmp650 = tmp646 + tmp649;
2470
                    c_re(inout[35 * iostride]) = tmp643 - tmp650;
2471
                    c_re(inout[3 * iostride]) = tmp643 + tmp650;
2472
                    tmp651 = tmp639 - tmp642;
2473
                    tmp654 = tmp652 - tmp653;
2474
                    c_re(inout[51 * iostride]) = tmp651 - tmp654;
2475
                    c_re(inout[19 * iostride]) = tmp651 + tmp654;
2476
               }
2477
               {
2478
                    fftw_real tmp1135;
2479
                    fftw_real tmp1142;
2480
                    fftw_real tmp1143;
2481
                    fftw_real tmp1144;
2482
                    ASSERT_ALIGNED_DOUBLE();
2483
                    tmp1135 = tmp652 + tmp653;
2484
                    tmp1142 = tmp1136 + tmp1141;
2485
                    c_im(inout[3 * iostride]) = tmp1135 + tmp1142;
2486
                    c_im(inout[35 * iostride]) = tmp1142 - tmp1135;
2487
                    tmp1143 = tmp649 - tmp646;
2488
                    tmp1144 = tmp1141 - tmp1136;
2489
                    c_im(inout[19 * iostride]) = tmp1143 + tmp1144;
2490
                    c_im(inout[51 * iostride]) = tmp1144 - tmp1143;
2491
               }
2492
          }
2493
          {
2494
               fftw_real tmp807;
2495
               fftw_real tmp891;
2496
               fftw_real tmp830;
2497
               fftw_real tmp1090;
2498
               fftw_real tmp1093;
2499
               fftw_real tmp1099;
2500
               fftw_real tmp894;
2501
               fftw_real tmp1098;
2502
               fftw_real tmp885;
2503
               fftw_real tmp889;
2504
               fftw_real tmp901;
2505
               fftw_real tmp905;
2506
               fftw_real tmp858;
2507
               fftw_real tmp888;
2508
               fftw_real tmp898;
2509
               fftw_real tmp904;
2510
               ASSERT_ALIGNED_DOUBLE();
2511
               {
2512
                    fftw_real tmp795;
2513
                    fftw_real tmp806;
2514
                    fftw_real tmp892;
2515
                    fftw_real tmp893;
2516
                    ASSERT_ALIGNED_DOUBLE();
2517
                    tmp795 = tmp791 - tmp794;
2518
                    tmp806 = K707106781 * (tmp800 - tmp805);
2519
                    tmp807 = tmp795 - tmp806;
2520
                    tmp891 = tmp795 + tmp806;
2521
                    {
2522
                         fftw_real tmp818;
2523
                         fftw_real tmp829;
2524
                         fftw_real tmp1091;
2525
                         fftw_real tmp1092;
2526
                         ASSERT_ALIGNED_DOUBLE();
2527
                         tmp818 = (K382683432 * tmp812) - (K923879532 * tmp817);
2528
                         tmp829 = (K382683432 * tmp823) + (K923879532 * tmp828);
2529
                         tmp830 = tmp818 - tmp829;
2530
                         tmp1090 = tmp818 + tmp829;
2531
                         tmp1091 = K707106781 * (tmp909 - tmp908);
2532
                         tmp1092 = tmp1077 - tmp1076;
2533
                         tmp1093 = tmp1091 + tmp1092;
2534
                         tmp1099 = tmp1092 - tmp1091;
2535
                    }
2536
                    tmp892 = (K923879532 * tmp812) + (K382683432 * tmp817);
2537
                    tmp893 = (K382683432 * tmp828) - (K923879532 * tmp823);
2538
                    tmp894 = tmp892 + tmp893;
2539
                    tmp1098 = tmp893 - tmp892;
2540
                    {
2541
                         fftw_real tmp875;
2542
                         fftw_real tmp899;
2543
                         fftw_real tmp884;
2544
                         fftw_real tmp900;
2545
                         fftw_real tmp874;
2546
                         fftw_real tmp883;
2547
                         ASSERT_ALIGNED_DOUBLE();
2548
                         tmp874 = K707106781 * (tmp868 - tmp873);
2549
                         tmp875 = tmp863 - tmp874;
2550
                         tmp899 = tmp863 + tmp874;
2551
                         tmp883 = K707106781 * (tmp881 - tmp882);
2552
                         tmp884 = tmp880 - tmp883;
2553
                         tmp900 = tmp880 + tmp883;
2554
                         tmp885 = (K195090322 * tmp875) - (K980785280 * tmp884);
2555
                         tmp889 = (K195090322 * tmp884) + (K980785280 * tmp875);
2556
                         tmp901 = (K831469612 * tmp899) - (K555570233 * tmp900);
2557
                         tmp905 = (K831469612 * tmp900) + (K555570233 * tmp899);
2558
                    }
2559
                    {
2560
                         fftw_real tmp848;
2561
                         fftw_real tmp896;
2562
                         fftw_real tmp857;
2563
                         fftw_real tmp897;
2564
                         fftw_real tmp847;
2565
                         fftw_real tmp856;
2566
                         ASSERT_ALIGNED_DOUBLE();
2567
                         tmp847 = K707106781 * (tmp841 - tmp846);
2568
                         tmp848 = tmp836 - tmp847;
2569
                         tmp896 = tmp836 + tmp847;
2570
                         tmp856 = K707106781 * (tmp854 - tmp855);
2571
                         tmp857 = tmp853 - tmp856;
2572
                         tmp897 = tmp853 + tmp856;
2573
                         tmp858 = (K980785280 * tmp848) + (K195090322 * tmp857);
2574
                         tmp888 = (K195090322 * tmp848) - (K980785280 * tmp857);
2575
                         tmp898 = (K555570233 * tmp896) + (K831469612 * tmp897);
2576
                         tmp904 = (K831469612 * tmp896) - (K555570233 * tmp897);
2577
                    }
2578
               }
2579
               {
2580
                    fftw_real tmp831;
2581
                    fftw_real tmp886;
2582
                    fftw_real tmp887;
2583
                    fftw_real tmp890;
2584
                    ASSERT_ALIGNED_DOUBLE();
2585
                    tmp831 = tmp807 + tmp830;
2586
                    tmp886 = tmp858 + tmp885;
2587
                    c_re(inout[46 * iostride]) = tmp831 - tmp886;
2588
                    c_re(inout[14 * iostride]) = tmp831 + tmp886;
2589
                    tmp887 = tmp807 - tmp830;
2590
                    tmp890 = tmp888 - tmp889;
2591
                    c_re(inout[62 * iostride]) = tmp887 - tmp890;
2592
                    c_re(inout[30 * iostride]) = tmp887 + tmp890;
2593
               }
2594
               {
2595
                    fftw_real tmp1097;
2596
                    fftw_real tmp1100;
2597
                    fftw_real tmp1101;
2598
                    fftw_real tmp1102;
2599
                    ASSERT_ALIGNED_DOUBLE();
2600
                    tmp1097 = tmp888 + tmp889;
2601
                    tmp1100 = tmp1098 + tmp1099;
2602
                    c_im(inout[14 * iostride]) = tmp1097 + tmp1100;
2603
                    c_im(inout[46 * iostride]) = tmp1100 - tmp1097;
2604
                    tmp1101 = tmp885 - tmp858;
2605
                    tmp1102 = tmp1099 - tmp1098;
2606
                    c_im(inout[30 * iostride]) = tmp1101 + tmp1102;
2607
                    c_im(inout[62 * iostride]) = tmp1102 - tmp1101;
2608
               }
2609
               {
2610
                    fftw_real tmp895;
2611
                    fftw_real tmp902;
2612
                    fftw_real tmp903;
2613
                    fftw_real tmp906;
2614
                    ASSERT_ALIGNED_DOUBLE();
2615
                    tmp895 = tmp891 + tmp894;
2616
                    tmp902 = tmp898 + tmp901;
2617
                    c_re(inout[38 * iostride]) = tmp895 - tmp902;
2618
                    c_re(inout[6 * iostride]) = tmp895 + tmp902;
2619
                    tmp903 = tmp891 - tmp894;
2620
                    tmp906 = tmp904 - tmp905;
2621
                    c_re(inout[54 * iostride]) = tmp903 - tmp906;
2622
                    c_re(inout[22 * iostride]) = tmp903 + tmp906;
2623
               }
2624
               {
2625
                    fftw_real tmp1089;
2626
                    fftw_real tmp1094;
2627
                    fftw_real tmp1095;
2628
                    fftw_real tmp1096;
2629
                    ASSERT_ALIGNED_DOUBLE();
2630
                    tmp1089 = tmp904 + tmp905;
2631
                    tmp1094 = tmp1090 + tmp1093;
2632
                    c_im(inout[6 * iostride]) = tmp1089 + tmp1094;
2633
                    c_im(inout[38 * iostride]) = tmp1094 - tmp1089;
2634
                    tmp1095 = tmp901 - tmp898;
2635
                    tmp1096 = tmp1093 - tmp1090;
2636
                    c_im(inout[22 * iostride]) = tmp1095 + tmp1096;
2637
                    c_im(inout[54 * iostride]) = tmp1096 - tmp1095;
2638
               }
2639
          }
2640
          {
2641
               fftw_real tmp911;
2642
               fftw_real tmp939;
2643
               fftw_real tmp918;
2644
               fftw_real tmp1074;
2645
               fftw_real tmp1079;
2646
               fftw_real tmp1085;
2647
               fftw_real tmp942;
2648
               fftw_real tmp1084;
2649
               fftw_real tmp933;
2650
               fftw_real tmp937;
2651
               fftw_real tmp949;
2652
               fftw_real tmp953;
2653
               fftw_real tmp926;
2654
               fftw_real tmp936;
2655
               fftw_real tmp946;
2656
               fftw_real tmp952;
2657
               ASSERT_ALIGNED_DOUBLE();
2658
               {
2659
                    fftw_real tmp907;
2660
                    fftw_real tmp910;
2661
                    fftw_real tmp940;
2662
                    fftw_real tmp941;
2663
                    ASSERT_ALIGNED_DOUBLE();
2664
                    tmp907 = tmp791 + tmp794;
2665
                    tmp910 = K707106781 * (tmp908 + tmp909);
2666
                    tmp911 = tmp907 - tmp910;
2667
                    tmp939 = tmp907 + tmp910;
2668
                    {
2669
                         fftw_real tmp914;
2670
                         fftw_real tmp917;
2671
                         fftw_real tmp1075;
2672
                         fftw_real tmp1078;
2673
                         ASSERT_ALIGNED_DOUBLE();
2674
                         tmp914 = (K923879532 * tmp912) - (K382683432 * tmp913);
2675
                         tmp917 = (K923879532 * tmp915) + (K382683432 * tmp916);
2676
                         tmp918 = tmp914 - tmp917;
2677
                         tmp1074 = tmp914 + tmp917;
2678
                         tmp1075 = K707106781 * (tmp800 + tmp805);
2679
                         tmp1078 = tmp1076 + tmp1077;
2680
                         tmp1079 = tmp1075 + tmp1078;
2681
                         tmp1085 = tmp1078 - tmp1075;
2682
                    }
2683
                    tmp940 = (K382683432 * tmp912) + (K923879532 * tmp913);
2684
                    tmp941 = (K923879532 * tmp916) - (K382683432 * tmp915);
2685
                    tmp942 = tmp940 + tmp941;
2686
                    tmp1084 = tmp941 - tmp940;
2687
                    {
2688
                         fftw_real tmp929;
2689
                         fftw_real tmp947;
2690
                         fftw_real tmp932;
2691
                         fftw_real tmp948;
2692
                         fftw_real tmp928;
2693
                         fftw_real tmp931;
2694
                         ASSERT_ALIGNED_DOUBLE();
2695
                         tmp928 = K707106781 * (tmp882 + tmp881);
2696
                         tmp929 = tmp927 - tmp928;
2697
                         tmp947 = tmp927 + tmp928;
2698
                         tmp931 = K707106781 * (tmp868 + tmp873);
2699
                         tmp932 = tmp930 - tmp931;
2700
                         tmp948 = tmp930 + tmp931;
2701
                         tmp933 = (K555570233 * tmp929) - (K831469612 * tmp932);
2702
                         tmp937 = (K831469612 * tmp929) + (K555570233 * tmp932);
2703
                         tmp949 = (K980785280 * tmp947) - (K195090322 * tmp948);
2704
                         tmp953 = (K195090322 * tmp947) + (K980785280 * tmp948);
2705
                    }
2706
                    {
2707
                         fftw_real tmp922;
2708
                         fftw_real tmp944;
2709
                         fftw_real tmp925;
2710
                         fftw_real tmp945;
2711
                         fftw_real tmp921;
2712
                         fftw_real tmp924;
2713
                         ASSERT_ALIGNED_DOUBLE();
2714
                         tmp921 = K707106781 * (tmp846 + tmp841);
2715
                         tmp922 = tmp920 - tmp921;
2716
                         tmp944 = tmp920 + tmp921;
2717
                         tmp924 = K707106781 * (tmp854 + tmp855);
2718
                         tmp925 = tmp923 - tmp924;
2719
                         tmp945 = tmp923 + tmp924;
2720
                         tmp926 = (K555570233 * tmp922) + (K831469612 * tmp925);
2721
                         tmp936 = (K555570233 * tmp925) - (K831469612 * tmp922);
2722
                         tmp946 = (K980785280 * tmp944) + (K195090322 * tmp945);
2723
                         tmp952 = (K980785280 * tmp945) - (K195090322 * tmp944);
2724
                    }
2725
               }
2726
               {
2727
                    fftw_real tmp919;
2728
                    fftw_real tmp934;
2729
                    fftw_real tmp935;
2730
                    fftw_real tmp938;
2731
                    ASSERT_ALIGNED_DOUBLE();
2732
                    tmp919 = tmp911 + tmp918;
2733
                    tmp934 = tmp926 + tmp933;
2734
                    c_re(inout[42 * iostride]) = tmp919 - tmp934;
2735
                    c_re(inout[10 * iostride]) = tmp919 + tmp934;
2736
                    tmp935 = tmp911 - tmp918;
2737
                    tmp938 = tmp936 - tmp937;
2738
                    c_re(inout[58 * iostride]) = tmp935 - tmp938;
2739
                    c_re(inout[26 * iostride]) = tmp935 + tmp938;
2740
               }
2741
               {
2742
                    fftw_real tmp1083;
2743
                    fftw_real tmp1086;
2744
                    fftw_real tmp1087;
2745
                    fftw_real tmp1088;
2746
                    ASSERT_ALIGNED_DOUBLE();
2747
                    tmp1083 = tmp936 + tmp937;
2748
                    tmp1086 = tmp1084 + tmp1085;
2749
                    c_im(inout[10 * iostride]) = tmp1083 + tmp1086;
2750
                    c_im(inout[42 * iostride]) = tmp1086 - tmp1083;
2751
                    tmp1087 = tmp933 - tmp926;
2752
                    tmp1088 = tmp1085 - tmp1084;
2753
                    c_im(inout[26 * iostride]) = tmp1087 + tmp1088;
2754
                    c_im(inout[58 * iostride]) = tmp1088 - tmp1087;
2755
               }
2756
               {
2757
                    fftw_real tmp943;
2758
                    fftw_real tmp950;
2759
                    fftw_real tmp951;
2760
                    fftw_real tmp954;
2761
                    ASSERT_ALIGNED_DOUBLE();
2762
                    tmp943 = tmp939 + tmp942;
2763
                    tmp950 = tmp946 + tmp949;
2764
                    c_re(inout[34 * iostride]) = tmp943 - tmp950;
2765
                    c_re(inout[2 * iostride]) = tmp943 + tmp950;
2766
                    tmp951 = tmp939 - tmp942;
2767
                    tmp954 = tmp952 - tmp953;
2768
                    c_re(inout[50 * iostride]) = tmp951 - tmp954;
2769
                    c_re(inout[18 * iostride]) = tmp951 + tmp954;
2770
               }
2771
               {
2772
                    fftw_real tmp1073;
2773
                    fftw_real tmp1080;
2774
                    fftw_real tmp1081;
2775
                    fftw_real tmp1082;
2776
                    ASSERT_ALIGNED_DOUBLE();
2777
                    tmp1073 = tmp952 + tmp953;
2778
                    tmp1080 = tmp1074 + tmp1079;
2779
                    c_im(inout[2 * iostride]) = tmp1073 + tmp1080;
2780
                    c_im(inout[34 * iostride]) = tmp1080 - tmp1073;
2781
                    tmp1081 = tmp949 - tmp946;
2782
                    tmp1082 = tmp1079 - tmp1074;
2783
                    c_im(inout[18 * iostride]) = tmp1081 + tmp1082;
2784
                    c_im(inout[50 * iostride]) = tmp1082 - tmp1081;
2785
               }
2786
          }
2787
          {
2788
               fftw_real tmp667;
2789
               fftw_real tmp727;
2790
               fftw_real tmp1125;
2791
               fftw_real tmp1131;
2792
               fftw_real tmp682;
2793
               fftw_real tmp1122;
2794
               fftw_real tmp730;
2795
               fftw_real tmp1130;
2796
               fftw_real tmp702;
2797
               fftw_real tmp724;
2798
               fftw_real tmp734;
2799
               fftw_real tmp740;
2800
               fftw_real tmp721;
2801
               fftw_real tmp725;
2802
               fftw_real tmp737;
2803
               fftw_real tmp741;
2804
               ASSERT_ALIGNED_DOUBLE();
2805
               {
2806
                    fftw_real tmp659;
2807
                    fftw_real tmp666;
2808
                    fftw_real tmp1123;
2809
                    fftw_real tmp1124;
2810
                    ASSERT_ALIGNED_DOUBLE();
2811
                    tmp659 = tmp655 - tmp658;
2812
                    tmp666 = tmp662 - tmp665;
2813
                    tmp667 = tmp659 - tmp666;
2814
                    tmp727 = tmp659 + tmp666;
2815
                    tmp1123 = tmp745 - tmp744;
2816
                    tmp1124 = tmp1109 - tmp1106;
2817
                    tmp1125 = tmp1123 + tmp1124;
2818
                    tmp1131 = tmp1124 - tmp1123;
2819
               }
2820
               {
2821
                    fftw_real tmp674;
2822
                    fftw_real tmp728;
2823
                    fftw_real tmp681;
2824
                    fftw_real tmp729;
2825
                    ASSERT_ALIGNED_DOUBLE();
2826
                    {
2827
                         fftw_real tmp670;
2828
                         fftw_real tmp673;
2829
                         fftw_real tmp677;
2830
                         fftw_real tmp680;
2831
                         ASSERT_ALIGNED_DOUBLE();
2832
                         tmp670 = tmp668 - tmp669;
2833
                         tmp673 = tmp671 - tmp672;
2834
                         tmp674 = (K555570233 * tmp670) - (K831469612 * tmp673);
2835
                         tmp728 = (K555570233 * tmp673) + (K831469612 * tmp670);
2836
                         tmp677 = tmp675 - tmp676;
2837
                         tmp680 = tmp678 - tmp679;
2838
                         tmp681 = (K831469612 * tmp677) + (K555570233 * tmp680);
2839
                         tmp729 = (K555570233 * tmp677) - (K831469612 * tmp680);
2840
                    }
2841
                    tmp682 = tmp674 - tmp681;
2842
                    tmp1122 = tmp674 + tmp681;
2843
                    tmp730 = tmp728 + tmp729;
2844
                    tmp1130 = tmp729 - tmp728;
2845
               }
2846
               {
2847
                    fftw_real tmp694;
2848
                    fftw_real tmp732;
2849
                    fftw_real tmp701;
2850
                    fftw_real tmp733;
2851
                    ASSERT_ALIGNED_DOUBLE();
2852
                    {
2853
                         fftw_real tmp686;
2854
                         fftw_real tmp693;
2855
                         fftw_real tmp697;
2856
                         fftw_real tmp700;
2857
                         ASSERT_ALIGNED_DOUBLE();
2858
                         tmp686 = tmp684 - tmp685;
2859
                         tmp693 = tmp689 - tmp692;
2860
                         tmp694 = tmp686 - tmp693;
2861
                         tmp732 = tmp686 + tmp693;
2862
                         tmp697 = tmp695 - tmp696;
2863
                         tmp700 = tmp698 - tmp699;
2864
                         tmp701 = tmp697 - tmp700;
2865
                         tmp733 = tmp697 + tmp700;
2866
                    }
2867
                    tmp702 = (K956940335 * tmp694) + (K290284677 * tmp701);
2868
                    tmp724 = (K290284677 * tmp694) - (K956940335 * tmp701);
2869
                    tmp734 = (K471396736 * tmp732) + (K881921264 * tmp733);
2870
                    tmp740 = (K881921264 * tmp732) - (K471396736 * tmp733);
2871
               }
2872
               {
2873
                    fftw_real tmp713;
2874
                    fftw_real tmp735;
2875
                    fftw_real tmp720;
2876
                    fftw_real tmp736;
2877
                    ASSERT_ALIGNED_DOUBLE();
2878
                    {
2879
                         fftw_real tmp705;
2880
                         fftw_real tmp712;
2881
                         fftw_real tmp716;
2882
                         fftw_real tmp719;
2883
                         ASSERT_ALIGNED_DOUBLE();
2884
                         tmp705 = tmp703 - tmp704;
2885
                         tmp712 = tmp708 - tmp711;
2886
                         tmp713 = tmp705 - tmp712;
2887
                         tmp735 = tmp705 + tmp712;
2888
                         tmp716 = tmp714 - tmp715;
2889
                         tmp719 = tmp717 - tmp718;
2890
                         tmp720 = tmp716 - tmp719;
2891
                         tmp736 = tmp716 + tmp719;
2892
                    }
2893
                    tmp721 = (K290284677 * tmp713) - (K956940335 * tmp720);
2894
                    tmp725 = (K290284677 * tmp720) + (K956940335 * tmp713);
2895
                    tmp737 = (K881921264 * tmp735) - (K471396736 * tmp736);
2896
                    tmp741 = (K881921264 * tmp736) + (K471396736 * tmp735);
2897
               }
2898
               {
2899
                    fftw_real tmp683;
2900
                    fftw_real tmp722;
2901
                    fftw_real tmp723;
2902
                    fftw_real tmp726;
2903
                    ASSERT_ALIGNED_DOUBLE();
2904
                    tmp683 = tmp667 + tmp682;
2905
                    tmp722 = tmp702 + tmp721;
2906
                    c_re(inout[45 * iostride]) = tmp683 - tmp722;
2907
                    c_re(inout[13 * iostride]) = tmp683 + tmp722;
2908
                    tmp723 = tmp667 - tmp682;
2909
                    tmp726 = tmp724 - tmp725;
2910
                    c_re(inout[61 * iostride]) = tmp723 - tmp726;
2911
                    c_re(inout[29 * iostride]) = tmp723 + tmp726;
2912
               }
2913
               {
2914
                    fftw_real tmp1129;
2915
                    fftw_real tmp1132;
2916
                    fftw_real tmp1133;
2917
                    fftw_real tmp1134;
2918
                    ASSERT_ALIGNED_DOUBLE();
2919
                    tmp1129 = tmp724 + tmp725;
2920
                    tmp1132 = tmp1130 + tmp1131;
2921
                    c_im(inout[13 * iostride]) = tmp1129 + tmp1132;
2922
                    c_im(inout[45 * iostride]) = tmp1132 - tmp1129;
2923
                    tmp1133 = tmp721 - tmp702;
2924
                    tmp1134 = tmp1131 - tmp1130;
2925
                    c_im(inout[29 * iostride]) = tmp1133 + tmp1134;
2926
                    c_im(inout[61 * iostride]) = tmp1134 - tmp1133;
2927
               }
2928
               {
2929
                    fftw_real tmp731;
2930
                    fftw_real tmp738;
2931
                    fftw_real tmp739;
2932
                    fftw_real tmp742;
2933
                    ASSERT_ALIGNED_DOUBLE();
2934
                    tmp731 = tmp727 + tmp730;
2935
                    tmp738 = tmp734 + tmp737;
2936
                    c_re(inout[37 * iostride]) = tmp731 - tmp738;
2937
                    c_re(inout[5 * iostride]) = tmp731 + tmp738;
2938
                    tmp739 = tmp727 - tmp730;
2939
                    tmp742 = tmp740 - tmp741;
2940
                    c_re(inout[53 * iostride]) = tmp739 - tmp742;
2941
                    c_re(inout[21 * iostride]) = tmp739 + tmp742;
2942
               }
2943
               {
2944
                    fftw_real tmp1121;
2945
                    fftw_real tmp1126;
2946
                    fftw_real tmp1127;
2947
                    fftw_real tmp1128;
2948
                    ASSERT_ALIGNED_DOUBLE();
2949
                    tmp1121 = tmp740 + tmp741;
2950
                    tmp1126 = tmp1122 + tmp1125;
2951
                    c_im(inout[5 * iostride]) = tmp1121 + tmp1126;
2952
                    c_im(inout[37 * iostride]) = tmp1126 - tmp1121;
2953
                    tmp1127 = tmp737 - tmp734;
2954
                    tmp1128 = tmp1125 - tmp1122;
2955
                    c_im(inout[21 * iostride]) = tmp1127 + tmp1128;
2956
                    c_im(inout[53 * iostride]) = tmp1128 - tmp1127;
2957
               }
2958
          }
2959
          {
2960
               fftw_real tmp747;
2961
               fftw_real tmp775;
2962
               fftw_real tmp1111;
2963
               fftw_real tmp1117;
2964
               fftw_real tmp754;
2965
               fftw_real tmp1104;
2966
               fftw_real tmp778;
2967
               fftw_real tmp1116;
2968
               fftw_real tmp762;
2969
               fftw_real tmp772;
2970
               fftw_real tmp782;
2971
               fftw_real tmp788;
2972
               fftw_real tmp769;
2973
               fftw_real tmp773;
2974
               fftw_real tmp785;
2975
               fftw_real tmp789;
2976
               ASSERT_ALIGNED_DOUBLE();
2977
               {
2978
                    fftw_real tmp743;
2979
                    fftw_real tmp746;
2980
                    fftw_real tmp1105;
2981
                    fftw_real tmp1110;
2982
                    ASSERT_ALIGNED_DOUBLE();
2983
                    tmp743 = tmp655 + tmp658;
2984
                    tmp746 = tmp744 + tmp745;
2985
                    tmp747 = tmp743 - tmp746;
2986
                    tmp775 = tmp743 + tmp746;
2987
                    tmp1105 = tmp662 + tmp665;
2988
                    tmp1110 = tmp1106 + tmp1109;
2989
                    tmp1111 = tmp1105 + tmp1110;
2990
                    tmp1117 = tmp1110 - tmp1105;
2991
               }
2992
               {
2993
                    fftw_real tmp750;
2994
                    fftw_real tmp776;
2995
                    fftw_real tmp753;
2996
                    fftw_real tmp777;
2997
                    ASSERT_ALIGNED_DOUBLE();
2998
                    {
2999
                         fftw_real tmp748;
3000
                         fftw_real tmp749;
3001
                         fftw_real tmp751;
3002
                         fftw_real tmp752;
3003
                         ASSERT_ALIGNED_DOUBLE();
3004
                         tmp748 = tmp668 + tmp669;
3005
                         tmp749 = tmp671 + tmp672;
3006
                         tmp750 = (K980785280 * tmp748) - (K195090322 * tmp749);
3007
                         tmp776 = (K980785280 * tmp749) + (K195090322 * tmp748);
3008
                         tmp751 = tmp675 + tmp676;
3009
                         tmp752 = tmp678 + tmp679;
3010
                         tmp753 = (K195090322 * tmp751) + (K980785280 * tmp752);
3011
                         tmp777 = (K980785280 * tmp751) - (K195090322 * tmp752);
3012
                    }
3013
                    tmp754 = tmp750 - tmp753;
3014
                    tmp1104 = tmp750 + tmp753;
3015
                    tmp778 = tmp776 + tmp777;
3016
                    tmp1116 = tmp777 - tmp776;
3017
               }
3018
               {
3019
                    fftw_real tmp758;
3020
                    fftw_real tmp780;
3021
                    fftw_real tmp761;
3022
                    fftw_real tmp781;
3023
                    ASSERT_ALIGNED_DOUBLE();
3024
                    {
3025
                         fftw_real tmp756;
3026
                         fftw_real tmp757;
3027
                         fftw_real tmp759;
3028
                         fftw_real tmp760;
3029
                         ASSERT_ALIGNED_DOUBLE();
3030
                         tmp756 = tmp695 + tmp696;
3031
                         tmp757 = tmp692 + tmp689;
3032
                         tmp758 = tmp756 - tmp757;
3033
                         tmp780 = tmp756 + tmp757;
3034
                         tmp759 = tmp684 + tmp685;
3035
                         tmp760 = tmp698 + tmp699;
3036
                         tmp761 = tmp759 - tmp760;
3037
                         tmp781 = tmp759 + tmp760;
3038
                    }
3039
                    tmp762 = (K634393284 * tmp758) + (K773010453 * tmp761);
3040
                    tmp772 = (K634393284 * tmp761) - (K773010453 * tmp758);
3041
                    tmp782 = (K995184726 * tmp780) + (K098017140 * tmp781);
3042
                    tmp788 = (K995184726 * tmp781) - (K098017140 * tmp780);
3043
               }
3044
               {
3045
                    fftw_real tmp765;
3046
                    fftw_real tmp783;
3047
                    fftw_real tmp768;
3048
                    fftw_real tmp784;
3049
                    ASSERT_ALIGNED_DOUBLE();
3050
                    {
3051
                         fftw_real tmp763;
3052
                         fftw_real tmp764;
3053
                         fftw_real tmp766;
3054
                         fftw_real tmp767;
3055
                         ASSERT_ALIGNED_DOUBLE();
3056
                         tmp763 = tmp703 + tmp704;
3057
                         tmp764 = tmp718 + tmp717;
3058
                         tmp765 = tmp763 - tmp764;
3059
                         tmp783 = tmp763 + tmp764;
3060
                         tmp766 = tmp714 + tmp715;
3061
                         tmp767 = tmp708 + tmp711;
3062
                         tmp768 = tmp766 - tmp767;
3063
                         tmp784 = tmp766 + tmp767;
3064
                    }
3065
                    tmp769 = (K634393284 * tmp765) - (K773010453 * tmp768);
3066
                    tmp773 = (K773010453 * tmp765) + (K634393284 * tmp768);
3067
                    tmp785 = (K995184726 * tmp783) - (K098017140 * tmp784);
3068
                    tmp789 = (K098017140 * tmp783) + (K995184726 * tmp784);
3069
               }
3070
               {
3071
                    fftw_real tmp755;
3072
                    fftw_real tmp770;
3073
                    fftw_real tmp771;
3074
                    fftw_real tmp774;
3075
                    ASSERT_ALIGNED_DOUBLE();
3076
                    tmp755 = tmp747 + tmp754;
3077
                    tmp770 = tmp762 + tmp769;
3078
                    c_re(inout[41 * iostride]) = tmp755 - tmp770;
3079
                    c_re(inout[9 * iostride]) = tmp755 + tmp770;
3080
                    tmp771 = tmp747 - tmp754;
3081
                    tmp774 = tmp772 - tmp773;
3082
                    c_re(inout[57 * iostride]) = tmp771 - tmp774;
3083
                    c_re(inout[25 * iostride]) = tmp771 + tmp774;
3084
               }
3085
               {
3086
                    fftw_real tmp1115;
3087
                    fftw_real tmp1118;
3088
                    fftw_real tmp1119;
3089
                    fftw_real tmp1120;
3090
                    ASSERT_ALIGNED_DOUBLE();
3091
                    tmp1115 = tmp772 + tmp773;
3092
                    tmp1118 = tmp1116 + tmp1117;
3093
                    c_im(inout[9 * iostride]) = tmp1115 + tmp1118;
3094
                    c_im(inout[41 * iostride]) = tmp1118 - tmp1115;
3095
                    tmp1119 = tmp769 - tmp762;
3096
                    tmp1120 = tmp1117 - tmp1116;
3097
                    c_im(inout[25 * iostride]) = tmp1119 + tmp1120;
3098
                    c_im(inout[57 * iostride]) = tmp1120 - tmp1119;
3099
               }
3100
               {
3101
                    fftw_real tmp779;
3102
                    fftw_real tmp786;
3103
                    fftw_real tmp787;
3104
                    fftw_real tmp790;
3105
                    ASSERT_ALIGNED_DOUBLE();
3106
                    tmp779 = tmp775 + tmp778;
3107
                    tmp786 = tmp782 + tmp785;
3108
                    c_re(inout[33 * iostride]) = tmp779 - tmp786;
3109
                    c_re(inout[iostride]) = tmp779 + tmp786;
3110
                    tmp787 = tmp775 - tmp778;
3111
                    tmp790 = tmp788 - tmp789;
3112
                    c_re(inout[49 * iostride]) = tmp787 - tmp790;
3113
                    c_re(inout[17 * iostride]) = tmp787 + tmp790;
3114
               }
3115
               {
3116
                    fftw_real tmp1103;
3117
                    fftw_real tmp1112;
3118
                    fftw_real tmp1113;
3119
                    fftw_real tmp1114;
3120
                    ASSERT_ALIGNED_DOUBLE();
3121
                    tmp1103 = tmp788 + tmp789;
3122
                    tmp1112 = tmp1104 + tmp1111;
3123
                    c_im(inout[iostride]) = tmp1103 + tmp1112;
3124
                    c_im(inout[33 * iostride]) = tmp1112 - tmp1103;
3125
                    tmp1113 = tmp785 - tmp782;
3126
                    tmp1114 = tmp1111 - tmp1104;
3127
                    c_im(inout[17 * iostride]) = tmp1113 + tmp1114;
3128
                    c_im(inout[49 * iostride]) = tmp1114 - tmp1113;
3129
               }
3130
          }
3131
     }
3132
}
3133
 
3134
static const int twiddle_order[] =
3135
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63};
3136
fftw_codelet_desc fftw_twiddle_64_desc =
3137
{
3138
     "fftw_twiddle_64",
3139
     (void (*)()) fftw_twiddle_64,
3140
     64,
3141
     FFTW_FORWARD,
3142
     FFTW_TWIDDLE,
3143
     1408,
3144
     63,
3145
     twiddle_order,
3146
};