← Back to branch summary

~ubuntu-branches/ubuntu/quantal/fftw/quantal

« back to all changes in this revision

Viewing changes to rfftw/fcr_64.c

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2011-11-29 01:48:33 UTC
  • mfrom: (5.1.1 sid)
  • Revision ID: package-import@ubuntu.com-20111129014833-3leawsns2nghyaoj
Tags: 2.1.5-1
http://bugs.debian.org/571446
http://bugs.debian.org/633175
* Team upload.
* New upstream release
* Package moved into the Debian Science team (no answer from the previous
  maintainer) and package not maintained.
* Standards-Version updated to version 3.9.2
* Vcs-Browser & Vcs-Svn updated
* Switch to mpi-default-dev (Closes: #571446)
* Get ride of .la files (Closes: #633175)
* Fix lintian warning debhelper-but-no-misc-depends
* Fix lintian warning patch-system-but-direct-changes-in-diff 
* Switch to dpkg-source 3.0 (quilt) format

Show diffs side-by-side

added added

removed removed

Lines of Context:
rfftw/fcr_64.c
1
1
/*
2
 
 * Copyright (c) 1997-1999 Massachusetts Institute of Technology
 
2
 * Copyright (c) 1997-1999, 2003 Massachusetts Institute of Technology
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License as published by
18
18
 */
19
19
 
20
20
/* This file was automatically generated --- DO NOT EDIT */
21
 
/* Generated on Sun Nov  7 20:44:28 EST 1999 */
22
 
 
23
 
#include <fftw-int.h>
24
 
#include <fftw.h>
25
 
 
26
 
/* Generated by: ./genfft -magic-alignment-check -magic-twiddle-load-all -magic-variables 4 -magic-loopi -hc2real 64 */
 
21
/* Generated on Mon Mar 24 02:07:23 EST 2003 */
 
22
 
 
23
#include "fftw-int.h"
 
24
#include "fftw.h"
 
25
 
 
26
/* Generated by: /homee/stevenj/cvs/fftw/gensrc/genfft -magic-alignment-check -magic-twiddle-load-all -magic-variables 4 -magic-loopi -hc2real 64 */
27
27
 
28
28
/*
29
29
 * This function contains 394 FP additions, 146 FP multiplications,
30
30
 * (or, 342 additions, 94 multiplications, 52 fused multiply/add),
31
31
 * 86 stack variables, and 128 memory accesses
32
32
 */
33
 
static const fftw_real K555570233 = FFTW_KONST(+0.555570233019602224742830813948532874374937191);
34
 
static const fftw_real K831469612 = FFTW_KONST(+0.831469612302545237078788377617905756738560812);
35
 
static const fftw_real K195090322 = FFTW_KONST(+0.195090322016128267848284868477022240927691618);
36
 
static const fftw_real K980785280 = FFTW_KONST(+0.980785280403230449126182236134239036973933731);
37
 
static const fftw_real K765366864 = FFTW_KONST(+0.765366864730179543456919968060797733522689125);
38
 
static const fftw_real K1_847759065 = FFTW_KONST(+1.847759065022573512256366378793576573644833252);
39
 
static const fftw_real K995184726 = FFTW_KONST(+0.995184726672196886244836953109479921575474869);
40
 
static const fftw_real K098017140 = FFTW_KONST(+0.098017140329560601994195563888641845861136673);
41
 
static const fftw_real K471396736 = FFTW_KONST(+0.471396736825997648556387625905254377657460319);
42
 
static const fftw_real K881921264 = FFTW_KONST(+0.881921264348355029712756863660388349508442621);
43
 
static const fftw_real K773010453 = FFTW_KONST(+0.773010453362736960810906609758469800971041293);
44
 
static const fftw_real K634393284 = FFTW_KONST(+0.634393284163645498215171613225493370675687095);
45
 
static const fftw_real K290284677 = FFTW_KONST(+0.290284677254462367636192375817395274691476278);
46
 
static const fftw_real K956940335 = FFTW_KONST(+0.956940335732208864935797886980269969482849206);
47
 
static const fftw_real K1_414213562 = FFTW_KONST(+1.414213562373095048801688724209698078569671875);
48
 
static const fftw_real K2_000000000 = FFTW_KONST(+2.000000000000000000000000000000000000000000000);
 
33
static const fftw_real K980785280 =
 
34
FFTW_KONST(+0.980785280403230449126182236134239036973933731);
 
35
static const fftw_real K195090322 =
 
36
FFTW_KONST(+0.195090322016128267848284868477022240927691618);
 
37
static const fftw_real K555570233 =
 
38
FFTW_KONST(+0.555570233019602224742830813948532874374937191);
 
39
static const fftw_real K831469612 =
 
40
FFTW_KONST(+0.831469612302545237078788377617905756738560812);
 
41
static const fftw_real K765366864 =
 
42
FFTW_KONST(+0.765366864730179543456919968060797733522689125);
 
43
static const fftw_real K1_847759065 =
 
44
FFTW_KONST(+1.847759065022573512256366378793576573644833252);
 
45
static const fftw_real K773010453 =
 
46
FFTW_KONST(+0.773010453362736960810906609758469800971041293);
 
47
static const fftw_real K634393284 =
 
48
FFTW_KONST(+0.634393284163645498215171613225493370675687095);
 
49
static const fftw_real K290284677 =
 
50
FFTW_KONST(+0.290284677254462367636192375817395274691476278);
 
51
static const fftw_real K956940335 =
 
52
FFTW_KONST(+0.956940335732208864935797886980269969482849206);
 
53
static const fftw_real K995184726 =
 
54
FFTW_KONST(+0.995184726672196886244836953109479921575474869);
 
55
static const fftw_real K098017140 =
 
56
FFTW_KONST(+0.098017140329560601994195563888641845861136673);
 
57
static const fftw_real K471396736 =
 
58
FFTW_KONST(+0.471396736825997648556387625905254377657460319);
 
59
static const fftw_real K881921264 =
 
60
FFTW_KONST(+0.881921264348355029712756863660388349508442621);
 
61
static const fftw_real K1_414213562 =
 
62
FFTW_KONST(+1.414213562373095048801688724209698078569671875);
 
63
static const fftw_real K2_000000000 =
 
64
FFTW_KONST(+2.000000000000000000000000000000000000000000000);
49
65
 
50
66
/*
51
67
 * Generator Id's : 
52
 
 * $Id: exprdag.ml,v 1.41 1999/05/26 15:44:14 fftw Exp $
53
 
 * $Id: fft.ml,v 1.43 1999/05/17 19:44:18 fftw Exp $
54
 
 * $Id: to_c.ml,v 1.25 1999/10/26 21:41:32 stevenj Exp $
 
68
 * $Id: exprdag.ml,v 1.43 2003/03/16 23:43:46 stevenj Exp $
 
69
 * $Id: fft.ml,v 1.44 2003/03/16 23:43:46 stevenj Exp $
 
70
 * $Id: to_c.ml,v 1.26 2003/03/16 23:43:46 stevenj Exp $
55
71
 */
56
72
 
57
 
void fftw_hc2real_64(const fftw_real *real_input, const fftw_real *imag_input, fftw_real *output, int real_istride, int imag_istride, int ostride)
 
73
void fftw_hc2real_64(const fftw_real *real_input,
 
74
                     const fftw_real *imag_input, fftw_real *output,
 
75
                     int real_istride, int imag_istride, int ostride)
58
76
{
59
77
     fftw_real tmp10;
60
78
     fftw_real tmp196;
61
79
     fftw_real tmp70;
62
80
     fftw_real tmp152;
63
 
     fftw_real tmp227;
64
 
     fftw_real tmp301;
65
 
     fftw_real tmp327;
66
 
     fftw_real tmp373;
 
81
     fftw_real tmp249;
 
82
     fftw_real tmp304;
 
83
     fftw_real tmp337;
 
84
     fftw_real tmp376;
67
85
     fftw_real tmp64;
68
86
     fftw_real tmp206;
69
87
     fftw_real tmp128;
70
 
     fftw_real tmp163;
 
88
     fftw_real tmp162;
71
89
     fftw_real tmp184;
72
90
     fftw_real tmp204;
73
91
     fftw_real tmp137;
74
 
     fftw_real tmp162;
 
92
     fftw_real tmp163;
75
93
     fftw_real tmp273;
76
 
     fftw_real tmp287;
 
94
     fftw_real tmp288;
77
95
     fftw_real tmp349;
78
 
     fftw_real tmp359;
 
96
     fftw_real tmp360;
79
97
     fftw_real tmp280;
80
 
     fftw_real tmp288;
 
98
     fftw_real tmp287;
81
99
     fftw_real tmp352;
82
 
     fftw_real tmp360;
 
100
     fftw_real tmp359;
83
101
     fftw_real tmp17;
84
102
     fftw_real tmp79;
85
103
     fftw_real tmp153;
86
104
     fftw_real tmp197;
87
 
     fftw_real tmp234;
88
 
     fftw_real tmp302;
89
 
     fftw_real tmp330;
90
 
     fftw_real tmp374;
 
105
     fftw_real tmp241;
 
106
     fftw_real tmp305;
 
107
     fftw_real tmp334;
 
108
     fftw_real tmp377;
91
109
     fftw_real tmp25;
92
110
     fftw_real tmp32;
93
111
     fftw_real tmp199;
98
116
     fftw_real tmp200;
99
117
     fftw_real tmp98;
100
118
     fftw_real tmp156;
101
 
     fftw_real tmp242;
 
119
     fftw_real tmp226;
 
120
     fftw_real tmp293;
 
121
     fftw_real tmp330;
 
122
     fftw_real tmp365;
 
123
     fftw_real tmp233;
102
124
     fftw_real tmp292;
103
 
     fftw_real tmp334;
 
125
     fftw_real tmp327;
104
126
     fftw_real tmp364;
105
 
     fftw_real tmp249;
106
 
     fftw_real tmp293;
107
 
     fftw_real tmp337;
108
 
     fftw_real tmp365;
109
127
     fftw_real tmp49;
110
128
     fftw_real tmp203;
111
129
     fftw_real tmp109;
115
133
     fftw_real tmp118;
116
134
     fftw_real tmp160;
117
135
     fftw_real tmp258;
 
136
     fftw_real tmp285;
 
137
     fftw_real tmp345;
 
138
     fftw_real tmp357;
 
139
     fftw_real tmp265;
118
140
     fftw_real tmp284;
119
141
     fftw_real tmp342;
120
142
     fftw_real tmp356;
121
 
     fftw_real tmp265;
122
 
     fftw_real tmp285;
123
 
     fftw_real tmp345;
124
 
     fftw_real tmp357;
125
143
     ASSERT_ALIGNED_DOUBLE;
126
144
     {
127
145
          fftw_real tmp5;
128
 
          fftw_real tmp222;
 
146
          fftw_real tmp247;
129
147
          fftw_real tmp3;
130
 
          fftw_real tmp220;
 
148
          fftw_real tmp245;
131
149
          fftw_real tmp9;
132
 
          fftw_real tmp224;
 
150
          fftw_real tmp242;
133
151
          fftw_real tmp69;
134
 
          fftw_real tmp225;
 
152
          fftw_real tmp243;
135
153
          fftw_real tmp6;
136
154
          fftw_real tmp66;
137
155
          ASSERT_ALIGNED_DOUBLE;
138
156
          {
139
157
               fftw_real tmp4;
140
 
               fftw_real tmp221;
 
158
               fftw_real tmp246;
141
159
               fftw_real tmp1;
142
160
               fftw_real tmp2;
143
161
               ASSERT_ALIGNED_DOUBLE;
144
162
               tmp4 = real_input[16 * real_istride];
145
163
               tmp5 = K2_000000000 * tmp4;
146
 
               tmp221 = imag_input[16 * imag_istride];
147
 
               tmp222 = K2_000000000 * tmp221;
 
164
               tmp246 = imag_input[16 * imag_istride];
 
165
               tmp247 = K2_000000000 * tmp246;
148
166
               tmp1 = real_input[0];
149
167
               tmp2 = real_input[32 * real_istride];
150
168
               tmp3 = tmp1 + tmp2;
151
 
               tmp220 = tmp1 - tmp2;
 
169
               tmp245 = tmp1 - tmp2;
152
170
               {
153
171
                    fftw_real tmp7;
154
172
                    fftw_real tmp8;
158
176
                    tmp7 = real_input[8 * real_istride];
159
177
                    tmp8 = real_input[24 * real_istride];
160
178
                    tmp9 = K2_000000000 * (tmp7 + tmp8);
161
 
                    tmp224 = tmp7 - tmp8;
 
179
                    tmp242 = tmp7 - tmp8;
162
180
                    tmp67 = imag_input[8 * imag_istride];
163
181
                    tmp68 = imag_input[24 * imag_istride];
164
182
                    tmp69 = K2_000000000 * (tmp67 - tmp68);
165
 
                    tmp225 = tmp68 + tmp67;
 
183
                    tmp243 = tmp67 + tmp68;
166
184
               }
167
185
          }
168
186
          tmp6 = tmp3 + tmp5;
172
190
          tmp70 = tmp66 - tmp69;
173
191
          tmp152 = tmp66 + tmp69;
174
192
          {
175
 
               fftw_real tmp223;
176
 
               fftw_real tmp226;
177
 
               fftw_real tmp325;
178
 
               fftw_real tmp326;
 
193
               fftw_real tmp244;
 
194
               fftw_real tmp248;
 
195
               fftw_real tmp335;
 
196
               fftw_real tmp336;
179
197
               ASSERT_ALIGNED_DOUBLE;
180
 
               tmp223 = tmp220 - tmp222;
181
 
               tmp226 = K1_414213562 * (tmp224 - tmp225);
182
 
               tmp227 = tmp223 + tmp226;
183
 
               tmp301 = tmp223 - tmp226;
184
 
               tmp325 = tmp220 + tmp222;
185
 
               tmp326 = K1_414213562 * (tmp224 + tmp225);
186
 
               tmp327 = tmp325 - tmp326;
187
 
               tmp373 = tmp325 + tmp326;
 
198
               tmp244 = K1_414213562 * (tmp242 - tmp243);
 
199
               tmp248 = tmp245 - tmp247;
 
200
               tmp249 = tmp244 + tmp248;
 
201
               tmp304 = tmp248 - tmp244;
 
202
               tmp335 = tmp245 + tmp247;
 
203
               tmp336 = K1_414213562 * (tmp242 + tmp243);
 
204
               tmp337 = tmp335 - tmp336;
 
205
               tmp376 = tmp336 + tmp335;
188
206
          }
189
207
     }
190
208
     {
191
209
          fftw_real tmp52;
192
 
          fftw_real tmp267;
 
210
          fftw_real tmp274;
193
211
          fftw_real tmp135;
194
 
          fftw_real tmp271;
 
212
          fftw_real tmp278;
195
213
          fftw_real tmp55;
196
 
          fftw_real tmp270;
 
214
          fftw_real tmp277;
197
215
          fftw_real tmp132;
198
 
          fftw_real tmp268;
 
216
          fftw_real tmp275;
199
217
          fftw_real tmp59;
200
 
          fftw_real tmp274;
 
218
          fftw_real tmp267;
201
219
          fftw_real tmp126;
202
 
          fftw_real tmp278;
 
220
          fftw_real tmp271;
203
221
          fftw_real tmp62;
204
 
          fftw_real tmp277;
 
222
          fftw_real tmp270;
205
223
          fftw_real tmp123;
206
 
          fftw_real tmp275;
 
224
          fftw_real tmp268;
207
225
          ASSERT_ALIGNED_DOUBLE;
208
226
          {
209
227
               fftw_real tmp50;
214
232
               tmp50 = real_input[3 * real_istride];
215
233
               tmp51 = real_input[29 * real_istride];
216
234
               tmp52 = tmp50 + tmp51;
217
 
               tmp267 = tmp50 - tmp51;
 
235
               tmp274 = tmp50 - tmp51;
218
236
               tmp133 = imag_input[3 * imag_istride];
219
237
               tmp134 = imag_input[29 * imag_istride];
220
238
               tmp135 = tmp133 - tmp134;
221
 
               tmp271 = tmp133 + tmp134;
 
239
               tmp278 = tmp133 + tmp134;
222
240
          }
223
241
          {
224
242
               fftw_real tmp53;
229
247
               tmp53 = real_input[13 * real_istride];
230
248
               tmp54 = real_input[19 * real_istride];
231
249
               tmp55 = tmp53 + tmp54;
232
 
               tmp270 = tmp54 - tmp53;
 
250
               tmp277 = tmp54 - tmp53;
233
251
               tmp130 = imag_input[13 * imag_istride];
234
252
               tmp131 = imag_input[19 * imag_istride];
235
253
               tmp132 = tmp130 - tmp131;
236
 
               tmp268 = tmp131 + tmp130;
 
254
               tmp275 = tmp130 + tmp131;
237
255
          }
238
256
          {
239
257
               fftw_real tmp57;
244
262
               tmp57 = real_input[5 * real_istride];
245
263
               tmp58 = real_input[27 * real_istride];
246
264
               tmp59 = tmp57 + tmp58;
247
 
               tmp274 = tmp57 - tmp58;
 
265
               tmp267 = tmp57 - tmp58;
248
266
               tmp124 = imag_input[5 * imag_istride];
249
267
               tmp125 = imag_input[27 * imag_istride];
250
268
               tmp126 = tmp124 - tmp125;
251
 
               tmp278 = tmp124 + tmp125;
 
269
               tmp271 = tmp124 + tmp125;
252
270
          }
253
271
          {
254
272
               fftw_real tmp60;
259
277
               tmp60 = real_input[11 * real_istride];
260
278
               tmp61 = real_input[21 * real_istride];
261
279
               tmp62 = tmp60 + tmp61;
262
 
               tmp277 = tmp61 - tmp60;
 
280
               tmp270 = tmp61 - tmp60;
263
281
               tmp121 = imag_input[11 * imag_istride];
264
282
               tmp122 = imag_input[21 * imag_istride];
265
283
               tmp123 = tmp121 - tmp122;
266
 
               tmp275 = tmp122 + tmp121;
 
284
               tmp268 = tmp121 + tmp122;
267
285
          }
268
286
          {
269
287
               fftw_real tmp56;
278
296
               tmp120 = tmp52 - tmp55;
279
297
               tmp127 = tmp123 + tmp126;
280
298
               tmp128 = tmp120 - tmp127;
281
 
               tmp163 = tmp120 + tmp127;
 
299
               tmp162 = tmp120 + tmp127;
282
300
          }
283
301
          {
284
302
               fftw_real tmp182;
289
307
               tmp182 = tmp135 - tmp132;
290
308
               tmp183 = tmp126 - tmp123;
291
309
               tmp184 = tmp182 - tmp183;
292
 
               tmp204 = tmp182 + tmp183;
 
310
               tmp204 = tmp183 + tmp182;
293
311
               tmp129 = tmp62 - tmp59;
294
312
               tmp136 = tmp132 + tmp135;
295
313
               tmp137 = tmp129 + tmp136;
296
 
               tmp162 = tmp136 - tmp129;
 
314
               tmp163 = tmp136 - tmp129;
297
315
          }
298
316
          {
299
317
               fftw_real tmp269;
303
321
               ASSERT_ALIGNED_DOUBLE;
304
322
               tmp269 = tmp267 - tmp268;
305
323
               tmp272 = tmp270 + tmp271;
306
 
               tmp273 = (K956940335 * tmp269) - (K290284677 * tmp272);
307
 
               tmp287 = (K290284677 * tmp269) + (K956940335 * tmp272);
 
324
               tmp273 = (K881921264 * tmp269) - (K471396736 * tmp272);
 
325
               tmp288 = (K471396736 * tmp269) + (K881921264 * tmp272);
308
326
               tmp347 = tmp267 + tmp268;
309
327
               tmp348 = tmp271 - tmp270;
310
 
               tmp349 = (K634393284 * tmp347) - (K773010453 * tmp348);
311
 
               tmp359 = (K773010453 * tmp347) + (K634393284 * tmp348);
 
328
               tmp349 = (K098017140 * tmp347) - (K995184726 * tmp348);
 
329
               tmp360 = (K995184726 * tmp347) + (K098017140 * tmp348);
312
330
          }
313
331
          {
314
332
               fftw_real tmp276;
318
336
               ASSERT_ALIGNED_DOUBLE;
319
337
               tmp276 = tmp274 - tmp275;
320
338
               tmp279 = tmp277 + tmp278;
321
 
               tmp280 = (K881921264 * tmp276) - (K471396736 * tmp279);
322
 
               tmp288 = (K471396736 * tmp276) + (K881921264 * tmp279);
 
339
               tmp280 = (K956940335 * tmp276) - (K290284677 * tmp279);
 
340
               tmp287 = (K290284677 * tmp276) + (K956940335 * tmp279);
323
341
               tmp350 = tmp274 + tmp275;
324
342
               tmp351 = tmp278 - tmp277;
325
 
               tmp352 = (K098017140 * tmp350) - (K995184726 * tmp351);
326
 
               tmp360 = (K995184726 * tmp350) + (K098017140 * tmp351);
 
343
               tmp352 = (K634393284 * tmp350) - (K773010453 * tmp351);
 
344
               tmp359 = (K773010453 * tmp350) + (K634393284 * tmp351);
327
345
          }
328
346
     }
329
347
     {
330
348
          fftw_real tmp13;
331
 
          fftw_real tmp228;
 
349
          fftw_real tmp235;
332
350
          fftw_real tmp77;
333
 
          fftw_real tmp232;
 
351
          fftw_real tmp239;
334
352
          fftw_real tmp16;
335
 
          fftw_real tmp231;
 
353
          fftw_real tmp238;
336
354
          fftw_real tmp74;
337
 
          fftw_real tmp229;
 
355
          fftw_real tmp236;
338
356
          fftw_real tmp71;
339
357
          fftw_real tmp78;
340
358
          ASSERT_ALIGNED_DOUBLE;
347
365
               tmp11 = real_input[4 * real_istride];
348
366
               tmp12 = real_input[28 * real_istride];
349
367
               tmp13 = tmp11 + tmp12;
350
 
               tmp228 = tmp11 - tmp12;
 
368
               tmp235 = tmp11 - tmp12;
351
369
               tmp75 = imag_input[4 * imag_istride];
352
370
               tmp76 = imag_input[28 * imag_istride];
353
371
               tmp77 = tmp75 - tmp76;
354
 
               tmp232 = tmp75 + tmp76;
 
372
               tmp239 = tmp75 + tmp76;
355
373
          }
356
374
          {
357
375
               fftw_real tmp14;
362
380
               tmp14 = real_input[12 * real_istride];
363
381
               tmp15 = real_input[20 * real_istride];
364
382
               tmp16 = tmp14 + tmp15;
365
 
               tmp231 = tmp15 - tmp14;
 
383
               tmp238 = tmp15 - tmp14;
366
384
               tmp72 = imag_input[12 * imag_istride];
367
385
               tmp73 = imag_input[20 * imag_istride];
368
386
               tmp74 = tmp72 - tmp73;
369
 
               tmp229 = tmp73 + tmp72;
 
387
               tmp236 = tmp72 + tmp73;
370
388
          }
371
389
          tmp17 = K2_000000000 * (tmp13 + tmp16);
372
390
          tmp71 = tmp13 - tmp16;
375
393
          tmp153 = K1_414213562 * (tmp71 + tmp78);
376
394
          tmp197 = K2_000000000 * (tmp77 - tmp74);
377
395
          {
378
 
               fftw_real tmp230;
379
 
               fftw_real tmp233;
380
 
               fftw_real tmp328;
381
 
               fftw_real tmp329;
 
396
               fftw_real tmp237;
 
397
               fftw_real tmp240;
 
398
               fftw_real tmp332;
 
399
               fftw_real tmp333;
382
400
               ASSERT_ALIGNED_DOUBLE;
383
 
               tmp230 = tmp228 - tmp229;
384
 
               tmp233 = tmp231 + tmp232;
385
 
               tmp234 = (K1_847759065 * tmp230) - (K765366864 * tmp233);
386
 
               tmp302 = (K765366864 * tmp230) + (K1_847759065 * tmp233);
387
 
               tmp328 = tmp228 + tmp229;
388
 
               tmp329 = tmp232 - tmp231;
389
 
               tmp330 = (K765366864 * tmp328) - (K1_847759065 * tmp329);
390
 
               tmp374 = (K1_847759065 * tmp328) + (K765366864 * tmp329);
 
401
               tmp237 = tmp235 - tmp236;
 
402
               tmp240 = tmp238 + tmp239;
 
403
               tmp241 = (K1_847759065 * tmp237) - (K765366864 * tmp240);
 
404
               tmp305 = (K765366864 * tmp237) + (K1_847759065 * tmp240);
 
405
               tmp332 = tmp235 + tmp236;
 
406
               tmp333 = tmp239 - tmp238;
 
407
               tmp334 = (K765366864 * tmp332) - (K1_847759065 * tmp333);
 
408
               tmp377 = (K1_847759065 * tmp332) + (K765366864 * tmp333);
391
409
          }
392
410
     }
393
411
     {
394
412
          fftw_real tmp21;
395
 
          fftw_real tmp236;
 
413
          fftw_real tmp227;
396
414
          fftw_real tmp96;
397
 
          fftw_real tmp240;
 
415
          fftw_real tmp231;
398
416
          fftw_real tmp24;
399
 
          fftw_real tmp239;
 
417
          fftw_real tmp230;
400
418
          fftw_real tmp93;
401
 
          fftw_real tmp237;
 
419
          fftw_real tmp228;
402
420
          fftw_real tmp28;
403
 
          fftw_real tmp243;
 
421
          fftw_real tmp220;
404
422
          fftw_real tmp87;
405
 
          fftw_real tmp247;
 
423
          fftw_real tmp224;
406
424
          fftw_real tmp31;
407
 
          fftw_real tmp246;
 
425
          fftw_real tmp223;
408
426
          fftw_real tmp84;
409
 
          fftw_real tmp244;
 
427
          fftw_real tmp221;
410
428
          ASSERT_ALIGNED_DOUBLE;
411
429
          {
412
430
               fftw_real tmp19;
417
435
               tmp19 = real_input[2 * real_istride];
418
436
               tmp20 = real_input[30 * real_istride];
419
437
               tmp21 = tmp19 + tmp20;
420
 
               tmp236 = tmp19 - tmp20;
 
438
               tmp227 = tmp19 - tmp20;
421
439
               tmp94 = imag_input[2 * imag_istride];
422
440
               tmp95 = imag_input[30 * imag_istride];
423
441
               tmp96 = tmp94 - tmp95;
424
 
               tmp240 = tmp94 + tmp95;
 
442
               tmp231 = tmp94 + tmp95;
425
443
          }
426
444
          {
427
445
               fftw_real tmp22;
432
450
               tmp22 = real_input[14 * real_istride];
433
451
               tmp23 = real_input[18 * real_istride];
434
452
               tmp24 = tmp22 + tmp23;
435
 
               tmp239 = tmp23 - tmp22;
 
453
               tmp230 = tmp23 - tmp22;
436
454
               tmp91 = imag_input[14 * imag_istride];
437
455
               tmp92 = imag_input[18 * imag_istride];
438
456
               tmp93 = tmp91 - tmp92;
439
 
               tmp237 = tmp92 + tmp91;
 
457
               tmp228 = tmp91 + tmp92;
440
458
          }
441
459
          {
442
460
               fftw_real tmp26;
447
465
               tmp26 = real_input[6 * real_istride];
448
466
               tmp27 = real_input[26 * real_istride];
449
467
               tmp28 = tmp26 + tmp27;
450
 
               tmp243 = tmp26 - tmp27;
 
468
               tmp220 = tmp26 - tmp27;
451
469
               tmp85 = imag_input[6 * imag_istride];
452
470
               tmp86 = imag_input[26 * imag_istride];
453
471
               tmp87 = tmp85 - tmp86;
454
 
               tmp247 = tmp85 + tmp86;
 
472
               tmp224 = tmp85 + tmp86;
455
473
          }
456
474
          {
457
475
               fftw_real tmp29;
462
480
               tmp29 = real_input[10 * real_istride];
463
481
               tmp30 = real_input[22 * real_istride];
464
482
               tmp31 = tmp29 + tmp30;
465
 
               tmp246 = tmp30 - tmp29;
 
483
               tmp223 = tmp30 - tmp29;
466
484
               tmp82 = imag_input[10 * imag_istride];
467
485
               tmp83 = imag_input[22 * imag_istride];
468
486
               tmp84 = tmp82 - tmp83;
469
 
               tmp244 = tmp83 + tmp82;
 
487
               tmp221 = tmp82 + tmp83;
470
488
          }
471
489
          {
472
490
               fftw_real tmp81;
483
501
               tmp155 = tmp81 + tmp88;
484
502
               tmp187 = tmp96 - tmp93;
485
503
               tmp188 = tmp87 - tmp84;
486
 
               tmp200 = tmp187 + tmp188;
 
504
               tmp200 = tmp188 + tmp187;
487
505
               tmp90 = tmp31 - tmp28;
488
506
               tmp97 = tmp93 + tmp96;
489
507
               tmp98 = tmp90 + tmp97;
490
508
               tmp156 = tmp97 - tmp90;
491
509
          }
492
510
          {
493
 
               fftw_real tmp238;
494
 
               fftw_real tmp241;
495
 
               fftw_real tmp332;
496
 
               fftw_real tmp333;
 
511
               fftw_real tmp222;
 
512
               fftw_real tmp225;
 
513
               fftw_real tmp328;
 
514
               fftw_real tmp329;
497
515
               ASSERT_ALIGNED_DOUBLE;
498
 
               tmp238 = tmp236 - tmp237;
499
 
               tmp241 = tmp239 + tmp240;
500
 
               tmp242 = (K980785280 * tmp238) - (K195090322 * tmp241);
501
 
               tmp292 = (K195090322 * tmp238) + (K980785280 * tmp241);
502
 
               tmp332 = tmp236 + tmp237;
503
 
               tmp333 = tmp240 - tmp239;
504
 
               tmp334 = (K831469612 * tmp332) - (K555570233 * tmp333);
505
 
               tmp364 = (K555570233 * tmp332) + (K831469612 * tmp333);
 
516
               tmp222 = tmp220 - tmp221;
 
517
               tmp225 = tmp223 + tmp224;
 
518
               tmp226 = (K831469612 * tmp222) - (K555570233 * tmp225);
 
519
               tmp293 = (K555570233 * tmp222) + (K831469612 * tmp225);
 
520
               tmp328 = tmp220 + tmp221;
 
521
               tmp329 = tmp224 - tmp223;
 
522
               tmp330 = (K195090322 * tmp328) + (K980785280 * tmp329);
 
523
               tmp365 = (K980785280 * tmp328) - (K195090322 * tmp329);
506
524
          }
507
525
          {
508
 
               fftw_real tmp245;
509
 
               fftw_real tmp248;
510
 
               fftw_real tmp335;
511
 
               fftw_real tmp336;
 
526
               fftw_real tmp229;
 
527
               fftw_real tmp232;
 
528
               fftw_real tmp325;
 
529
               fftw_real tmp326;
512
530
               ASSERT_ALIGNED_DOUBLE;
513
 
               tmp245 = tmp243 - tmp244;
514
 
               tmp248 = tmp246 + tmp247;
515
 
               tmp249 = (K831469612 * tmp245) - (K555570233 * tmp248);
516
 
               tmp293 = (K555570233 * tmp245) + (K831469612 * tmp248);
517
 
               tmp335 = tmp243 + tmp244;
518
 
               tmp336 = tmp247 - tmp246;
519
 
               tmp337 = (K195090322 * tmp335) + (K980785280 * tmp336);
520
 
               tmp365 = (K980785280 * tmp335) - (K195090322 * tmp336);
 
531
               tmp229 = tmp227 - tmp228;
 
532
               tmp232 = tmp230 + tmp231;
 
533
               tmp233 = (K980785280 * tmp229) - (K195090322 * tmp232);
 
534
               tmp292 = (K195090322 * tmp229) + (K980785280 * tmp232);
 
535
               tmp325 = tmp227 + tmp228;
 
536
               tmp326 = tmp231 - tmp230;
 
537
               tmp327 = (K831469612 * tmp325) - (K555570233 * tmp326);
 
538
               tmp364 = (K555570233 * tmp325) + (K831469612 * tmp326);
521
539
          }
522
540
     }
523
541
     {
524
542
          fftw_real tmp37;
525
 
          fftw_real tmp252;
 
543
          fftw_real tmp259;
526
544
          fftw_real tmp116;
527
 
          fftw_real tmp256;
 
545
          fftw_real tmp263;
528
546
          fftw_real tmp40;
529
 
          fftw_real tmp255;
 
547
          fftw_real tmp262;
530
548
          fftw_real tmp113;
531
 
          fftw_real tmp253;
 
549
          fftw_real tmp260;
532
550
          fftw_real tmp44;
533
 
          fftw_real tmp259;
 
551
          fftw_real tmp252;
534
552
          fftw_real tmp107;
535
 
          fftw_real tmp263;
 
553
          fftw_real tmp256;
536
554
          fftw_real tmp47;
537
 
          fftw_real tmp262;
 
555
          fftw_real tmp255;
538
556
          fftw_real tmp104;
539
 
          fftw_real tmp260;
 
557
          fftw_real tmp253;
540
558
          ASSERT_ALIGNED_DOUBLE;
541
559
          {
542
560
               fftw_real tmp35;
547
565
               tmp35 = real_input[real_istride];
548
566
               tmp36 = real_input[31 * real_istride];
549
567
               tmp37 = tmp35 + tmp36;
550
 
               tmp252 = tmp35 - tmp36;
 
568
               tmp259 = tmp35 - tmp36;
551
569
               tmp114 = imag_input[imag_istride];
552
570
               tmp115 = imag_input[31 * imag_istride];
553
571
               tmp116 = tmp114 - tmp115;
554
 
               tmp256 = tmp114 + tmp115;
 
572
               tmp263 = tmp114 + tmp115;
555
573
          }
556
574
          {
557
575
               fftw_real tmp38;
562
580
               tmp38 = real_input[15 * real_istride];
563
581
               tmp39 = real_input[17 * real_istride];
564
582
               tmp40 = tmp38 + tmp39;
565
 
               tmp255 = tmp39 - tmp38;
 
583
               tmp262 = tmp39 - tmp38;
566
584
               tmp111 = imag_input[15 * imag_istride];
567
585
               tmp112 = imag_input[17 * imag_istride];
568
586
               tmp113 = tmp111 - tmp112;
569
 
               tmp253 = tmp112 + tmp111;
 
587
               tmp260 = tmp111 + tmp112;
570
588
          }
571
589
          {
572
590
               fftw_real tmp42;
577
595
               tmp42 = real_input[7 * real_istride];
578
596
               tmp43 = real_input[25 * real_istride];
579
597
               tmp44 = tmp42 + tmp43;
580
 
               tmp259 = tmp42 - tmp43;
 
598
               tmp252 = tmp42 - tmp43;
581
599
               tmp105 = imag_input[7 * imag_istride];
582
600
               tmp106 = imag_input[25 * imag_istride];
583
601
               tmp107 = tmp105 - tmp106;
584
 
               tmp263 = tmp105 + tmp106;
 
602
               tmp256 = tmp105 + tmp106;
585
603
          }
586
604
          {
587
605
               fftw_real tmp45;
592
610
               tmp45 = real_input[9 * real_istride];
593
611
               tmp46 = real_input[23 * real_istride];
594
612
               tmp47 = tmp45 + tmp46;
595
 
               tmp262 = tmp46 - tmp45;
 
613
               tmp255 = tmp46 - tmp45;
596
614
               tmp102 = imag_input[9 * imag_istride];
597
615
               tmp103 = imag_input[23 * imag_istride];
598
616
               tmp104 = tmp102 - tmp103;
599
 
               tmp260 = tmp103 + tmp102;
 
617
               tmp253 = tmp102 + tmp103;
600
618
          }
601
619
          {
602
620
               fftw_real tmp41;
622
640
               tmp179 = tmp116 - tmp113;
623
641
               tmp180 = tmp107 - tmp104;
624
642
               tmp181 = tmp179 - tmp180;
625
 
               tmp207 = tmp179 + tmp180;
 
643
               tmp207 = tmp180 + tmp179;
626
644
               tmp110 = tmp47 - tmp44;
627
645
               tmp117 = tmp113 + tmp116;
628
646
               tmp118 = tmp110 + tmp117;
631
649
          {
632
650
               fftw_real tmp254;
633
651
               fftw_real tmp257;
634
 
               fftw_real tmp340;
635
 
               fftw_real tmp341;
 
652
               fftw_real tmp343;
 
653
               fftw_real tmp344;
636
654
               ASSERT_ALIGNED_DOUBLE;
637
655
               tmp254 = tmp252 - tmp253;
638
656
               tmp257 = tmp255 + tmp256;
639
 
               tmp258 = (K995184726 * tmp254) - (K098017140 * tmp257);
640
 
               tmp284 = (K098017140 * tmp254) + (K995184726 * tmp257);
641
 
               tmp340 = tmp252 + tmp253;
642
 
               tmp341 = tmp256 - tmp255;
643
 
               tmp342 = (K956940335 * tmp340) - (K290284677 * tmp341);
644
 
               tmp356 = (K290284677 * tmp340) + (K956940335 * tmp341);
 
657
               tmp258 = (K773010453 * tmp254) - (K634393284 * tmp257);
 
658
               tmp285 = (K634393284 * tmp254) + (K773010453 * tmp257);
 
659
               tmp343 = tmp252 + tmp253;
 
660
               tmp344 = tmp256 - tmp255;
 
661
               tmp345 = (K471396736 * tmp343) + (K881921264 * tmp344);
 
662
               tmp357 = (K881921264 * tmp343) - (K471396736 * tmp344);
645
663
          }
646
664
          {
647
665
               fftw_real tmp261;
648
666
               fftw_real tmp264;
649
 
               fftw_real tmp343;
650
 
               fftw_real tmp344;
 
667
               fftw_real tmp340;
 
668
               fftw_real tmp341;
651
669
               ASSERT_ALIGNED_DOUBLE;
652
670
               tmp261 = tmp259 - tmp260;
653
671
               tmp264 = tmp262 + tmp263;
654
 
               tmp265 = (K773010453 * tmp261) - (K634393284 * tmp264);
655
 
               tmp285 = (K634393284 * tmp261) + (K773010453 * tmp264);
656
 
               tmp343 = tmp259 + tmp260;
657
 
               tmp344 = tmp263 - tmp262;
658
 
               tmp345 = (K471396736 * tmp343) + (K881921264 * tmp344);
659
 
               tmp357 = (K881921264 * tmp343) - (K471396736 * tmp344);
 
672
               tmp265 = (K995184726 * tmp261) - (K098017140 * tmp264);
 
673
               tmp284 = (K098017140 * tmp261) + (K995184726 * tmp264);
 
674
               tmp340 = tmp259 + tmp260;
 
675
               tmp341 = tmp263 - tmp262;
 
676
               tmp342 = (K956940335 * tmp340) - (K290284677 * tmp341);
 
677
               tmp356 = (K290284677 * tmp340) + (K956940335 * tmp341);
660
678
          }
661
679
     }
662
680
     {
727
745
               tmp100 = tmp80 + tmp99;
728
746
               tmp140 = tmp80 - tmp99;
729
747
               tmp144 = tmp70 - tmp79;
730
 
               tmp145 = (K1_847759065 * tmp98) + (K765366864 * tmp89);
 
748
               tmp145 = (K765366864 * tmp89) + (K1_847759065 * tmp98);
731
749
               tmp146 = tmp144 - tmp145;
732
750
               tmp150 = tmp144 + tmp145;
733
751
          }
741
759
               tmp138 = (K831469612 * tmp128) - (K555570233 * tmp137);
742
760
               tmp139 = K2_000000000 * (tmp119 + tmp138);
743
761
               tmp147 = tmp119 - tmp138;
744
 
               tmp141 = (K980785280 * tmp118) + (K195090322 * tmp109);
745
 
               tmp142 = (K831469612 * tmp137) + (K555570233 * tmp128);
 
762
               tmp141 = (K195090322 * tmp109) + (K980785280 * tmp118);
 
763
               tmp142 = (K555570233 * tmp128) + (K831469612 * tmp137);
746
764
               tmp143 = K2_000000000 * (tmp141 - tmp142);
747
765
               tmp148 = tmp141 + tmp142;
748
766
          }
775
793
               fftw_real tmp363;
776
794
               fftw_real tmp366;
777
795
               ASSERT_ALIGNED_DOUBLE;
778
 
               tmp331 = tmp327 + tmp330;
779
 
               tmp338 = K2_000000000 * (tmp334 - tmp337);
 
796
               tmp331 = K2_000000000 * (tmp327 - tmp330);
 
797
               tmp338 = tmp334 + tmp337;
780
798
               tmp339 = tmp331 + tmp338;
781
 
               tmp355 = tmp331 - tmp338;
782
 
               tmp363 = tmp327 - tmp330;
 
799
               tmp355 = tmp338 - tmp331;
 
800
               tmp363 = tmp337 - tmp334;
783
801
               tmp366 = K2_000000000 * (tmp364 - tmp365);
784
802
               tmp367 = tmp363 - tmp366;
785
 
               tmp371 = tmp363 + tmp366;
 
803
               tmp371 = tmp366 + tmp363;
786
804
          }
787
805
          {
788
806
               fftw_real tmp346;
800
818
               tmp369 = tmp358 + tmp361;
801
819
          }
802
820
          output[35 * ostride] = tmp339 - tmp354;
803
 
          output[3 * ostride] = tmp339 + tmp354;
 
821
          output[3 * ostride] = tmp354 + tmp339;
804
822
          output[19 * ostride] = tmp355 - tmp362;
805
 
          output[51 * ostride] = tmp355 + tmp362;
 
823
          output[51 * ostride] = tmp362 + tmp355;
806
824
          tmp372 = K1_414213562 * (tmp368 + tmp369);
807
825
          output[27 * ostride] = tmp371 - tmp372;
808
 
          output[59 * ostride] = tmp371 + tmp372;
 
826
          output[59 * ostride] = tmp372 + tmp371;
809
827
          tmp370 = K1_414213562 * (tmp368 - tmp369);
810
828
          output[43 * ostride] = tmp367 - tmp370;
811
 
          output[11 * ostride] = tmp367 + tmp370;
 
829
          output[11 * ostride] = tmp370 + tmp367;
812
830
     }
813
831
     {
 
832
          fftw_real tmp378;
 
833
          fftw_real tmp389;
814
834
          fftw_real tmp375;
815
 
          fftw_real tmp389;
816
 
          fftw_real tmp378;
817
835
          fftw_real tmp390;
818
836
          fftw_real tmp382;
819
837
          fftw_real tmp392;
820
838
          fftw_real tmp385;
821
839
          fftw_real tmp393;
822
 
          fftw_real tmp376;
823
 
          fftw_real tmp377;
 
840
          fftw_real tmp373;
 
841
          fftw_real tmp374;
824
842
          ASSERT_ALIGNED_DOUBLE;
825
 
          tmp375 = tmp373 - tmp374;
826
 
          tmp389 = tmp373 + tmp374;
827
 
          tmp376 = tmp334 + tmp337;
828
 
          tmp377 = tmp364 + tmp365;
829
 
          tmp378 = K1_414213562 * (tmp376 - tmp377);
830
 
          tmp390 = K1_414213562 * (tmp377 + tmp376);
 
843
          tmp378 = tmp376 - tmp377;
 
844
          tmp389 = tmp377 + tmp376;
 
845
          tmp373 = tmp330 + tmp327;
 
846
          tmp374 = tmp365 + tmp364;
 
847
          tmp375 = K1_414213562 * (tmp373 - tmp374);
 
848
          tmp390 = K1_414213562 * (tmp373 + tmp374);
831
849
          {
832
850
               fftw_real tmp380;
833
851
               fftw_real tmp381;
834
852
               fftw_real tmp383;
835
853
               fftw_real tmp384;
836
854
               ASSERT_ALIGNED_DOUBLE;
837
 
               tmp380 = tmp342 + tmp345;
838
 
               tmp381 = tmp359 + tmp360;
 
855
               tmp380 = tmp345 + tmp342;
 
856
               tmp381 = tmp360 + tmp359;
839
857
               tmp382 = tmp380 - tmp381;
840
858
               tmp392 = tmp380 + tmp381;
841
 
               tmp383 = tmp356 + tmp357;
842
 
               tmp384 = tmp352 - tmp349;
 
859
               tmp383 = tmp357 + tmp356;
 
860
               tmp384 = tmp349 - tmp352;
843
861
               tmp385 = tmp383 + tmp384;
844
862
               tmp393 = tmp383 - tmp384;
845
863
          }
852
870
               tmp379 = tmp375 + tmp378;
853
871
               tmp386 = (K1_847759065 * tmp382) - (K765366864 * tmp385);
854
872
               output[39 * ostride] = tmp379 - tmp386;
855
 
               output[7 * ostride] = tmp379 + tmp386;
856
 
               tmp387 = tmp375 - tmp378;
 
873
               output[7 * ostride] = tmp386 + tmp379;
 
874
               tmp387 = tmp378 - tmp375;
857
875
               tmp388 = (K1_847759065 * tmp385) + (K765366864 * tmp382);
858
876
               output[23 * ostride] = tmp387 - tmp388;
859
 
               output[55 * ostride] = tmp387 + tmp388;
 
877
               output[55 * ostride] = tmp388 + tmp387;
860
878
          }
861
879
          {
862
880
               fftw_real tmp391;
867
885
               tmp391 = tmp389 - tmp390;
868
886
               tmp394 = (K765366864 * tmp392) - (K1_847759065 * tmp393);
869
887
               output[47 * ostride] = tmp391 - tmp394;
870
 
               output[15 * ostride] = tmp391 + tmp394;
871
 
               tmp395 = tmp389 + tmp390;
 
888
               output[15 * ostride] = tmp394 + tmp391;
 
889
               tmp395 = tmp390 + tmp389;
872
890
               tmp396 = (K765366864 * tmp393) + (K1_847759065 * tmp392);
873
891
               output[31 * ostride] = tmp395 - tmp396;
874
 
               output[63 * ostride] = tmp395 + tmp396;
 
892
               output[63 * ostride] = tmp396 + tmp395;
875
893
          }
876
894
     }
877
895
     {
932
950
          fftw_real tmp172;
933
951
          fftw_real tmp176;
934
952
          fftw_real tmp165;
 
953
          fftw_real tmp174;
 
954
          fftw_real tmp169;
935
955
          fftw_real tmp173;
936
 
          fftw_real tmp169;
937
 
          fftw_real tmp174;
938
956
          fftw_real tmp177;
939
957
          fftw_real tmp175;
940
958
          ASSERT_ALIGNED_DOUBLE;
946
964
               ASSERT_ALIGNED_DOUBLE;
947
965
               tmp154 = tmp152 - tmp153;
948
966
               tmp157 = (K765366864 * tmp155) - (K1_847759065 * tmp156);
949
 
               tmp158 = tmp154 + tmp157;
950
 
               tmp166 = tmp154 - tmp157;
 
967
               tmp158 = tmp154 - tmp157;
 
968
               tmp166 = tmp154 + tmp157;
951
969
               tmp170 = tmp152 + tmp153;
952
 
               tmp171 = (K765366864 * tmp156) + (K1_847759065 * tmp155);
 
970
               tmp171 = (K1_847759065 * tmp155) + (K765366864 * tmp156);
953
971
               tmp172 = tmp170 - tmp171;
954
972
               tmp176 = tmp170 + tmp171;
955
973
          }
959
977
               fftw_real tmp167;
960
978
               fftw_real tmp168;
961
979
               ASSERT_ALIGNED_DOUBLE;
962
 
               tmp161 = (K831469612 * tmp159) - (K555570233 * tmp160);
963
 
               tmp164 = (K980785280 * tmp162) + (K195090322 * tmp163);
 
980
               tmp161 = (K555570233 * tmp159) + (K831469612 * tmp160);
 
981
               tmp164 = (K980785280 * tmp162) - (K195090322 * tmp163);
964
982
               tmp165 = K2_000000000 * (tmp161 - tmp164);
965
 
               tmp173 = tmp161 + tmp164;
966
 
               tmp167 = (K831469612 * tmp160) + (K555570233 * tmp159);
967
 
               tmp168 = (K980785280 * tmp163) - (K195090322 * tmp162);
 
983
               tmp174 = tmp161 + tmp164;
 
984
               tmp167 = (K831469612 * tmp159) - (K555570233 * tmp160);
 
985
               tmp168 = (K195090322 * tmp162) + (K980785280 * tmp163);
968
986
               tmp169 = K2_000000000 * (tmp167 - tmp168);
969
 
               tmp174 = tmp167 + tmp168;
 
987
               tmp173 = tmp167 + tmp168;
970
988
          }
971
 
          output[38 * ostride] = tmp158 - tmp165;
972
 
          output[6 * ostride] = tmp158 + tmp165;
973
 
          output[22 * ostride] = tmp166 - tmp169;
974
 
          output[54 * ostride] = tmp166 + tmp169;
975
 
          tmp177 = K1_414213562 * (tmp173 + tmp174);
 
989
          output[22 * ostride] = tmp158 - tmp165;
 
990
          output[54 * ostride] = tmp158 + tmp165;
 
991
          output[38 * ostride] = tmp166 - tmp169;
 
992
          output[6 * ostride] = tmp166 + tmp169;
 
993
          tmp177 = K1_414213562 * (tmp174 + tmp173);
976
994
          output[30 * ostride] = tmp176 - tmp177;
977
995
          output[62 * ostride] = tmp176 + tmp177;
978
996
          tmp175 = K1_414213562 * (tmp173 - tmp174);
992
1010
          fftw_real tmp298;
993
1011
          ASSERT_ALIGNED_DOUBLE;
994
1012
          {
995
 
               fftw_real tmp235;
 
1013
               fftw_real tmp234;
996
1014
               fftw_real tmp250;
997
1015
               fftw_real tmp291;
998
1016
               fftw_real tmp294;
999
1017
               ASSERT_ALIGNED_DOUBLE;
1000
 
               tmp235 = tmp227 + tmp234;
1001
 
               tmp250 = K2_000000000 * (tmp242 + tmp249);
1002
 
               tmp251 = tmp235 + tmp250;
1003
 
               tmp283 = tmp235 - tmp250;
1004
 
               tmp291 = tmp227 - tmp234;
 
1018
               tmp234 = K2_000000000 * (tmp226 + tmp233);
 
1019
               tmp250 = tmp241 + tmp249;
 
1020
               tmp251 = tmp234 + tmp250;
 
1021
               tmp283 = tmp250 - tmp234;
 
1022
               tmp291 = tmp249 - tmp241;
1005
1023
               tmp294 = K2_000000000 * (tmp292 - tmp293);
1006
1024
               tmp295 = tmp291 - tmp294;
1007
 
               tmp299 = tmp291 + tmp294;
 
1025
               tmp299 = tmp294 + tmp291;
1008
1026
          }
1009
1027
          {
1010
1028
               fftw_real tmp266;
1022
1040
               tmp297 = tmp286 + tmp289;
1023
1041
          }
1024
1042
          output[33 * ostride] = tmp251 - tmp282;
1025
 
          output[ostride] = tmp251 + tmp282;
 
1043
          output[ostride] = tmp282 + tmp251;
1026
1044
          output[17 * ostride] = tmp283 - tmp290;
1027
 
          output[49 * ostride] = tmp283 + tmp290;
 
1045
          output[49 * ostride] = tmp290 + tmp283;
1028
1046
          tmp300 = K1_414213562 * (tmp296 + tmp297);
1029
1047
          output[25 * ostride] = tmp299 - tmp300;
1030
 
          output[57 * ostride] = tmp299 + tmp300;
 
1048
          output[57 * ostride] = tmp300 + tmp299;
1031
1049
          tmp298 = K1_414213562 * (tmp296 - tmp297);
1032
1050
          output[41 * ostride] = tmp295 - tmp298;
1033
 
          output[9 * ostride] = tmp295 + tmp298;
 
1051
          output[9 * ostride] = tmp298 + tmp295;
1034
1052
     }
1035
1053
     {
 
1054
          fftw_real tmp306;
 
1055
          fftw_real tmp317;
1036
1056
          fftw_real tmp303;
1037
 
          fftw_real tmp317;
1038
 
          fftw_real tmp306;
1039
1057
          fftw_real tmp318;
1040
1058
          fftw_real tmp310;
1041
1059
          fftw_real tmp320;
1042
1060
          fftw_real tmp313;
1043
1061
          fftw_real tmp321;
1044
 
          fftw_real tmp304;
1045
 
          fftw_real tmp305;
 
1062
          fftw_real tmp301;
 
1063
          fftw_real tmp302;
1046
1064
          ASSERT_ALIGNED_DOUBLE;
1047
 
          tmp303 = tmp301 - tmp302;
1048
 
          tmp317 = tmp301 + tmp302;
1049
 
          tmp304 = tmp242 - tmp249;
1050
 
          tmp305 = tmp292 + tmp293;
1051
 
          tmp306 = K1_414213562 * (tmp304 - tmp305);
1052
 
          tmp318 = K1_414213562 * (tmp304 + tmp305);
 
1065
          tmp306 = tmp304 - tmp305;
 
1066
          tmp317 = tmp305 + tmp304;
 
1067
          tmp301 = tmp233 - tmp226;
 
1068
          tmp302 = tmp293 + tmp292;
 
1069
          tmp303 = K1_414213562 * (tmp301 - tmp302);
 
1070
          tmp318 = K1_414213562 * (tmp301 + tmp302);
1053
1071
          {
1054
1072
               fftw_real tmp308;
1055
1073
               fftw_real tmp309;
1056
1074
               fftw_real tmp311;
1057
1075
               fftw_real tmp312;
1058
1076
               ASSERT_ALIGNED_DOUBLE;
1059
 
               tmp308 = tmp258 - tmp265;
1060
 
               tmp309 = tmp287 + tmp288;
 
1077
               tmp308 = tmp265 - tmp258;
 
1078
               tmp309 = tmp288 + tmp287;
1061
1079
               tmp310 = tmp308 - tmp309;
1062
1080
               tmp320 = tmp308 + tmp309;
1063
 
               tmp311 = tmp284 + tmp285;
1064
 
               tmp312 = tmp280 - tmp273;
 
1081
               tmp311 = tmp285 + tmp284;
 
1082
               tmp312 = tmp273 - tmp280;
1065
1083
               tmp313 = tmp311 + tmp312;
1066
1084
               tmp321 = tmp311 - tmp312;
1067
1085
          }
1074
1092
               tmp307 = tmp303 + tmp306;
1075
1093
               tmp314 = (K1_847759065 * tmp310) - (K765366864 * tmp313);
1076
1094
               output[37 * ostride] = tmp307 - tmp314;
1077
 
               output[5 * ostride] = tmp307 + tmp314;
1078
 
               tmp315 = tmp303 - tmp306;
 
1095
               output[5 * ostride] = tmp314 + tmp307;
 
1096
               tmp315 = tmp306 - tmp303;
1079
1097
               tmp316 = (K1_847759065 * tmp313) + (K765366864 * tmp310);
1080
1098
               output[21 * ostride] = tmp315 - tmp316;
1081
 
               output[53 * ostride] = tmp315 + tmp316;
 
1099
               output[53 * ostride] = tmp316 + tmp315;
1082
1100
          }
1083
1101
          {
1084
1102
               fftw_real tmp319;
1089
1107
               tmp319 = tmp317 - tmp318;
1090
1108
               tmp322 = (K765366864 * tmp320) - (K1_847759065 * tmp321);
1091
1109
               output[45 * ostride] = tmp319 - tmp322;
1092
 
               output[13 * ostride] = tmp319 + tmp322;
1093
 
               tmp323 = tmp317 + tmp318;
 
1110
               output[13 * ostride] = tmp322 + tmp319;
 
1111
               tmp323 = tmp318 + tmp317;
1094
1112
               tmp324 = (K765366864 * tmp321) + (K1_847759065 * tmp320);
1095
1113
               output[29 * ostride] = tmp323 - tmp324;
1096
 
               output[61 * ostride] = tmp323 + tmp324;
 
1114
               output[61 * ostride] = tmp324 + tmp323;
1097
1115
          }
1098
1116
     }
1099
1117
}
1100
1118
 
1101
 
fftw_codelet_desc fftw_hc2real_64_desc =
1102
 
{
 
1119
fftw_codelet_desc fftw_hc2real_64_desc = {
1103
1120
     "fftw_hc2real_64",
1104
1121
     (void (*)()) fftw_hc2real_64,
1105
1122
     64,