Subversion Repositories shark

Rev

Rev 3 | 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:56:08 EDT 1999 */
22
 
107 pj 23
#include <fftw-int.h>
24
#include <fftw.h>
2 pj 25
 
26
/* Generated by: ./genfft -magic-alignment-check -magic-twiddle-load-all -magic-variables 4 -magic-loopi -hc2hc-backward 16 */
27
 
28
/*
29
 * This function contains 298 FP additions, 134 FP multiplications,
30
 * (or, 244 additions, 80 multiplications, 54 fused multiply/add),
31
 * 49 stack variables, and 128 memory accesses
32
 */
33
static const fftw_real K1_961570560 = FFTW_KONST(+1.961570560806460898252364472268478073947867462);
34
static const fftw_real K390180644 = FFTW_KONST(+0.390180644032256535696569736954044481855383236);
35
static const fftw_real K1_111140466 = FFTW_KONST(+1.111140466039204449485661627897065748749874382);
36
static const fftw_real K1_662939224 = FFTW_KONST(+1.662939224605090474157576755235811513477121624);
37
static const fftw_real K707106781 = FFTW_KONST(+0.707106781186547524400844362104849039284835938);
38
static const fftw_real K382683432 = FFTW_KONST(+0.382683432365089771728459984030398866761344562);
39
static const fftw_real K923879532 = FFTW_KONST(+0.923879532511286756128183189396788286822416626);
40
static const fftw_real K765366864 = FFTW_KONST(+0.765366864730179543456919968060797733522689125);
41
static const fftw_real K1_847759065 = FFTW_KONST(+1.847759065022573512256366378793576573644833252);
42
static const fftw_real K1_414213562 = FFTW_KONST(+1.414213562373095048801688724209698078569671875);
43
static const fftw_real K2_000000000 = FFTW_KONST(+2.000000000000000000000000000000000000000000000);
44
 
45
/*
46
 * Generator Id's :
107 pj 47
 * $Id: fhb_16.c,v 1.2 2003-03-24 11:14:56 pj Exp $
48
 * $Id: fhb_16.c,v 1.2 2003-03-24 11:14:56 pj Exp $
49
 * $Id: fhb_16.c,v 1.2 2003-03-24 11:14:56 pj Exp $
2 pj 50
 */
51
 
52
void fftw_hc2hc_backward_16(fftw_real *A, const fftw_complex *W, int iostride, int m, int dist)
53
{
54
     int i;
55
     fftw_real *X;
56
     fftw_real *Y;
57
     X = A;
58
     Y = A + (16 * iostride);
59
     {
60
          fftw_real tmp279;
61
          fftw_real tmp324;
62
          fftw_real tmp312;
63
          fftw_real tmp299;
64
          fftw_real tmp276;
65
          fftw_real tmp296;
66
          fftw_real tmp309;
67
          fftw_real tmp323;
68
          fftw_real tmp283;
69
          fftw_real tmp291;
70
          fftw_real tmp286;
71
          fftw_real tmp294;
72
          fftw_real tmp301;
73
          fftw_real tmp319;
74
          fftw_real tmp327;
75
          fftw_real tmp326;
76
          fftw_real tmp316;
77
          fftw_real tmp302;
78
          ASSERT_ALIGNED_DOUBLE();
79
          {
80
               fftw_real tmp277;
81
               fftw_real tmp278;
82
               fftw_real tmp310;
83
               fftw_real tmp297;
84
               fftw_real tmp298;
85
               fftw_real tmp311;
86
               ASSERT_ALIGNED_DOUBLE();
87
               tmp277 = X[2 * iostride];
88
               tmp278 = X[6 * iostride];
89
               tmp310 = tmp277 - tmp278;
90
               tmp297 = Y[-2 * iostride];
91
               tmp298 = Y[-6 * iostride];
92
               tmp311 = tmp298 + tmp297;
93
               tmp279 = K2_000000000 * (tmp277 + tmp278);
94
               tmp324 = K1_414213562 * (tmp310 + tmp311);
95
               tmp312 = K1_414213562 * (tmp310 - tmp311);
96
               tmp299 = K2_000000000 * (tmp297 - tmp298);
97
          }
98
          {
99
               fftw_real tmp275;
100
               fftw_real tmp308;
101
               fftw_real tmp273;
102
               fftw_real tmp306;
103
               ASSERT_ALIGNED_DOUBLE();
104
               {
105
                    fftw_real tmp274;
106
                    fftw_real tmp307;
107
                    fftw_real tmp271;
108
                    fftw_real tmp272;
109
                    ASSERT_ALIGNED_DOUBLE();
110
                    tmp274 = X[4 * iostride];
111
                    tmp275 = K2_000000000 * tmp274;
112
                    tmp307 = Y[-4 * iostride];
113
                    tmp308 = K2_000000000 * tmp307;
114
                    tmp271 = X[0];
115
                    tmp272 = X[8 * iostride];
116
                    tmp273 = tmp271 + tmp272;
117
                    tmp306 = tmp271 - tmp272;
118
               }
119
               tmp276 = tmp273 + tmp275;
120
               tmp296 = tmp273 - tmp275;
121
               tmp309 = tmp306 - tmp308;
122
               tmp323 = tmp306 + tmp308;
123
          }
124
          {
125
               fftw_real tmp314;
126
               fftw_real tmp318;
127
               fftw_real tmp317;
128
               fftw_real tmp315;
129
               ASSERT_ALIGNED_DOUBLE();
130
               {
131
                    fftw_real tmp281;
132
                    fftw_real tmp282;
133
                    fftw_real tmp289;
134
                    fftw_real tmp290;
135
                    ASSERT_ALIGNED_DOUBLE();
136
                    tmp281 = X[iostride];
137
                    tmp282 = X[7 * iostride];
138
                    tmp283 = tmp281 + tmp282;
139
                    tmp314 = tmp281 - tmp282;
140
                    tmp289 = Y[-iostride];
141
                    tmp290 = Y[-7 * iostride];
142
                    tmp291 = tmp289 - tmp290;
143
                    tmp318 = tmp289 + tmp290;
144
               }
145
               {
146
                    fftw_real tmp284;
147
                    fftw_real tmp285;
148
                    fftw_real tmp292;
149
                    fftw_real tmp293;
150
                    ASSERT_ALIGNED_DOUBLE();
151
                    tmp284 = X[3 * iostride];
152
                    tmp285 = X[5 * iostride];
153
                    tmp286 = tmp284 + tmp285;
154
                    tmp317 = tmp285 - tmp284;
155
                    tmp292 = Y[-3 * iostride];
156
                    tmp293 = Y[-5 * iostride];
157
                    tmp294 = tmp292 - tmp293;
158
                    tmp315 = tmp293 + tmp292;
159
               }
160
               tmp301 = tmp283 - tmp286;
161
               tmp319 = tmp317 + tmp318;
162
               tmp327 = tmp318 - tmp317;
163
               tmp326 = tmp314 + tmp315;
164
               tmp316 = tmp314 - tmp315;
165
               tmp302 = tmp294 + tmp291;
166
          }
167
          {
168
               fftw_real tmp280;
169
               fftw_real tmp287;
170
               fftw_real tmp288;
171
               fftw_real tmp295;
172
               ASSERT_ALIGNED_DOUBLE();
173
               tmp280 = tmp276 + tmp279;
174
               tmp287 = K2_000000000 * (tmp283 + tmp286);
175
               X[8 * iostride] = tmp280 - tmp287;
176
               X[0] = tmp280 + tmp287;
177
               tmp288 = tmp276 - tmp279;
178
               tmp295 = K2_000000000 * (tmp291 - tmp294);
179
               X[12 * iostride] = tmp288 + tmp295;
180
               X[4 * iostride] = tmp288 - tmp295;
181
          }
182
          {
183
               fftw_real tmp300;
184
               fftw_real tmp303;
185
               fftw_real tmp304;
186
               fftw_real tmp305;
187
               ASSERT_ALIGNED_DOUBLE();
188
               tmp300 = tmp296 - tmp299;
189
               tmp303 = K1_414213562 * (tmp301 - tmp302);
190
               X[10 * iostride] = tmp300 - tmp303;
191
               X[2 * iostride] = tmp300 + tmp303;
192
               tmp304 = tmp296 + tmp299;
193
               tmp305 = K1_414213562 * (tmp301 + tmp302);
194
               X[6 * iostride] = tmp304 - tmp305;
195
               X[14 * iostride] = tmp304 + tmp305;
196
          }
197
          {
198
               fftw_real tmp313;
199
               fftw_real tmp320;
200
               fftw_real tmp321;
201
               fftw_real tmp322;
202
               ASSERT_ALIGNED_DOUBLE();
203
               tmp313 = tmp309 + tmp312;
204
               tmp320 = (K1_847759065 * tmp316) - (K765366864 * tmp319);
205
               X[9 * iostride] = tmp313 - tmp320;
206
               X[iostride] = tmp313 + tmp320;
207
               tmp321 = tmp309 - tmp312;
208
               tmp322 = (K765366864 * tmp316) + (K1_847759065 * tmp319);
209
               X[5 * iostride] = tmp321 - tmp322;
210
               X[13 * iostride] = tmp321 + tmp322;
211
          }
212
          {
213
               fftw_real tmp325;
214
               fftw_real tmp328;
215
               fftw_real tmp329;
216
               fftw_real tmp330;
217
               ASSERT_ALIGNED_DOUBLE();
218
               tmp325 = tmp323 - tmp324;
219
               tmp328 = (K765366864 * tmp326) - (K1_847759065 * tmp327);
220
               X[11 * iostride] = tmp325 - tmp328;
221
               X[3 * iostride] = tmp325 + tmp328;
222
               tmp329 = tmp323 + tmp324;
223
               tmp330 = (K1_847759065 * tmp326) + (K765366864 * tmp327);
224
               X[7 * iostride] = tmp329 - tmp330;
225
               X[15 * iostride] = tmp329 + tmp330;
226
          }
227
     }
228
     X = X + dist;
229
     Y = Y - dist;
230
     for (i = 2; i < m; i = i + 2, X = X + dist, Y = Y - dist, W = W + 15) {
231
          fftw_real tmp73;
232
          fftw_real tmp98;
233
          fftw_real tmp135;
234
          fftw_real tmp160;
235
          fftw_real tmp182;
236
          fftw_real tmp236;
237
          fftw_real tmp210;
238
          fftw_real tmp248;
239
          fftw_real tmp95;
240
          fftw_real tmp124;
241
          fftw_real tmp138;
242
          fftw_real tmp164;
243
          fftw_real tmp197;
244
          fftw_real tmp216;
245
          fftw_real tmp244;
246
          fftw_real tmp252;
247
          fftw_real tmp80;
248
          fftw_real tmp128;
249
          fftw_real tmp105;
250
          fftw_real tmp161;
251
          fftw_real tmp213;
252
          fftw_real tmp237;
253
          fftw_real tmp189;
254
          fftw_real tmp249;
255
          fftw_real tmp88;
256
          fftw_real tmp115;
257
          fftw_real tmp137;
258
          fftw_real tmp163;
259
          fftw_real tmp204;
260
          fftw_real tmp215;
261
          fftw_real tmp241;
262
          fftw_real tmp251;
263
          ASSERT_ALIGNED_DOUBLE();
264
          {
265
               fftw_real tmp69;
266
               fftw_real tmp180;
267
               fftw_real tmp131;
268
               fftw_real tmp209;
269
               fftw_real tmp72;
270
               fftw_real tmp208;
271
               fftw_real tmp134;
272
               fftw_real tmp181;
273
               ASSERT_ALIGNED_DOUBLE();
274
               {
275
                    fftw_real tmp67;
276
                    fftw_real tmp68;
277
                    fftw_real tmp129;
278
                    fftw_real tmp130;
279
                    ASSERT_ALIGNED_DOUBLE();
280
                    tmp67 = X[0];
281
                    tmp68 = Y[-8 * iostride];
282
                    tmp69 = tmp67 + tmp68;
283
                    tmp180 = tmp67 - tmp68;
284
                    tmp129 = Y[0];
285
                    tmp130 = X[8 * iostride];
286
                    tmp131 = tmp129 - tmp130;
287
                    tmp209 = tmp129 + tmp130;
288
               }
289
               {
290
                    fftw_real tmp70;
291
                    fftw_real tmp71;
292
                    fftw_real tmp132;
293
                    fftw_real tmp133;
294
                    ASSERT_ALIGNED_DOUBLE();
295
                    tmp70 = X[4 * iostride];
296
                    tmp71 = Y[-12 * iostride];
297
                    tmp72 = tmp70 + tmp71;
298
                    tmp208 = tmp70 - tmp71;
299
                    tmp132 = Y[-4 * iostride];
300
                    tmp133 = X[12 * iostride];
301
                    tmp134 = tmp132 - tmp133;
302
                    tmp181 = tmp132 + tmp133;
303
               }
304
               tmp73 = tmp69 + tmp72;
305
               tmp98 = tmp69 - tmp72;
306
               tmp135 = tmp131 - tmp134;
307
               tmp160 = tmp131 + tmp134;
308
               tmp182 = tmp180 - tmp181;
309
               tmp236 = tmp180 + tmp181;
310
               tmp210 = tmp208 + tmp209;
311
               tmp248 = tmp209 - tmp208;
312
          }
313
          {
314
               fftw_real tmp91;
315
               fftw_real tmp194;
316
               fftw_real tmp119;
317
               fftw_real tmp192;
318
               fftw_real tmp94;
319
               fftw_real tmp191;
320
               fftw_real tmp122;
321
               fftw_real tmp195;
322
               fftw_real tmp116;
323
               fftw_real tmp123;
324
               ASSERT_ALIGNED_DOUBLE();
325
               {
326
                    fftw_real tmp89;
327
                    fftw_real tmp90;
328
                    fftw_real tmp117;
329
                    fftw_real tmp118;
330
                    ASSERT_ALIGNED_DOUBLE();
331
                    tmp89 = Y[-15 * iostride];
332
                    tmp90 = X[7 * iostride];
333
                    tmp91 = tmp89 + tmp90;
334
                    tmp194 = tmp89 - tmp90;
335
                    tmp117 = Y[-7 * iostride];
336
                    tmp118 = X[15 * iostride];
337
                    tmp119 = tmp117 - tmp118;
338
                    tmp192 = tmp117 + tmp118;
339
               }
340
               {
341
                    fftw_real tmp92;
342
                    fftw_real tmp93;
343
                    fftw_real tmp120;
344
                    fftw_real tmp121;
345
                    ASSERT_ALIGNED_DOUBLE();
346
                    tmp92 = X[3 * iostride];
347
                    tmp93 = Y[-11 * iostride];
348
                    tmp94 = tmp92 + tmp93;
349
                    tmp191 = tmp92 - tmp93;
350
                    tmp120 = Y[-3 * iostride];
351
                    tmp121 = X[11 * iostride];
352
                    tmp122 = tmp120 - tmp121;
353
                    tmp195 = tmp120 + tmp121;
354
               }
355
               tmp95 = tmp91 + tmp94;
356
               tmp116 = tmp91 - tmp94;
357
               tmp123 = tmp119 - tmp122;
358
               tmp124 = tmp116 + tmp123;
359
               tmp138 = tmp123 - tmp116;
360
               tmp164 = tmp119 + tmp122;
361
               {
362
                    fftw_real tmp193;
363
                    fftw_real tmp196;
364
                    fftw_real tmp242;
365
                    fftw_real tmp243;
366
                    ASSERT_ALIGNED_DOUBLE();
367
                    tmp193 = tmp191 - tmp192;
368
                    tmp196 = tmp194 - tmp195;
369
                    tmp197 = (K923879532 * tmp193) - (K382683432 * tmp196);
370
                    tmp216 = (K382683432 * tmp193) + (K923879532 * tmp196);
371
                    tmp242 = tmp194 + tmp195;
372
                    tmp243 = tmp191 + tmp192;
373
                    tmp244 = (K382683432 * tmp242) - (K923879532 * tmp243);
374
                    tmp252 = (K382683432 * tmp243) + (K923879532 * tmp242);
375
               }
376
          }
377
          {
378
               fftw_real tmp76;
379
               fftw_real tmp183;
380
               fftw_real tmp104;
381
               fftw_real tmp184;
382
               fftw_real tmp79;
383
               fftw_real tmp186;
384
               fftw_real tmp101;
385
               fftw_real tmp187;
386
               ASSERT_ALIGNED_DOUBLE();
387
               {
388
                    fftw_real tmp74;
389
                    fftw_real tmp75;
390
                    fftw_real tmp102;
391
                    fftw_real tmp103;
392
                    ASSERT_ALIGNED_DOUBLE();
393
                    tmp74 = X[2 * iostride];
394
                    tmp75 = Y[-10 * iostride];
395
                    tmp76 = tmp74 + tmp75;
396
                    tmp183 = tmp74 - tmp75;
397
                    tmp102 = Y[-2 * iostride];
398
                    tmp103 = X[10 * iostride];
399
                    tmp104 = tmp102 - tmp103;
400
                    tmp184 = tmp102 + tmp103;
401
               }
402
               {
403
                    fftw_real tmp77;
404
                    fftw_real tmp78;
405
                    fftw_real tmp99;
406
                    fftw_real tmp100;
407
                    ASSERT_ALIGNED_DOUBLE();
408
                    tmp77 = Y[-14 * iostride];
409
                    tmp78 = X[6 * iostride];
410
                    tmp79 = tmp77 + tmp78;
411
                    tmp186 = tmp77 - tmp78;
412
                    tmp99 = Y[-6 * iostride];
413
                    tmp100 = X[14 * iostride];
414
                    tmp101 = tmp99 - tmp100;
415
                    tmp187 = tmp99 + tmp100;
416
               }
417
               tmp80 = tmp76 + tmp79;
418
               tmp128 = tmp76 - tmp79;
419
               tmp105 = tmp101 - tmp104;
420
               tmp161 = tmp104 + tmp101;
421
               {
422
                    fftw_real tmp211;
423
                    fftw_real tmp212;
424
                    fftw_real tmp185;
425
                    fftw_real tmp188;
426
                    ASSERT_ALIGNED_DOUBLE();
427
                    tmp211 = tmp183 + tmp184;
428
                    tmp212 = tmp186 + tmp187;
429
                    tmp213 = K707106781 * (tmp211 - tmp212);
430
                    tmp237 = K707106781 * (tmp211 + tmp212);
431
                    tmp185 = tmp183 - tmp184;
432
                    tmp188 = tmp186 - tmp187;
433
                    tmp189 = K707106781 * (tmp185 + tmp188);
434
                    tmp249 = K707106781 * (tmp185 - tmp188);
435
               }
436
          }
437
          {
438
               fftw_real tmp84;
439
               fftw_real tmp201;
440
               fftw_real tmp110;
441
               fftw_real tmp199;
442
               fftw_real tmp87;
443
               fftw_real tmp198;
444
               fftw_real tmp113;
445
               fftw_real tmp202;
446
               fftw_real tmp107;
447
               fftw_real tmp114;
448
               ASSERT_ALIGNED_DOUBLE();
449
               {
450
                    fftw_real tmp82;
451
                    fftw_real tmp83;
452
                    fftw_real tmp108;
453
                    fftw_real tmp109;
454
                    ASSERT_ALIGNED_DOUBLE();
455
                    tmp82 = X[iostride];
456
                    tmp83 = Y[-9 * iostride];
457
                    tmp84 = tmp82 + tmp83;
458
                    tmp201 = tmp82 - tmp83;
459
                    tmp108 = Y[-iostride];
460
                    tmp109 = X[9 * iostride];
461
                    tmp110 = tmp108 - tmp109;
462
                    tmp199 = tmp108 + tmp109;
463
               }
464
               {
465
                    fftw_real tmp85;
466
                    fftw_real tmp86;
467
                    fftw_real tmp111;
468
                    fftw_real tmp112;
469
                    ASSERT_ALIGNED_DOUBLE();
470
                    tmp85 = X[5 * iostride];
471
                    tmp86 = Y[-13 * iostride];
472
                    tmp87 = tmp85 + tmp86;
473
                    tmp198 = tmp85 - tmp86;
474
                    tmp111 = Y[-5 * iostride];
475
                    tmp112 = X[13 * iostride];
476
                    tmp113 = tmp111 - tmp112;
477
                    tmp202 = tmp111 + tmp112;
478
               }
479
               tmp88 = tmp84 + tmp87;
480
               tmp107 = tmp84 - tmp87;
481
               tmp114 = tmp110 - tmp113;
482
               tmp115 = tmp107 - tmp114;
483
               tmp137 = tmp107 + tmp114;
484
               tmp163 = tmp110 + tmp113;
485
               {
486
                    fftw_real tmp200;
487
                    fftw_real tmp203;
488
                    fftw_real tmp239;
489
                    fftw_real tmp240;
490
                    ASSERT_ALIGNED_DOUBLE();
491
                    tmp200 = tmp198 + tmp199;
492
                    tmp203 = tmp201 - tmp202;
493
                    tmp204 = (K923879532 * tmp200) + (K382683432 * tmp203);
494
                    tmp215 = (K923879532 * tmp203) - (K382683432 * tmp200);
495
                    tmp239 = tmp201 + tmp202;
496
                    tmp240 = tmp199 - tmp198;
497
                    tmp241 = (K382683432 * tmp239) - (K923879532 * tmp240);
498
                    tmp251 = (K382683432 * tmp240) + (K923879532 * tmp239);
499
               }
500
          }
501
          {
502
               fftw_real tmp81;
503
               fftw_real tmp96;
504
               fftw_real tmp158;
505
               fftw_real tmp162;
506
               fftw_real tmp165;
507
               fftw_real tmp166;
508
               fftw_real tmp157;
509
               fftw_real tmp159;
510
               ASSERT_ALIGNED_DOUBLE();
511
               tmp81 = tmp73 + tmp80;
512
               tmp96 = tmp88 + tmp95;
513
               tmp158 = tmp81 - tmp96;
514
               tmp162 = tmp160 + tmp161;
515
               tmp165 = tmp163 + tmp164;
516
               tmp166 = tmp162 - tmp165;
517
               X[0] = tmp81 + tmp96;
518
               Y[-15 * iostride] = tmp162 + tmp165;
519
               tmp157 = c_re(W[7]);
520
               tmp159 = c_im(W[7]);
521
               X[8 * iostride] = (tmp157 * tmp158) + (tmp159 * tmp166);
522
               Y[-7 * iostride] = (tmp157 * tmp166) - (tmp159 * tmp158);
523
          }
524
          {
525
               fftw_real tmp170;
526
               fftw_real tmp176;
527
               fftw_real tmp174;
528
               fftw_real tmp178;
529
               ASSERT_ALIGNED_DOUBLE();
530
               {
531
                    fftw_real tmp168;
532
                    fftw_real tmp169;
533
                    fftw_real tmp172;
534
                    fftw_real tmp173;
535
                    ASSERT_ALIGNED_DOUBLE();
536
                    tmp168 = tmp160 - tmp161;
537
                    tmp169 = tmp88 - tmp95;
538
                    tmp170 = tmp168 - tmp169;
539
                    tmp176 = tmp169 + tmp168;
540
                    tmp172 = tmp73 - tmp80;
541
                    tmp173 = tmp164 - tmp163;
542
                    tmp174 = tmp172 - tmp173;
543
                    tmp178 = tmp172 + tmp173;
544
               }
545
               {
546
                    fftw_real tmp167;
547
                    fftw_real tmp171;
548
                    fftw_real tmp175;
549
                    fftw_real tmp177;
550
                    ASSERT_ALIGNED_DOUBLE();
551
                    tmp167 = c_re(W[11]);
552
                    tmp171 = c_im(W[11]);
553
                    Y[-3 * iostride] = (tmp167 * tmp170) - (tmp171 * tmp174);
554
                    X[12 * iostride] = (tmp171 * tmp170) + (tmp167 * tmp174);
555
                    tmp175 = c_re(W[3]);
556
                    tmp177 = c_im(W[3]);
557
                    Y[-11 * iostride] = (tmp175 * tmp176) - (tmp177 * tmp178);
558
                    X[4 * iostride] = (tmp177 * tmp176) + (tmp175 * tmp178);
559
               }
560
          }
561
          {
562
               fftw_real tmp126;
563
               fftw_real tmp142;
564
               fftw_real tmp140;
565
               fftw_real tmp144;
566
               ASSERT_ALIGNED_DOUBLE();
567
               {
568
                    fftw_real tmp106;
569
                    fftw_real tmp125;
570
                    fftw_real tmp136;
571
                    fftw_real tmp139;
572
                    ASSERT_ALIGNED_DOUBLE();
573
                    tmp106 = tmp98 + tmp105;
574
                    tmp125 = K707106781 * (tmp115 + tmp124);
575
                    tmp126 = tmp106 - tmp125;
576
                    tmp142 = tmp106 + tmp125;
577
                    tmp136 = tmp128 + tmp135;
578
                    tmp139 = K707106781 * (tmp137 + tmp138);
579
                    tmp140 = tmp136 - tmp139;
580
                    tmp144 = tmp136 + tmp139;
581
               }
582
               {
583
                    fftw_real tmp97;
584
                    fftw_real tmp127;
585
                    fftw_real tmp141;
586
                    fftw_real tmp143;
587
                    ASSERT_ALIGNED_DOUBLE();
588
                    tmp97 = c_re(W[9]);
589
                    tmp127 = c_im(W[9]);
590
                    X[10 * iostride] = (tmp97 * tmp126) + (tmp127 * tmp140);
591
                    Y[-5 * iostride] = (tmp97 * tmp140) - (tmp127 * tmp126);
592
                    tmp141 = c_re(W[1]);
593
                    tmp143 = c_im(W[1]);
594
                    X[2 * iostride] = (tmp141 * tmp142) + (tmp143 * tmp144);
595
                    Y[-13 * iostride] = (tmp141 * tmp144) - (tmp143 * tmp142);
596
               }
597
          }
598
          {
599
               fftw_real tmp148;
600
               fftw_real tmp154;
601
               fftw_real tmp152;
602
               fftw_real tmp156;
603
               ASSERT_ALIGNED_DOUBLE();
604
               {
605
                    fftw_real tmp146;
606
                    fftw_real tmp147;
607
                    fftw_real tmp150;
608
                    fftw_real tmp151;
609
                    ASSERT_ALIGNED_DOUBLE();
610
                    tmp146 = tmp135 - tmp128;
611
                    tmp147 = K707106781 * (tmp115 - tmp124);
612
                    tmp148 = tmp146 - tmp147;
613
                    tmp154 = tmp146 + tmp147;
614
                    tmp150 = tmp98 - tmp105;
615
                    tmp151 = K707106781 * (tmp138 - tmp137);
616
                    tmp152 = tmp150 - tmp151;
617
                    tmp156 = tmp150 + tmp151;
618
               }
619
               {
620
                    fftw_real tmp145;
621
                    fftw_real tmp149;
622
                    fftw_real tmp153;
623
                    fftw_real tmp155;
624
                    ASSERT_ALIGNED_DOUBLE();
625
                    tmp145 = c_re(W[13]);
626
                    tmp149 = c_im(W[13]);
627
                    Y[-iostride] = (tmp145 * tmp148) - (tmp149 * tmp152);
628
                    X[14 * iostride] = (tmp149 * tmp148) + (tmp145 * tmp152);
629
                    tmp153 = c_re(W[5]);
630
                    tmp155 = c_im(W[5]);
631
                    Y[-9 * iostride] = (tmp153 * tmp154) - (tmp155 * tmp156);
632
                    X[6 * iostride] = (tmp155 * tmp154) + (tmp153 * tmp156);
633
               }
634
          }
635
          {
636
               fftw_real tmp206;
637
               fftw_real tmp220;
638
               fftw_real tmp218;
639
               fftw_real tmp222;
640
               ASSERT_ALIGNED_DOUBLE();
641
               {
642
                    fftw_real tmp190;
643
                    fftw_real tmp205;
644
                    fftw_real tmp214;
645
                    fftw_real tmp217;
646
                    ASSERT_ALIGNED_DOUBLE();
647
                    tmp190 = tmp182 - tmp189;
648
                    tmp205 = tmp197 - tmp204;
649
                    tmp206 = tmp190 - tmp205;
650
                    tmp220 = tmp190 + tmp205;
651
                    tmp214 = tmp210 - tmp213;
652
                    tmp217 = tmp215 - tmp216;
653
                    tmp218 = tmp214 - tmp217;
654
                    tmp222 = tmp214 + tmp217;
655
               }
656
               {
657
                    fftw_real tmp179;
658
                    fftw_real tmp207;
659
                    fftw_real tmp219;
660
                    fftw_real tmp221;
661
                    ASSERT_ALIGNED_DOUBLE();
662
                    tmp179 = c_re(W[12]);
663
                    tmp207 = c_im(W[12]);
664
                    X[13 * iostride] = (tmp179 * tmp206) + (tmp207 * tmp218);
665
                    Y[-2 * iostride] = (tmp179 * tmp218) - (tmp207 * tmp206);
666
                    tmp219 = c_re(W[4]);
667
                    tmp221 = c_im(W[4]);
668
                    X[5 * iostride] = (tmp219 * tmp220) + (tmp221 * tmp222);
669
                    Y[-10 * iostride] = (tmp219 * tmp222) - (tmp221 * tmp220);
670
               }
671
          }
672
          {
673
               fftw_real tmp226;
674
               fftw_real tmp232;
675
               fftw_real tmp230;
676
               fftw_real tmp234;
677
               ASSERT_ALIGNED_DOUBLE();
678
               {
679
                    fftw_real tmp224;
680
                    fftw_real tmp225;
681
                    fftw_real tmp228;
682
                    fftw_real tmp229;
683
                    ASSERT_ALIGNED_DOUBLE();
684
                    tmp224 = tmp210 + tmp213;
685
                    tmp225 = tmp204 + tmp197;
686
                    tmp226 = tmp224 - tmp225;
687
                    tmp232 = tmp224 + tmp225;
688
                    tmp228 = tmp182 + tmp189;
689
                    tmp229 = tmp215 + tmp216;
690
                    tmp230 = tmp228 - tmp229;
691
                    tmp234 = tmp228 + tmp229;
692
               }
693
               {
694
                    fftw_real tmp223;
695
                    fftw_real tmp227;
696
                    fftw_real tmp231;
697
                    fftw_real tmp233;
698
                    ASSERT_ALIGNED_DOUBLE();
699
                    tmp223 = c_re(W[8]);
700
                    tmp227 = c_im(W[8]);
701
                    Y[-6 * iostride] = (tmp223 * tmp226) - (tmp227 * tmp230);
702
                    X[9 * iostride] = (tmp227 * tmp226) + (tmp223 * tmp230);
703
                    tmp231 = c_re(W[0]);
704
                    tmp233 = c_im(W[0]);
705
                    Y[-14 * iostride] = (tmp231 * tmp232) - (tmp233 * tmp234);
706
                    X[iostride] = (tmp233 * tmp232) + (tmp231 * tmp234);
707
               }
708
          }
709
          {
710
               fftw_real tmp246;
711
               fftw_real tmp256;
712
               fftw_real tmp254;
713
               fftw_real tmp258;
714
               ASSERT_ALIGNED_DOUBLE();
715
               {
716
                    fftw_real tmp238;
717
                    fftw_real tmp245;
718
                    fftw_real tmp250;
719
                    fftw_real tmp253;
720
                    ASSERT_ALIGNED_DOUBLE();
721
                    tmp238 = tmp236 - tmp237;
722
                    tmp245 = tmp241 + tmp244;
723
                    tmp246 = tmp238 - tmp245;
724
                    tmp256 = tmp238 + tmp245;
725
                    tmp250 = tmp248 + tmp249;
726
                    tmp253 = tmp251 - tmp252;
727
                    tmp254 = tmp250 - tmp253;
728
                    tmp258 = tmp250 + tmp253;
729
               }
730
               {
731
                    fftw_real tmp235;
732
                    fftw_real tmp247;
733
                    fftw_real tmp255;
734
                    fftw_real tmp257;
735
                    ASSERT_ALIGNED_DOUBLE();
736
                    tmp235 = c_re(W[10]);
737
                    tmp247 = c_im(W[10]);
738
                    X[11 * iostride] = (tmp235 * tmp246) + (tmp247 * tmp254);
739
                    Y[-4 * iostride] = (tmp235 * tmp254) - (tmp247 * tmp246);
740
                    tmp255 = c_re(W[2]);
741
                    tmp257 = c_im(W[2]);
742
                    X[3 * iostride] = (tmp255 * tmp256) + (tmp257 * tmp258);
743
                    Y[-12 * iostride] = (tmp255 * tmp258) - (tmp257 * tmp256);
744
               }
745
          }
746
          {
747
               fftw_real tmp262;
748
               fftw_real tmp268;
749
               fftw_real tmp266;
750
               fftw_real tmp270;
751
               ASSERT_ALIGNED_DOUBLE();
752
               {
753
                    fftw_real tmp260;
754
                    fftw_real tmp261;
755
                    fftw_real tmp264;
756
                    fftw_real tmp265;
757
                    ASSERT_ALIGNED_DOUBLE();
758
                    tmp260 = tmp248 - tmp249;
759
                    tmp261 = tmp241 - tmp244;
760
                    tmp262 = tmp260 + tmp261;
761
                    tmp268 = tmp260 - tmp261;
762
                    tmp264 = tmp236 + tmp237;
763
                    tmp265 = tmp251 + tmp252;
764
                    tmp266 = tmp264 - tmp265;
765
                    tmp270 = tmp264 + tmp265;
766
               }
767
               {
768
                    fftw_real tmp259;
769
                    fftw_real tmp263;
770
                    fftw_real tmp267;
771
                    fftw_real tmp269;
772
                    ASSERT_ALIGNED_DOUBLE();
773
                    tmp259 = c_re(W[6]);
774
                    tmp263 = c_im(W[6]);
775
                    Y[-8 * iostride] = (tmp259 * tmp262) - (tmp263 * tmp266);
776
                    X[7 * iostride] = (tmp263 * tmp262) + (tmp259 * tmp266);
777
                    tmp267 = c_re(W[14]);
778
                    tmp269 = c_im(W[14]);
779
                    Y[0] = (tmp267 * tmp268) - (tmp269 * tmp270);
780
                    X[15 * iostride] = (tmp269 * tmp268) + (tmp267 * tmp270);
781
               }
782
          }
783
     }
784
     if (i == m) {
785
          fftw_real tmp7;
786
          fftw_real tmp51;
787
          fftw_real tmp19;
788
          fftw_real tmp43;
789
          fftw_real tmp39;
790
          fftw_real tmp47;
791
          fftw_real tmp59;
792
          fftw_real tmp64;
793
          fftw_real tmp14;
794
          fftw_real tmp56;
795
          fftw_real tmp24;
796
          fftw_real tmp32;
797
          fftw_real tmp29;
798
          fftw_real tmp33;
799
          fftw_real tmp54;
800
          fftw_real tmp65;
801
          fftw_real tmp63;
802
          fftw_real tmp66;
803
          ASSERT_ALIGNED_DOUBLE();
804
          {
805
               fftw_real tmp3;
806
               fftw_real tmp15;
807
               fftw_real tmp38;
808
               fftw_real tmp57;
809
               fftw_real tmp6;
810
               fftw_real tmp35;
811
               fftw_real tmp18;
812
               fftw_real tmp58;
813
               ASSERT_ALIGNED_DOUBLE();
814
               {
815
                    fftw_real tmp1;
816
                    fftw_real tmp2;
817
                    fftw_real tmp36;
818
                    fftw_real tmp37;
819
                    ASSERT_ALIGNED_DOUBLE();
820
                    tmp1 = X[0];
821
                    tmp2 = X[7 * iostride];
822
                    tmp3 = tmp1 + tmp2;
823
                    tmp15 = tmp1 - tmp2;
824
                    tmp36 = Y[0];
825
                    tmp37 = Y[-7 * iostride];
826
                    tmp38 = tmp36 + tmp37;
827
                    tmp57 = tmp36 - tmp37;
828
               }
829
               {
830
                    fftw_real tmp4;
831
                    fftw_real tmp5;
832
                    fftw_real tmp16;
833
                    fftw_real tmp17;
834
                    ASSERT_ALIGNED_DOUBLE();
835
                    tmp4 = X[4 * iostride];
836
                    tmp5 = X[3 * iostride];
837
                    tmp6 = tmp4 + tmp5;
838
                    tmp35 = tmp4 - tmp5;
839
                    tmp16 = Y[-4 * iostride];
840
                    tmp17 = Y[-3 * iostride];
841
                    tmp18 = tmp16 + tmp17;
842
                    tmp58 = tmp16 - tmp17;
843
               }
844
               tmp7 = tmp3 + tmp6;
845
               tmp51 = tmp3 - tmp6;
846
               tmp19 = tmp15 - tmp18;
847
               tmp43 = tmp15 + tmp18;
848
               tmp39 = tmp35 + tmp38;
849
               tmp47 = tmp38 - tmp35;
850
               tmp59 = tmp57 - tmp58;
851
               tmp64 = tmp58 + tmp57;
852
          }
853
          {
854
               fftw_real tmp10;
855
               fftw_real tmp20;
856
               fftw_real tmp23;
857
               fftw_real tmp53;
858
               fftw_real tmp13;
859
               fftw_real tmp25;
860
               fftw_real tmp28;
861
               fftw_real tmp52;
862
               ASSERT_ALIGNED_DOUBLE();
863
               {
864
                    fftw_real tmp8;
865
                    fftw_real tmp9;
866
                    fftw_real tmp21;
867
                    fftw_real tmp22;
868
                    ASSERT_ALIGNED_DOUBLE();
869
                    tmp8 = X[2 * iostride];
870
                    tmp9 = X[5 * iostride];
871
                    tmp10 = tmp8 + tmp9;
872
                    tmp20 = tmp8 - tmp9;
873
                    tmp21 = Y[-2 * iostride];
874
                    tmp22 = Y[-5 * iostride];
875
                    tmp23 = tmp21 + tmp22;
876
                    tmp53 = tmp21 - tmp22;
877
               }
878
               {
879
                    fftw_real tmp11;
880
                    fftw_real tmp12;
881
                    fftw_real tmp26;
882
                    fftw_real tmp27;
883
                    ASSERT_ALIGNED_DOUBLE();
884
                    tmp11 = X[iostride];
885
                    tmp12 = X[6 * iostride];
886
                    tmp13 = tmp11 + tmp12;
887
                    tmp25 = tmp11 - tmp12;
888
                    tmp26 = Y[-iostride];
889
                    tmp27 = Y[-6 * iostride];
890
                    tmp28 = tmp26 + tmp27;
891
                    tmp52 = tmp27 - tmp26;
892
               }
893
               tmp14 = tmp10 + tmp13;
894
               tmp56 = tmp10 - tmp13;
895
               tmp24 = tmp20 - tmp23;
896
               tmp32 = tmp20 + tmp23;
897
               tmp29 = tmp25 - tmp28;
898
               tmp33 = tmp25 + tmp28;
899
               tmp54 = tmp52 - tmp53;
900
               tmp65 = tmp53 + tmp52;
901
          }
902
          X[0] = K2_000000000 * (tmp7 + tmp14);
903
          X[8 * iostride] = -(K2_000000000 * (tmp65 + tmp64));
904
          tmp63 = tmp7 - tmp14;
905
          tmp66 = tmp64 - tmp65;
906
          X[4 * iostride] = K1_414213562 * (tmp63 - tmp66);
907
          X[12 * iostride] = -(K1_414213562 * (tmp63 + tmp66));
908
          {
909
               fftw_real tmp61;
910
               fftw_real tmp62;
911
               fftw_real tmp55;
912
               fftw_real tmp60;
913
               ASSERT_ALIGNED_DOUBLE();
914
               tmp61 = tmp51 - tmp54;
915
               tmp62 = tmp59 - tmp56;
916
               X[6 * iostride] = (K765366864 * tmp61) - (K1_847759065 * tmp62);
917
               X[14 * iostride] = -((K1_847759065 * tmp61) + (K765366864 * tmp62));
918
               tmp55 = tmp51 + tmp54;
919
               tmp60 = tmp56 + tmp59;
920
               X[2 * iostride] = (K1_847759065 * tmp55) - (K765366864 * tmp60);
921
               X[10 * iostride] = -((K765366864 * tmp55) + (K1_847759065 * tmp60));
922
          }
923
          {
924
               fftw_real tmp45;
925
               fftw_real tmp49;
926
               fftw_real tmp48;
927
               fftw_real tmp50;
928
               fftw_real tmp44;
929
               fftw_real tmp46;
930
               ASSERT_ALIGNED_DOUBLE();
931
               tmp44 = K707106781 * (tmp32 + tmp33);
932
               tmp45 = tmp43 - tmp44;
933
               tmp49 = tmp43 + tmp44;
934
               tmp46 = K707106781 * (tmp24 - tmp29);
935
               tmp48 = tmp46 + tmp47;
936
               tmp50 = tmp47 - tmp46;
937
               X[3 * iostride] = (K1_662939224 * tmp45) - (K1_111140466 * tmp48);
938
               X[11 * iostride] = -((K1_111140466 * tmp45) + (K1_662939224 * tmp48));
939
               X[7 * iostride] = (K390180644 * tmp49) - (K1_961570560 * tmp50);
940
               X[15 * iostride] = -((K1_961570560 * tmp49) + (K390180644 * tmp50));
941
          }
942
          {
943
               fftw_real tmp31;
944
               fftw_real tmp41;
945
               fftw_real tmp40;
946
               fftw_real tmp42;
947
               fftw_real tmp30;
948
               fftw_real tmp34;
949
               ASSERT_ALIGNED_DOUBLE();
950
               tmp30 = K707106781 * (tmp24 + tmp29);
951
               tmp31 = tmp19 + tmp30;
952
               tmp41 = tmp19 - tmp30;
953
               tmp34 = K707106781 * (tmp32 - tmp33);
954
               tmp40 = tmp34 + tmp39;
955
               tmp42 = tmp39 - tmp34;
956
               X[iostride] = (K1_961570560 * tmp31) - (K390180644 * tmp40);
957
               X[9 * iostride] = -((K390180644 * tmp31) + (K1_961570560 * tmp40));
958
               X[5 * iostride] = (K1_111140466 * tmp41) - (K1_662939224 * tmp42);
959
               X[13 * iostride] = -((K1_662939224 * tmp41) + (K1_111140466 * tmp42));
960
          }
961
     }
962
}
963
 
964
static const int twiddle_order[] =
965
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
966
fftw_codelet_desc fftw_hc2hc_backward_16_desc =
967
{
968
     "fftw_hc2hc_backward_16",
969
     (void (*)()) fftw_hc2hc_backward_16,
970
     16,
971
     FFTW_BACKWARD,
972
     FFTW_HC2HC,
973
     366,
974
     15,
975
     twiddle_order,
976
};