summaryrefslogtreecommitdiff
path: root/src/fftw3/rdft/codelets/r2hc
diff options
context:
space:
mode:
authorscuri <scuri>2008-10-17 06:10:15 +0000
committerscuri <scuri>2008-10-17 06:10:15 +0000
commit5a422aba704c375a307a902bafe658342e209906 (patch)
tree5005011e086bb863d8fb587ad3319bbec59b2447 /src/fftw3/rdft/codelets/r2hc
First commit - moving from LuaForge to SourceForge
Diffstat (limited to 'src/fftw3/rdft/codelets/r2hc')
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf2_16.c411
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf2_32.c853
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf2_4.c108
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf2_64.c1906
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf2_8.c192
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_10.c253
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_12.c300
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_15.c405
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_16.c406
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_2.c75
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_3.c97
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_32.c892
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_4.c111
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_5.c143
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_6.c160
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_64.c2001
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_7.c178
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_8.c203
-rw-r--r--src/fftw3/rdft/codelets/r2hc/hf_9.c256
-rw-r--r--src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c368
-rw-r--r--src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c799
-rw-r--r--src/fftw3/rdft/codelets/r2hc/mr2hc_128.c1647
-rw-r--r--src/fftw3/rdft/codelets/r2hc/mr2hc_32.c330
-rw-r--r--src/fftw3/rdft/codelets/r2hc/mr2hc_64.c729
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_10.c112
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_12.c128
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_15.c155
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_16.c171
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_2.c58
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_3.c63
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_32.c358
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_4.c65
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_5.c78
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_6.c73
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_7.c83
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_8.c96
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hcII_9.c118
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_10.c115
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_11.c102
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_12.c124
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_13.c194
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_14.c130
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_15.c168
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_16.c159
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_2.c58
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_3.c63
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_32.c320
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_4.c64
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_5.c78
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_6.c79
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_7.c83
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_8.c92
-rw-r--r--src/fftw3/rdft/codelets/r2hc/r2hc_9.c115
-rw-r--r--src/fftw3/rdft/codelets/r2hc/rhcodlist.c114
54 files changed, 16439 insertions, 0 deletions
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_16.c b/src/fftw3/rdft/codelets/r2hc/hf2_16.c
new file mode 100644
index 0000000..47323ee
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf2_16.c
@@ -0,0 +1,411 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:30 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 16 -dit -name hf2_16 -include hf.h */
+
+/*
+ * This function contains 196 FP additions, 108 FP multiplications,
+ * (or, 156 additions, 68 multiplications, 40 fused multiply/add),
+ * 104 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf2_16(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) {
+ E T1, T3d, T18, T26, T29, T2R, Tq, T1r, T1E, T2k, T2g, T1O, Te, T3c, Tz;
+ E T1P, T1S, T1T, T1U, TG, TL, T1V, T1Y, T1Z, T20, TT, TY, T1X, T1A, T2l;
+ E T1J, T2h, T1h, T2b, T1m, T2a;
+ T1 = rio[0];
+ T3d = iio[-WS(ios, 15)];
+ {
+ E T9, T1z, Td, T1v, T1I, Tl, Tp, T1G, Tu, T1D, TD, Ty, T1C, T1l, TX;
+ E TK, T1g, TI, T1j, TF, T1c, TQ, TS, T1p, T1q, TV, T2, T5, Ti, Tg;
+ E T4, Tw, Ts, Ta, Tv, T7, Tb, Tr, Tk, TW, TJ, TC, TU, To, TE;
+ E TH, T14, T24, T17, T25, TN, TO, TP, TR;
+ T9 = rio[WS(ios, 8)];
+ T1z = iio[-WS(ios, 8)];
+ Td = iio[-WS(ios, 7)];
+ T1v = rio[WS(ios, 7)];
+ T1I = iio[-WS(ios, 4)];
+ Tl = rio[WS(ios, 4)];
+ Tp = iio[-WS(ios, 11)];
+ T1G = rio[WS(ios, 11)];
+ Tu = rio[WS(ios, 12)];
+ T1D = iio[-WS(ios, 12)];
+ TD = rio[WS(ios, 2)];
+ Ty = iio[-WS(ios, 3)];
+ T1C = rio[WS(ios, 3)];
+ T1l = iio[-WS(ios, 2)];
+ TX = iio[-WS(ios, 9)];
+ TK = iio[-WS(ios, 5)];
+ T1g = iio[-WS(ios, 10)];
+ TI = rio[WS(ios, 10)];
+ T1j = rio[WS(ios, 13)];
+ TF = iio[-WS(ios, 13)];
+ T1c = rio[WS(ios, 5)];
+ TQ = rio[WS(ios, 14)];
+ TS = iio[-WS(ios, 1)];
+ T1p = rio[WS(ios, 15)];
+ T1q = iio[0];
+ TV = rio[WS(ios, 6)];
+ {
+ E T12, T16, T13, T15, T3, T6, Tm, Tj, Tn, Th;
+ T12 = rio[WS(ios, 1)];
+ T16 = iio[-WS(ios, 6)];
+ T13 = iio[-WS(ios, 14)];
+ T15 = rio[WS(ios, 9)];
+ T2 = W[4];
+ T5 = W[5];
+ T3 = W[0];
+ T6 = W[1];
+ Ti = W[3];
+ Tg = W[2];
+ T4 = T2 * T3;
+ Tw = T5 * Tg;
+ Ts = T5 * Ti;
+ Ta = T2 * T6;
+ Tv = T2 * Ti;
+ T7 = T5 * T6;
+ Tb = T5 * T3;
+ Tr = T2 * Tg;
+ Tm = Tg * T6;
+ Tj = Ti * T6;
+ Tn = Ti * T3;
+ Th = Tg * T3;
+ Tk = Th - Tj;
+ TW = Tv - Tw;
+ TJ = Ta + Tb;
+ TC = Th + Tj;
+ TU = Tr + Ts;
+ To = Tm + Tn;
+ TE = Tm - Tn;
+ TH = T4 - T7;
+ T14 = FMA(T3, T12, T6 * T13);
+ T24 = FNMS(T6, T12, T3 * T13);
+ T17 = FMA(T2, T15, T5 * T16);
+ T25 = FNMS(T5, T15, T2 * T16);
+ TN = W[6];
+ TO = W[7];
+ TP = FMA(TN, T3, TO * T6);
+ TR = FNMS(TO, T3, TN * T6);
+ }
+ T18 = T14 + T17;
+ T26 = T24 - T25;
+ T29 = T14 - T17;
+ T2R = T24 + T25;
+ Tq = FMA(Tk, Tl, To * Tp);
+ T1r = FMA(TN, T1p, TO * T1q);
+ T1E = FMA(Tg, T1C, Ti * T1D);
+ T2k = FNMS(TO, T1p, TN * T1q);
+ T2g = FNMS(Ti, T1C, Tg * T1D);
+ {
+ E T8, Tc, Tt, Tx;
+ T1O = FNMS(To, Tl, Tk * Tp);
+ T8 = T4 + T7;
+ Tc = Ta - Tb;
+ Te = FNMS(Tc, Td, T8 * T9);
+ T3c = FMA(Tc, T9, T8 * Td);
+ Tt = Tr - Ts;
+ Tx = Tv + Tw;
+ Tz = FMA(Tt, Tu, Tx * Ty);
+ T1P = FNMS(Tx, Tu, Tt * Ty);
+ T1S = FMA(TE, TD, TC * TF);
+ T1T = FNMS(TJ, TI, TH * TK);
+ T1U = T1S - T1T;
+ }
+ TG = FNMS(TE, TF, TC * TD);
+ TL = FMA(TH, TI, TJ * TK);
+ T1V = TG - TL;
+ T1Y = FMA(TR, TQ, TP * TS);
+ T1Z = FMA(TW, TV, TU * TX);
+ T20 = T1Y - T1Z;
+ TT = FNMS(TR, TS, TP * TQ);
+ TY = FNMS(TW, TX, TU * TV);
+ T1X = TT - TY;
+ {
+ E T1u, T1F, T1y, T1H;
+ {
+ E T1s, T1t, T1w, T1x;
+ T1s = T2 * TC;
+ T1t = T5 * TE;
+ T1u = T1s - T1t;
+ T1F = T1s + T1t;
+ T1w = T2 * TE;
+ T1x = T5 * TC;
+ T1y = T1w + T1x;
+ T1H = T1w - T1x;
+ }
+ T1A = FMA(T1u, T1v, T1y * T1z);
+ T2l = FNMS(T1y, T1v, T1u * T1z);
+ T1J = FNMS(T1H, T1I, T1F * T1G);
+ T2h = FMA(T1H, T1G, T1F * T1I);
+ }
+ {
+ E T1b, T1i, T1f, T1k;
+ {
+ E T19, T1a, T1d, T1e;
+ T19 = T2 * Tk;
+ T1a = T5 * To;
+ T1b = T19 + T1a;
+ T1i = T19 - T1a;
+ T1d = T2 * To;
+ T1e = T5 * Tk;
+ T1f = T1d - T1e;
+ T1k = T1d + T1e;
+ }
+ T1h = FNMS(T1f, T1g, T1b * T1c);
+ T2b = FNMS(T1k, T1j, T1i * T1l);
+ T1m = FMA(T1i, T1j, T1k * T1l);
+ T2a = FMA(T1f, T1c, T1b * T1g);
+ }
+ }
+ {
+ E TB, T2L, T10, T3k, T3f, T3l, T2O, T3a, T1o, T36, T2U, T32, T1L, T37, T2Z;
+ E T33;
+ {
+ E Tf, TA, T2M, T2N;
+ Tf = T1 + Te;
+ TA = Tq + Tz;
+ TB = Tf + TA;
+ T2L = Tf - TA;
+ {
+ E TM, TZ, T3b, T3e;
+ TM = TG + TL;
+ TZ = TT + TY;
+ T10 = TM + TZ;
+ T3k = TZ - TM;
+ T3b = T1O + T1P;
+ T3e = T3c + T3d;
+ T3f = T3b + T3e;
+ T3l = T3e - T3b;
+ }
+ T2M = T1S + T1T;
+ T2N = T1Y + T1Z;
+ T2O = T2M - T2N;
+ T3a = T2M + T2N;
+ {
+ E T1n, T2Q, T2S, T2T;
+ T1n = T1h + T1m;
+ T2Q = T18 - T1n;
+ T2S = T2a + T2b;
+ T2T = T2R - T2S;
+ T1o = T18 + T1n;
+ T36 = T2R + T2S;
+ T2U = T2Q + T2T;
+ T32 = T2T - T2Q;
+ }
+ {
+ E T1B, T1K, T2V, T2W, T2X, T2Y;
+ T1B = T1r + T1A;
+ T1K = T1E + T1J;
+ T2V = T1B - T1K;
+ T2W = T2k + T2l;
+ T2X = T2g + T2h;
+ T2Y = T2W - T2X;
+ T1L = T1B + T1K;
+ T37 = T2W + T2X;
+ T2Z = T2V - T2Y;
+ T33 = T2V + T2Y;
+ }
+ }
+ {
+ E T11, T1M, T39, T3g;
+ T11 = TB + T10;
+ T1M = T1o + T1L;
+ iio[-WS(ios, 8)] = T11 - T1M;
+ rio[0] = T11 + T1M;
+ T39 = T36 + T37;
+ T3g = T3a + T3f;
+ rio[WS(ios, 8)] = T39 - T3g;
+ iio[0] = T39 + T3g;
+ }
+ {
+ E T2P, T30, T3j, T3m;
+ T2P = T2L + T2O;
+ T30 = KP707106781 * (T2U + T2Z);
+ iio[-WS(ios, 10)] = T2P - T30;
+ rio[WS(ios, 2)] = T2P + T30;
+ T3j = KP707106781 * (T32 + T33);
+ T3m = T3k + T3l;
+ rio[WS(ios, 10)] = T3j - T3m;
+ iio[-WS(ios, 2)] = T3j + T3m;
+ }
+ {
+ E T31, T34, T3n, T3o;
+ T31 = T2L - T2O;
+ T34 = KP707106781 * (T32 - T33);
+ iio[-WS(ios, 14)] = T31 - T34;
+ rio[WS(ios, 6)] = T31 + T34;
+ T3n = KP707106781 * (T2Z - T2U);
+ T3o = T3l - T3k;
+ rio[WS(ios, 14)] = T3n - T3o;
+ iio[-WS(ios, 6)] = T3n + T3o;
+ }
+ {
+ E T35, T38, T3h, T3i;
+ T35 = TB - T10;
+ T38 = T36 - T37;
+ iio[-WS(ios, 12)] = T35 - T38;
+ rio[WS(ios, 4)] = T35 + T38;
+ T3h = T1L - T1o;
+ T3i = T3f - T3a;
+ rio[WS(ios, 12)] = T3h - T3i;
+ iio[-WS(ios, 4)] = T3h + T3i;
+ }
+ }
+ {
+ E T1R, T2v, T22, T3q, T3t, T3z, T2y, T3y, T2e, T2I, T2s, T2C, T2p, T2J, T2t;
+ E T2F;
+ {
+ E T1N, T1Q, T2w, T2x;
+ T1N = T1 - Te;
+ T1Q = T1O - T1P;
+ T1R = T1N - T1Q;
+ T2v = T1N + T1Q;
+ {
+ E T1W, T21, T3r, T3s;
+ T1W = T1U - T1V;
+ T21 = T1X + T20;
+ T22 = KP707106781 * (T1W - T21);
+ T3q = KP707106781 * (T1W + T21);
+ T3r = T3d - T3c;
+ T3s = Tq - Tz;
+ T3t = T3r - T3s;
+ T3z = T3s + T3r;
+ }
+ T2w = T1V + T1U;
+ T2x = T1X - T20;
+ T2y = KP707106781 * (T2w + T2x);
+ T3y = KP707106781 * (T2x - T2w);
+ {
+ E T28, T2A, T2d, T2B, T27, T2c;
+ T27 = T1h - T1m;
+ T28 = T26 + T27;
+ T2A = T26 - T27;
+ T2c = T2a - T2b;
+ T2d = T29 - T2c;
+ T2B = T29 + T2c;
+ T2e = FMA(KP923879532, T28, KP382683432 * T2d);
+ T2I = FNMS(KP382683432, T2B, KP923879532 * T2A);
+ T2s = FNMS(KP923879532, T2d, KP382683432 * T28);
+ T2C = FMA(KP382683432, T2A, KP923879532 * T2B);
+ }
+ {
+ E T2j, T2D, T2o, T2E;
+ {
+ E T2f, T2i, T2m, T2n;
+ T2f = T1r - T1A;
+ T2i = T2g - T2h;
+ T2j = T2f - T2i;
+ T2D = T2f + T2i;
+ T2m = T2k - T2l;
+ T2n = T1E - T1J;
+ T2o = T2m + T2n;
+ T2E = T2m - T2n;
+ }
+ T2p = FNMS(KP923879532, T2o, KP382683432 * T2j);
+ T2J = FMA(KP923879532, T2E, KP382683432 * T2D);
+ T2t = FMA(KP382683432, T2o, KP923879532 * T2j);
+ T2F = FNMS(KP382683432, T2E, KP923879532 * T2D);
+ }
+ }
+ {
+ E T23, T2q, T3x, T3A;
+ T23 = T1R + T22;
+ T2q = T2e + T2p;
+ iio[-WS(ios, 11)] = T23 - T2q;
+ rio[WS(ios, 3)] = T23 + T2q;
+ T3x = T2s + T2t;
+ T3A = T3y + T3z;
+ rio[WS(ios, 11)] = T3x - T3A;
+ iio[-WS(ios, 3)] = T3x + T3A;
+ }
+ {
+ E T2r, T2u, T3B, T3C;
+ T2r = T1R - T22;
+ T2u = T2s - T2t;
+ iio[-WS(ios, 15)] = T2r - T2u;
+ rio[WS(ios, 7)] = T2r + T2u;
+ T3B = T2p - T2e;
+ T3C = T3z - T3y;
+ rio[WS(ios, 15)] = T3B - T3C;
+ iio[-WS(ios, 7)] = T3B + T3C;
+ }
+ {
+ E T2z, T2G, T3p, T3u;
+ T2z = T2v + T2y;
+ T2G = T2C + T2F;
+ iio[-WS(ios, 9)] = T2z - T2G;
+ rio[WS(ios, 1)] = T2z + T2G;
+ T3p = T2I + T2J;
+ T3u = T3q + T3t;
+ rio[WS(ios, 9)] = T3p - T3u;
+ iio[-WS(ios, 1)] = T3p + T3u;
+ }
+ {
+ E T2H, T2K, T3v, T3w;
+ T2H = T2v - T2y;
+ T2K = T2I - T2J;
+ iio[-WS(ios, 13)] = T2H - T2K;
+ rio[WS(ios, 5)] = T2H + T2K;
+ T3v = T2F - T2C;
+ T3w = T3t - T3q;
+ rio[WS(ios, 13)] = T3v - T3w;
+ iio[-WS(ios, 5)] = T3v + T3w;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_COS, 0, 1},
+ {TW_SIN, 0, 1},
+ {TW_COS, 0, 3},
+ {TW_SIN, 0, 3},
+ {TW_COS, 0, 9},
+ {TW_SIN, 0, 9},
+ {TW_COS, 0, 15},
+ {TW_SIN, 0, 15},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 16, "hf2_16", twinstr, {156, 68, 40, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf2_16) (planner *p) {
+ X(khc2hc_dit_register) (p, hf2_16, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_32.c b/src/fftw3/rdft/codelets/r2hc/hf2_32.c
new file mode 100644
index 0000000..56c7769
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf2_32.c
@@ -0,0 +1,853 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:34 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 32 -dit -name hf2_32 -include hf.h */
+
+/*
+ * This function contains 488 FP additions, 280 FP multiplications,
+ * (or, 376 additions, 168 multiplications, 112 fused multiply/add),
+ * 204 stack variables, and 128 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf2_32(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) {
+ E T1, T3t, T4S, TQ, T3G, T49, T20, T2n, T4y, T1J, T43, T2w, T4z, T36, T4Z;
+ E TK, T8b, T40, T6l, T3U, T6k, T1h, T3L, T1D, T3V, T1s, T3X, T3E, T7E, T3O;
+ E T6h, T2k, T6w, T4i, T4x, T3q, T6I, T4O, T4P, T3w, T4T, T4R, T4U, Tm, To;
+ E TX, T4I, T3a, T3H, T31, T4Y, T3f, T4J, T2G, T4s, T4r, T2B, T4q, T4t, T27;
+ E T4a, T2M, T4m, T4n, T2P, T4l, T4o, T1U, T44, Tn, Tp, T7G;
+ T1 = rio[0];
+ {
+ E Tv, T3e, Tz, T3c, T39, TE, TI, T38, TN, T3v, TU, T1l, T3u, TW, T12;
+ E T35, T1f, T3m, T1b, T3o, T30, T2L, T16, T1k, T33, T2W, TP, T2J, T2D, T1w;
+ E T1z, T2A, T1B, T2z, T2F, T1u, T2N, T1q, T1I, T2O, T1o, T1G, T2m, T24, T1Z;
+ E T2r, T1X, T2v, T2l, T26, T2i, T1R, T1T, T2g, T2, Ti, T3, Tc, TF, TC;
+ E TG, TB, Tu, T1a, T15, Ty, T1t, T1Y, T1W, T1v, TH, T1y, T11, TD, T1A;
+ E T1e, T4g, T3k, T1n, T1p, T2e, T4M, TM, T1K, T1O, TO, T1L, T1N, Ta, Tb;
+ E T2t, Tk, T2o, Tf, Tg, T2s, Tj, T2p;
+ Tv = rio[WS(ios, 8)];
+ T3e = iio[-WS(ios, 8)];
+ Tz = iio[-WS(ios, 23)];
+ T3c = rio[WS(ios, 23)];
+ T39 = iio[-WS(ios, 24)];
+ TE = rio[WS(ios, 24)];
+ TI = iio[-WS(ios, 7)];
+ T38 = rio[WS(ios, 7)];
+ TN = rio[WS(ios, 4)];
+ T3v = iio[-WS(ios, 20)];
+ TU = rio[WS(ios, 20)];
+ T1l = iio[-WS(ios, 29)];
+ T3u = rio[WS(ios, 11)];
+ TW = iio[-WS(ios, 11)];
+ T12 = rio[WS(ios, 28)];
+ T35 = iio[-WS(ios, 16)];
+ T1f = iio[-WS(ios, 19)];
+ T3m = rio[WS(ios, 19)];
+ T1b = rio[WS(ios, 12)];
+ T3o = iio[-WS(ios, 12)];
+ T30 = iio[0];
+ T2L = iio[-WS(ios, 2)];
+ T16 = iio[-WS(ios, 3)];
+ T1k = rio[WS(ios, 2)];
+ T33 = rio[WS(ios, 15)];
+ T2W = rio[WS(ios, 31)];
+ TP = iio[-WS(ios, 27)];
+ T2J = rio[WS(ios, 29)];
+ T2D = rio[WS(ios, 21)];
+ T1w = iio[-WS(ios, 21)];
+ T1z = rio[WS(ios, 26)];
+ T2A = iio[-WS(ios, 26)];
+ T1B = iio[-WS(ios, 5)];
+ T2z = rio[WS(ios, 5)];
+ T2F = iio[-WS(ios, 10)];
+ T1u = rio[WS(ios, 10)];
+ T2N = rio[WS(ios, 13)];
+ T1q = iio[-WS(ios, 13)];
+ T1I = iio[-WS(ios, 1)];
+ T2O = iio[-WS(ios, 18)];
+ T1o = rio[WS(ios, 18)];
+ T1G = rio[WS(ios, 30)];
+ T2m = iio[-WS(ios, 22)];
+ T24 = rio[WS(ios, 22)];
+ T1Z = iio[-WS(ios, 25)];
+ T2r = rio[WS(ios, 25)];
+ T1X = rio[WS(ios, 6)];
+ T2v = iio[-WS(ios, 6)];
+ T2l = rio[WS(ios, 9)];
+ T26 = iio[-WS(ios, 9)];
+ T2i = iio[-WS(ios, 14)];
+ T1R = rio[WS(ios, 14)];
+ T1T = iio[-WS(ios, 17)];
+ T2g = rio[WS(ios, 17)];
+ {
+ E T2c, T2d, T3s, T3r, T3j, T3i, T4, T7, T5, T8, T6, T9, T14, T1d, Ts;
+ E T18, T19, T1c, Te, Td, Tt, Tw, T13, TZ, T10, Tx;
+ T2c = rio[WS(ios, 1)];
+ T2d = iio[-WS(ios, 30)];
+ T3s = iio[-WS(ios, 4)];
+ T3r = rio[WS(ios, 27)];
+ T3j = iio[-WS(ios, 28)];
+ T3i = rio[WS(ios, 3)];
+ T2 = W[6];
+ Ti = W[7];
+ T3 = W[4];
+ Tc = W[5];
+ T4 = W[2];
+ T7 = W[3];
+ T5 = W[0];
+ T8 = W[1];
+ T6 = T4 * T5;
+ T9 = T7 * T8;
+ T14 = Ti * T5;
+ T1d = Tc * T4;
+ Ts = T3 * T5;
+ T18 = T3 * T4;
+ T19 = Tc * T7;
+ T1c = T3 * T7;
+ Te = T7 * T5;
+ Td = T4 * T8;
+ Tt = Tc * T8;
+ Tw = T3 * T8;
+ TF = T2 * T7;
+ T13 = T2 * T8;
+ TC = Ti * T7;
+ TG = Ti * T4;
+ TZ = T2 * T5;
+ T10 = Ti * T8;
+ TB = T2 * T4;
+ Tx = Tc * T5;
+ Tu = Ts + Tt;
+ T1a = T18 - T19;
+ T15 = T13 + T14;
+ Ty = Tw - Tx;
+ T1t = Ts - Tt;
+ T1Y = T1c - T1d;
+ T1W = T18 + T19;
+ T1v = Tw + Tx;
+ TH = TF - TG;
+ T1y = TZ + T10;
+ T11 = TZ - T10;
+ TD = TB + TC;
+ T1A = T13 - T14;
+ T1e = T1c + T1d;
+ T3t = FMA(T2, T3r, Ti * T3s);
+ T4g = FNMS(T8, T2c, T5 * T2d);
+ T4S = FNMS(Ti, T3r, T2 * T3s);
+ T3k = FMA(T4, T3i, T7 * T3j);
+ T1n = FMA(T2, T3, Ti * Tc);
+ T1p = FNMS(Ti, T3, T2 * Tc);
+ T2e = FMA(T5, T2c, T8 * T2d);
+ T4M = FNMS(T7, T3i, T4 * T3j);
+ TM = T6 - T9;
+ T1K = T3 * TM;
+ T1O = Tc * TM;
+ TO = Td + Te;
+ T1L = Tc * TO;
+ T1N = T3 * TO;
+ Ta = T6 + T9;
+ Tb = T3 * Ta;
+ T2t = Ti * Ta;
+ Tk = Tc * Ta;
+ T2o = T2 * Ta;
+ Tf = Td - Te;
+ Tg = Tc * Tf;
+ T2s = T2 * Tf;
+ Tj = T3 * Tf;
+ T2p = Ti * Tf;
+ }
+ TQ = FMA(TM, TN, TO * TP);
+ T3G = FNMS(TO, TN, TM * TP);
+ T49 = FMA(T1Y, T1X, T1W * T1Z);
+ T20 = FNMS(T1Y, T1Z, T1W * T1X);
+ T2n = FMA(T3, T2l, Tc * T2m);
+ T4y = FNMS(Tc, T2l, T3 * T2m);
+ {
+ E T1F, T1H, TA, TJ;
+ T1F = TB - TC;
+ T1H = TF + TG;
+ T1J = FMA(T1F, T1G, T1H * T1I);
+ T43 = FNMS(T1H, T1G, T1F * T1I);
+ {
+ E T2q, T2u, T32, T34;
+ T2q = T2o - T2p;
+ T2u = T2s + T2t;
+ T2w = FMA(T2q, T2r, T2u * T2v);
+ T4z = FNMS(T2u, T2r, T2q * T2v);
+ T32 = FMA(T2, T1a, Ti * T1e);
+ T34 = FNMS(Ti, T1a, T2 * T1e);
+ T36 = FNMS(T34, T35, T32 * T33);
+ T4Z = FMA(T34, T33, T32 * T35);
+ }
+ TA = FNMS(Ty, Tz, Tu * Tv);
+ TJ = FNMS(TH, TI, TD * TE);
+ TK = TA + TJ;
+ T8b = TA - TJ;
+ {
+ E T3Y, T3Z, T3S, T3T;
+ T3Y = FNMS(T1v, T1u, T1t * T1w);
+ T3Z = FMA(T1A, T1z, T1y * T1B);
+ T40 = T3Y - T3Z;
+ T6l = T3Y + T3Z;
+ T3S = FMA(Tf, T1k, Ta * T1l);
+ T3T = FMA(T1p, T1o, T1n * T1q);
+ T3U = T3S - T3T;
+ T6k = T3S + T3T;
+ }
+ }
+ {
+ E T17, T1g, Th, Tl;
+ T17 = FMA(T11, T12, T15 * T16);
+ T1g = FMA(T1a, T1b, T1e * T1f);
+ T1h = T17 + T1g;
+ T3L = T17 - T1g;
+ {
+ E T1x, T1C, T1m, T1r;
+ T1x = FMA(T1t, T1u, T1v * T1w);
+ T1C = FNMS(T1A, T1B, T1y * T1z);
+ T1D = T1x + T1C;
+ T3V = T1x - T1C;
+ T1m = FNMS(Tf, T1l, Ta * T1k);
+ T1r = FNMS(T1p, T1q, T1n * T1o);
+ T1s = T1m + T1r;
+ T3X = T1m - T1r;
+ }
+ {
+ E T3C, T3D, T3M, T3N;
+ T3C = FMA(Ty, Tv, Tu * Tz);
+ T3D = FMA(TH, TE, TD * TI);
+ T3E = T3C - T3D;
+ T7E = T3C + T3D;
+ T3M = FNMS(T15, T12, T11 * T16);
+ T3N = FNMS(T1e, T1b, T1a * T1f);
+ T3O = T3M - T3N;
+ T6h = T3M + T3N;
+ {
+ E T2j, T4h, T2f, T2h;
+ T2f = FMA(T2, T1t, Ti * T1v);
+ T2h = FNMS(Ti, T1t, T2 * T1v);
+ T2j = FNMS(T2h, T2i, T2f * T2g);
+ T4h = FMA(T2h, T2g, T2f * T2i);
+ T2k = T2e + T2j;
+ T6w = T4g + T4h;
+ T4i = T4g - T4h;
+ T4x = T2e - T2j;
+ }
+ }
+ {
+ E T3p, T4N, T3l, T3n;
+ T3l = FNMS(Ti, Ty, T2 * Tu);
+ T3n = FMA(T2, Ty, Ti * Tu);
+ T3p = FMA(T3l, T3m, T3n * T3o);
+ T4N = FNMS(T3n, T3m, T3l * T3o);
+ T3q = T3k + T3p;
+ T6I = T4M + T4N;
+ T4O = T4M - T4N;
+ T4P = T3k - T3p;
+ }
+ Th = Tb + Tg;
+ Tl = Tj - Tk;
+ T3w = FNMS(Tl, T3v, Th * T3u);
+ T4T = FMA(Tl, T3u, Th * T3v);
+ T4R = T3t - T3w;
+ T4U = T4S - T4T;
+ Tm = FNMS(Ti, Tl, T2 * Th);
+ To = FMA(T2, Tl, Ti * Th);
+ {
+ E TR, TS, TT, TV;
+ TR = Tb - Tg;
+ TS = Tj + Tk;
+ TT = FMA(T2, TR, Ti * TS);
+ TV = FNMS(Ti, TR, T2 * TS);
+ TX = FNMS(TV, TW, TT * TU);
+ T4I = FNMS(TS, T38, TR * T39);
+ T3a = FMA(TR, T38, TS * T39);
+ T3H = FMA(TV, TU, TT * TW);
+ }
+ {
+ E T2V, T3b, T2Z, T3d;
+ {
+ E T2T, T2U, T2X, T2Y;
+ T2T = T2 * TM;
+ T2U = Ti * TO;
+ T2V = T2T - T2U;
+ T3b = T2T + T2U;
+ T2X = T2 * TO;
+ T2Y = Ti * TM;
+ T2Z = T2X + T2Y;
+ T3d = T2X - T2Y;
+ }
+ T31 = FMA(T2V, T2W, T2Z * T30);
+ T4Y = FNMS(T2Z, T2W, T2V * T30);
+ T3f = FNMS(T3d, T3e, T3b * T3c);
+ T4J = FMA(T3d, T3c, T3b * T3e);
+ }
+ {
+ E T23, T25, T1Q, T1S;
+ {
+ E T2C, T2E, T21, T22;
+ T2C = FNMS(Ti, T1Y, T2 * T1W);
+ T2E = FMA(T2, T1Y, Ti * T1W);
+ T2G = FMA(T2C, T2D, T2E * T2F);
+ T4s = FNMS(T2E, T2D, T2C * T2F);
+ T21 = T1K + T1L;
+ T22 = T1N - T1O;
+ T23 = FNMS(Ti, T22, T2 * T21);
+ T4r = FMA(T22, T2z, T21 * T2A);
+ T25 = FMA(T2, T22, Ti * T21);
+ T2B = FNMS(T22, T2A, T21 * T2z);
+ }
+ T4q = T2B - T2G;
+ T4t = T4r - T4s;
+ T27 = FMA(T23, T24, T25 * T26);
+ T4a = FNMS(T25, T24, T23 * T26);
+ {
+ E T2I, T2K, T1M, T1P;
+ T2I = T2o + T2p;
+ T2K = T2s - T2t;
+ T2M = FNMS(T2K, T2L, T2I * T2J);
+ T4m = FMA(T2K, T2J, T2I * T2L);
+ T1M = T1K - T1L;
+ T1P = T1N + T1O;
+ T1Q = FMA(T2, T1M, Ti * T1P);
+ T4n = FNMS(T1P, T2N, T1M * T2O);
+ T1S = FNMS(Ti, T1M, T2 * T1P);
+ T2P = FMA(T1M, T2N, T1P * T2O);
+ }
+ T4l = T2M - T2P;
+ T4o = T4m - T4n;
+ T1U = FNMS(T1S, T1T, T1Q * T1R);
+ T44 = FMA(T1S, T1R, T1Q * T1T);
+ }
+ }
+ }
+ Tn = rio[WS(ios, 16)];
+ Tp = iio[-WS(ios, 15)];
+ T7G = iio[-WS(ios, 31)];
+ {
+ E T1i, T7V, T6i, T7D, T42, T5e, T5A, T60, T6o, T6Y, TL, T6f, T3F, T5t, T7I;
+ E T8q, T7W, T8c, T3Q, T8p, T5w, T89, T4d, T61, T5f, T5D, T2a, T6t, T7O, T7C;
+ E T7g, T6Z, T4w, T64, T65, T4F, T5i, T5I, T5L, T5j, T2S, T7l, T7y, T6A, T6F;
+ E T73, T7i, T72, T4X, T67, T68, T56, T5l, T5P, T5S, T5m, T3z, T7q, T7z, T6L;
+ E T6Q, T76, T7n, T75;
+ {
+ E TY, T6g, T3W, T41;
+ TY = TQ + TX;
+ T1i = TY + T1h;
+ T7V = T1h - TY;
+ T6g = T3G + T3H;
+ T6i = T6g - T6h;
+ T7D = T6g + T6h;
+ T3W = T3U + T3V;
+ T41 = T3X - T40;
+ T42 = FNMS(KP923879532, T41, KP382683432 * T3W);
+ T5e = FMA(KP923879532, T3W, KP382683432 * T41);
+ }
+ {
+ E T5y, T5z, T6m, T6n;
+ T5y = T3U - T3V;
+ T5z = T3X + T40;
+ T5A = FNMS(KP382683432, T5z, KP923879532 * T5y);
+ T60 = FMA(KP382683432, T5y, KP923879532 * T5z);
+ T6m = T6k - T6l;
+ T6n = T1s - T1D;
+ T6o = T6m - T6n;
+ T6Y = T6n + T6m;
+ }
+ {
+ E Tr, T3B, Tq, T7H, T8a, T7F;
+ Tq = FMA(Tm, Tn, To * Tp);
+ Tr = T1 + Tq;
+ T3B = T1 - Tq;
+ TL = Tr + TK;
+ T6f = Tr - TK;
+ T3F = T3B - T3E;
+ T5t = T3B + T3E;
+ T7F = FNMS(To, Tn, Tm * Tp);
+ T7H = T7F + T7G;
+ T8a = T7G - T7F;
+ T7I = T7E + T7H;
+ T8q = T8b + T8a;
+ T7W = T7H - T7E;
+ T8c = T8a - T8b;
+ }
+ {
+ E T3P, T5v, T3K, T5u, T3I, T3J;
+ T3P = T3L + T3O;
+ T5v = T3L - T3O;
+ T3I = T3G - T3H;
+ T3J = TQ - TX;
+ T3K = T3I - T3J;
+ T5u = T3J + T3I;
+ T3Q = KP707106781 * (T3K - T3P);
+ T8p = KP707106781 * (T5v - T5u);
+ T5w = KP707106781 * (T5u + T5v);
+ T89 = KP707106781 * (T3K + T3P);
+ }
+ {
+ E T47, T5B, T4c, T5C;
+ {
+ E T45, T46, T48, T4b;
+ T45 = T43 - T44;
+ T46 = T20 - T27;
+ T47 = T45 + T46;
+ T5B = T45 - T46;
+ T48 = T1J - T1U;
+ T4b = T49 - T4a;
+ T4c = T48 - T4b;
+ T5C = T48 + T4b;
+ }
+ T4d = FMA(KP382683432, T47, KP923879532 * T4c);
+ T61 = FNMS(KP382683432, T5B, KP923879532 * T5C);
+ T5f = FNMS(KP923879532, T47, KP382683432 * T4c);
+ T5D = FMA(KP923879532, T5B, KP382683432 * T5C);
+ }
+ {
+ E T1E, T7e, T29, T6p, T6s, T7f;
+ T1E = T1s + T1D;
+ T7e = T6k + T6l;
+ {
+ E T1V, T28, T6q, T6r;
+ T1V = T1J + T1U;
+ T28 = T20 + T27;
+ T29 = T1V + T28;
+ T6p = T1V - T28;
+ T6q = T43 + T44;
+ T6r = T49 + T4a;
+ T6s = T6q - T6r;
+ T7f = T6q + T6r;
+ }
+ T2a = T1E + T29;
+ T6t = T6p + T6s;
+ T7O = T29 - T1E;
+ T7C = T7e + T7f;
+ T7g = T7e - T7f;
+ T6Z = T6p - T6s;
+ }
+ {
+ E T4k, T5J, T4B, T5G, T4v, T5H, T4E, T5K, T4j, T4A;
+ T4j = T2n - T2w;
+ T4k = T4i + T4j;
+ T5J = T4i - T4j;
+ T4A = T4y - T4z;
+ T4B = T4x - T4A;
+ T5G = T4x + T4A;
+ {
+ E T4p, T4u, T4C, T4D;
+ T4p = T4l - T4o;
+ T4u = T4q + T4t;
+ T4v = KP707106781 * (T4p - T4u);
+ T5H = KP707106781 * (T4u + T4p);
+ T4C = T4t - T4q;
+ T4D = T4l + T4o;
+ T4E = KP707106781 * (T4C - T4D);
+ T5K = KP707106781 * (T4C + T4D);
+ }
+ T4w = T4k - T4v;
+ T64 = T5G + T5H;
+ T65 = T5J + T5K;
+ T4F = T4B - T4E;
+ T5i = T4k + T4v;
+ T5I = T5G - T5H;
+ T5L = T5J - T5K;
+ T5j = T4B + T4E;
+ }
+ {
+ E T2y, T6B, T6y, T7j, T2R, T6z, T6E, T7k, T2x, T6x;
+ T2x = T2n + T2w;
+ T2y = T2k + T2x;
+ T6B = T2k - T2x;
+ T6x = T4y + T4z;
+ T6y = T6w - T6x;
+ T7j = T6w + T6x;
+ {
+ E T2H, T2Q, T6C, T6D;
+ T2H = T2B + T2G;
+ T2Q = T2M + T2P;
+ T2R = T2H + T2Q;
+ T6z = T2Q - T2H;
+ T6C = T4r + T4s;
+ T6D = T4m + T4n;
+ T6E = T6C - T6D;
+ T7k = T6C + T6D;
+ }
+ T2S = T2y + T2R;
+ T7l = T7j - T7k;
+ T7y = T7j + T7k;
+ T6A = T6y - T6z;
+ T6F = T6B - T6E;
+ T73 = T6B + T6E;
+ T7i = T2y - T2R;
+ T72 = T6y + T6z;
+ }
+ {
+ E T4L, T5N, T55, T5O, T4W, T5R, T52, T5Q;
+ {
+ E T4H, T4K, T53, T54;
+ T4H = T31 - T36;
+ T4K = T4I - T4J;
+ T4L = T4H - T4K;
+ T5N = T4H + T4K;
+ T53 = T4R - T4U;
+ T54 = T4P + T4O;
+ T55 = KP707106781 * (T53 - T54);
+ T5O = KP707106781 * (T54 + T53);
+ }
+ {
+ E T4Q, T4V, T50, T51;
+ T4Q = T4O - T4P;
+ T4V = T4R + T4U;
+ T4W = KP707106781 * (T4Q - T4V);
+ T5R = KP707106781 * (T4Q + T4V);
+ T50 = T4Y - T4Z;
+ T51 = T3a - T3f;
+ T52 = T50 + T51;
+ T5Q = T50 - T51;
+ }
+ T4X = T4L - T4W;
+ T67 = T5N + T5O;
+ T68 = T5Q + T5R;
+ T56 = T52 - T55;
+ T5l = T4L + T4W;
+ T5P = T5N - T5O;
+ T5S = T5Q - T5R;
+ T5m = T52 + T55;
+ }
+ {
+ E T3y, T6P, T6K, T7p, T3h, T6H, T6O, T7o, T3x, T6J;
+ T3x = T3t + T3w;
+ T3y = T3q + T3x;
+ T6P = T3x - T3q;
+ T6J = T4S + T4T;
+ T6K = T6I - T6J;
+ T7p = T6I + T6J;
+ {
+ E T37, T3g, T6M, T6N;
+ T37 = T31 + T36;
+ T3g = T3a + T3f;
+ T3h = T37 + T3g;
+ T6H = T37 - T3g;
+ T6M = T4Y + T4Z;
+ T6N = T4I + T4J;
+ T6O = T6M - T6N;
+ T7o = T6M + T6N;
+ }
+ T3z = T3h + T3y;
+ T7q = T7o - T7p;
+ T7z = T7o + T7p;
+ T6L = T6H - T6K;
+ T6Q = T6O - T6P;
+ T76 = T6O + T6P;
+ T7n = T3h - T3y;
+ T75 = T6H + T6K;
+ }
+ {
+ E T3A, T7A, T2b, T7x, T1j;
+ T3A = T2S + T3z;
+ T7A = T7y - T7z;
+ T1j = TL + T1i;
+ T2b = T1j + T2a;
+ T7x = T1j - T2a;
+ iio[-WS(ios, 16)] = T2b - T3A;
+ rio[WS(ios, 8)] = T7x + T7A;
+ rio[0] = T2b + T3A;
+ iio[-WS(ios, 24)] = T7x - T7A;
+ }
+ {
+ E T7B, T7L, T7K, T7M, T7J;
+ T7B = T7y + T7z;
+ T7L = T3z - T2S;
+ T7J = T7D + T7I;
+ T7K = T7C + T7J;
+ T7M = T7J - T7C;
+ rio[WS(ios, 16)] = T7B - T7K;
+ iio[-WS(ios, 8)] = T7L + T7M;
+ iio[0] = T7B + T7K;
+ rio[WS(ios, 24)] = T7L - T7M;
+ }
+ {
+ E T7h, T7t, T7Q, T7S, T7s, T7R, T7w, T7N, T7d, T7P;
+ T7d = TL - T1i;
+ T7h = T7d + T7g;
+ T7t = T7d - T7g;
+ T7P = T7I - T7D;
+ T7Q = T7O + T7P;
+ T7S = T7P - T7O;
+ {
+ E T7m, T7r, T7u, T7v;
+ T7m = T7i + T7l;
+ T7r = T7n - T7q;
+ T7s = KP707106781 * (T7m + T7r);
+ T7R = KP707106781 * (T7r - T7m);
+ T7u = T7l - T7i;
+ T7v = T7n + T7q;
+ T7w = KP707106781 * (T7u - T7v);
+ T7N = KP707106781 * (T7u + T7v);
+ }
+ iio[-WS(ios, 20)] = T7h - T7s;
+ rio[WS(ios, 20)] = T7N - T7Q;
+ rio[WS(ios, 4)] = T7h + T7s;
+ iio[-WS(ios, 4)] = T7N + T7Q;
+ iio[-WS(ios, 28)] = T7t - T7w;
+ rio[WS(ios, 28)] = T7R - T7S;
+ rio[WS(ios, 12)] = T7t + T7w;
+ iio[-WS(ios, 12)] = T7R + T7S;
+ }
+ {
+ E T71, T79, T7Y, T80, T78, T7Z, T7c, T7T;
+ {
+ E T6X, T70, T7U, T7X;
+ T6X = T6f + T6i;
+ T70 = KP707106781 * (T6Y + T6Z);
+ T71 = T6X + T70;
+ T79 = T6X - T70;
+ T7U = KP707106781 * (T6o + T6t);
+ T7X = T7V + T7W;
+ T7Y = T7U + T7X;
+ T80 = T7X - T7U;
+ }
+ {
+ E T74, T77, T7a, T7b;
+ T74 = FMA(KP382683432, T72, KP923879532 * T73);
+ T77 = FNMS(KP382683432, T76, KP923879532 * T75);
+ T78 = T74 + T77;
+ T7Z = T77 - T74;
+ T7a = FNMS(KP382683432, T73, KP923879532 * T72);
+ T7b = FMA(KP923879532, T76, KP382683432 * T75);
+ T7c = T7a - T7b;
+ T7T = T7a + T7b;
+ }
+ iio[-WS(ios, 18)] = T71 - T78;
+ rio[WS(ios, 18)] = T7T - T7Y;
+ rio[WS(ios, 2)] = T71 + T78;
+ iio[-WS(ios, 2)] = T7T + T7Y;
+ iio[-WS(ios, 26)] = T79 - T7c;
+ rio[WS(ios, 26)] = T7Z - T80;
+ rio[WS(ios, 10)] = T79 + T7c;
+ iio[-WS(ios, 10)] = T7Z + T80;
+ }
+ {
+ E T4f, T59, T8y, T8A, T58, T8z, T5c, T8v;
+ {
+ E T3R, T4e, T8w, T8x;
+ T3R = T3F - T3Q;
+ T4e = T42 - T4d;
+ T4f = T3R + T4e;
+ T59 = T3R - T4e;
+ T8w = T5f - T5e;
+ T8x = T8q - T8p;
+ T8y = T8w + T8x;
+ T8A = T8x - T8w;
+ }
+ {
+ E T4G, T57, T5a, T5b;
+ T4G = FMA(KP980785280, T4w, KP195090322 * T4F);
+ T57 = FNMS(KP980785280, T56, KP195090322 * T4X);
+ T58 = T4G + T57;
+ T8z = T57 - T4G;
+ T5a = FNMS(KP980785280, T4F, KP195090322 * T4w);
+ T5b = FMA(KP195090322, T56, KP980785280 * T4X);
+ T5c = T5a - T5b;
+ T8v = T5a + T5b;
+ }
+ iio[-WS(ios, 23)] = T4f - T58;
+ rio[WS(ios, 23)] = T8v - T8y;
+ rio[WS(ios, 7)] = T4f + T58;
+ iio[-WS(ios, 7)] = T8v + T8y;
+ iio[-WS(ios, 31)] = T59 - T5c;
+ rio[WS(ios, 31)] = T8z - T8A;
+ rio[WS(ios, 15)] = T59 + T5c;
+ iio[-WS(ios, 15)] = T8z + T8A;
+ }
+ {
+ E T5F, T5V, T8k, T8m, T5U, T8l, T5Y, T8h;
+ {
+ E T5x, T5E, T8i, T8j;
+ T5x = T5t - T5w;
+ T5E = T5A - T5D;
+ T5F = T5x + T5E;
+ T5V = T5x - T5E;
+ T8i = T61 - T60;
+ T8j = T8c - T89;
+ T8k = T8i + T8j;
+ T8m = T8j - T8i;
+ }
+ {
+ E T5M, T5T, T5W, T5X;
+ T5M = FMA(KP555570233, T5I, KP831469612 * T5L);
+ T5T = FNMS(KP831469612, T5S, KP555570233 * T5P);
+ T5U = T5M + T5T;
+ T8l = T5T - T5M;
+ T5W = FNMS(KP831469612, T5I, KP555570233 * T5L);
+ T5X = FMA(KP831469612, T5P, KP555570233 * T5S);
+ T5Y = T5W - T5X;
+ T8h = T5W + T5X;
+ }
+ iio[-WS(ios, 21)] = T5F - T5U;
+ rio[WS(ios, 21)] = T8h - T8k;
+ rio[WS(ios, 5)] = T5F + T5U;
+ iio[-WS(ios, 5)] = T8h + T8k;
+ iio[-WS(ios, 29)] = T5V - T5Y;
+ rio[WS(ios, 29)] = T8l - T8m;
+ rio[WS(ios, 13)] = T5V + T5Y;
+ iio[-WS(ios, 13)] = T8l + T8m;
+ }
+ {
+ E T6v, T6T, T84, T86, T6S, T85, T6W, T81;
+ {
+ E T6j, T6u, T82, T83;
+ T6j = T6f - T6i;
+ T6u = KP707106781 * (T6o - T6t);
+ T6v = T6j + T6u;
+ T6T = T6j - T6u;
+ T82 = KP707106781 * (T6Z - T6Y);
+ T83 = T7W - T7V;
+ T84 = T82 + T83;
+ T86 = T83 - T82;
+ }
+ {
+ E T6G, T6R, T6U, T6V;
+ T6G = FMA(KP923879532, T6A, KP382683432 * T6F);
+ T6R = FNMS(KP923879532, T6Q, KP382683432 * T6L);
+ T6S = T6G + T6R;
+ T85 = T6R - T6G;
+ T6U = FNMS(KP923879532, T6F, KP382683432 * T6A);
+ T6V = FMA(KP382683432, T6Q, KP923879532 * T6L);
+ T6W = T6U - T6V;
+ T81 = T6U + T6V;
+ }
+ iio[-WS(ios, 22)] = T6v - T6S;
+ rio[WS(ios, 22)] = T81 - T84;
+ rio[WS(ios, 6)] = T6v + T6S;
+ iio[-WS(ios, 6)] = T81 + T84;
+ iio[-WS(ios, 30)] = T6T - T6W;
+ rio[WS(ios, 30)] = T85 - T86;
+ rio[WS(ios, 14)] = T6T + T6W;
+ iio[-WS(ios, 14)] = T85 + T86;
+ }
+ {
+ E T5h, T5p, T8s, T8u, T5o, T8t, T5s, T8n;
+ {
+ E T5d, T5g, T8o, T8r;
+ T5d = T3F + T3Q;
+ T5g = T5e + T5f;
+ T5h = T5d + T5g;
+ T5p = T5d - T5g;
+ T8o = T42 + T4d;
+ T8r = T8p + T8q;
+ T8s = T8o + T8r;
+ T8u = T8r - T8o;
+ }
+ {
+ E T5k, T5n, T5q, T5r;
+ T5k = FMA(KP555570233, T5i, KP831469612 * T5j);
+ T5n = FNMS(KP555570233, T5m, KP831469612 * T5l);
+ T5o = T5k + T5n;
+ T8t = T5n - T5k;
+ T5q = FNMS(KP555570233, T5j, KP831469612 * T5i);
+ T5r = FMA(KP831469612, T5m, KP555570233 * T5l);
+ T5s = T5q - T5r;
+ T8n = T5q + T5r;
+ }
+ iio[-WS(ios, 19)] = T5h - T5o;
+ rio[WS(ios, 19)] = T8n - T8s;
+ rio[WS(ios, 3)] = T5h + T5o;
+ iio[-WS(ios, 3)] = T8n + T8s;
+ iio[-WS(ios, 27)] = T5p - T5s;
+ rio[WS(ios, 27)] = T8t - T8u;
+ rio[WS(ios, 11)] = T5p + T5s;
+ iio[-WS(ios, 11)] = T8t + T8u;
+ }
+ {
+ E T63, T6b, T8e, T8g, T6a, T8f, T6e, T87;
+ {
+ E T5Z, T62, T88, T8d;
+ T5Z = T5t + T5w;
+ T62 = T60 + T61;
+ T63 = T5Z + T62;
+ T6b = T5Z - T62;
+ T88 = T5A + T5D;
+ T8d = T89 + T8c;
+ T8e = T88 + T8d;
+ T8g = T8d - T88;
+ }
+ {
+ E T66, T69, T6c, T6d;
+ T66 = FMA(KP980785280, T64, KP195090322 * T65);
+ T69 = FNMS(KP195090322, T68, KP980785280 * T67);
+ T6a = T66 + T69;
+ T8f = T69 - T66;
+ T6c = FNMS(KP195090322, T64, KP980785280 * T65);
+ T6d = FMA(KP195090322, T67, KP980785280 * T68);
+ T6e = T6c - T6d;
+ T87 = T6c + T6d;
+ }
+ iio[-WS(ios, 17)] = T63 - T6a;
+ rio[WS(ios, 17)] = T87 - T8e;
+ rio[WS(ios, 1)] = T63 + T6a;
+ iio[-WS(ios, 1)] = T87 + T8e;
+ iio[-WS(ios, 25)] = T6b - T6e;
+ rio[WS(ios, 25)] = T8f - T8g;
+ rio[WS(ios, 9)] = T6b + T6e;
+ iio[-WS(ios, 9)] = T8f + T8g;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_COS, 0, 1},
+ {TW_SIN, 0, 1},
+ {TW_COS, 0, 3},
+ {TW_SIN, 0, 3},
+ {TW_COS, 0, 9},
+ {TW_SIN, 0, 9},
+ {TW_COS, 0, 27},
+ {TW_SIN, 0, 27},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 32, "hf2_32", twinstr, {376, 168, 112, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf2_32) (planner *p) {
+ X(khc2hc_dit_register) (p, hf2_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_4.c b/src/fftw3/rdft/codelets/r2hc/hf2_4.c
new file mode 100644
index 0000000..a676143
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf2_4.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:26 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 4 -dit -name hf2_4 -include hf.h */
+
+/*
+ * This function contains 24 FP additions, 16 FP multiplications,
+ * (or, 16 additions, 8 multiplications, 8 fused multiply/add),
+ * 21 stack variables, and 16 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf2_4(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 4) {
+ E T1, Tp, Ta, Te, To, Tl, Tk, Th;
+ T1 = rio[0];
+ Tp = iio[-WS(ios, 3)];
+ {
+ E T7, Td, T9, Tc, Tg, Tf, T2, T4, T3, T5, T6, T8;
+ T7 = rio[WS(ios, 2)];
+ Td = iio[-WS(ios, 2)];
+ T9 = iio[-WS(ios, 1)];
+ Tc = rio[WS(ios, 1)];
+ Tg = iio[0];
+ Tf = rio[WS(ios, 3)];
+ T2 = W[2];
+ T4 = W[3];
+ T3 = W[0];
+ T5 = W[1];
+ T6 = FMA(T2, T3, T4 * T5);
+ T8 = FNMS(T4, T3, T2 * T5);
+ Ta = FNMS(T8, T9, T6 * T7);
+ Te = FMA(T3, Tc, T5 * Td);
+ To = FMA(T8, T7, T6 * T9);
+ Tl = FNMS(T4, Tf, T2 * Tg);
+ Tk = FNMS(T5, Tc, T3 * Td);
+ Th = FMA(T2, Tf, T4 * Tg);
+ }
+ {
+ E Tb, Ti, Tn, Tq;
+ Tb = T1 + Ta;
+ Ti = Te + Th;
+ iio[-WS(ios, 2)] = Tb - Ti;
+ rio[0] = Tb + Ti;
+ Tn = Tk + Tl;
+ Tq = To + Tp;
+ rio[WS(ios, 2)] = Tn - Tq;
+ iio[0] = Tn + Tq;
+ }
+ {
+ E Tj, Tm, Tr, Ts;
+ Tj = T1 - Ta;
+ Tm = Tk - Tl;
+ iio[-WS(ios, 3)] = Tj - Tm;
+ rio[WS(ios, 1)] = Tj + Tm;
+ Tr = Th - Te;
+ Ts = Tp - To;
+ rio[WS(ios, 3)] = Tr - Ts;
+ iio[-WS(ios, 1)] = Tr + Ts;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_COS, 0, 1},
+ {TW_SIN, 0, 1},
+ {TW_COS, 0, 3},
+ {TW_SIN, 0, 3},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 4, "hf2_4", twinstr, {16, 8, 8, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf2_4) (planner *p) {
+ X(khc2hc_dit_register) (p, hf2_4, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_64.c b/src/fftw3/rdft/codelets/r2hc/hf2_64.c
new file mode 100644
index 0000000..fc2ec21
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf2_64.c
@@ -0,0 +1,1906 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:57 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 64 -dit -name hf2_64 -include hf.h */
+
+/*
+ * This function contains 1154 FP additions, 660 FP multiplications,
+ * (or, 880 additions, 386 multiplications, 274 fused multiply/add),
+ * 382 stack variables, and 256 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf2_64(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 10) {
+ E T1, T1g, T91, T7W, T7m, T2O, T4j, T7P, T4P, T8y, T2w, T8t, T2Z, T8e, T48;
+ E T1z, T7s, T1I, T7t, T8p, Ten, T1Y, T7D, T2t, T7O, T7L, Te6, T3N, T8E, T7A;
+ E Te0, T4C, TeA, T8S, T9v, T65, Tfi, T9J, Taq, T6K, Tf6, Ta2, Ta5, T73, Tfc;
+ E Tad, Tag, T3z, T83, T3u, T82, T81, T84, T15, T9K, T68, T7j, T43, T9w, T4F;
+ E T8G, T5l, TeL, T9k, T9n, T6o, Tf2, T9Q, T9R, T6z, Tf3, T9T, T9W, To, Ts;
+ E T4o, T8u, T4U, T92, T5a, TeT, T8V, T8Y, T5G, TeG, T97, T9e, T27, T7X, T2T;
+ E T7E, T7b, Tai, T6T, Ta3, Tf7, Ta8, T7Q, T2H, T2c, T76, Tah, T7F, T4d, T8z;
+ E TG, TK, T69, T6b, T3b, T87, T5u, T9l, TeM, T9q, T88, T89, T3o, T86, T5P;
+ E T9f, TeH, T9a, T34, T8f, T1r, T7n, T3S, T8F, T4G, T4I, Tp, T6c, TH, T6a;
+ E TL, Ti1, T4H, T4J, Tt;
+ T1 = rio[0];
+ {
+ E T12, T67, T14, T66, T6s, T1b, T1f, T6q, T1m, T6x, T1w, T1q, T6v, T6h, T31;
+ E T1D, T5I, T1y, T6g, T1S, T6m, T1N, T6W, T6Y, T1M, T6k, T1H, T2Y, T5L, T2W;
+ E T5N, T2b, T74, T2g, T29, T75, T26, T78, T1W, T22, T7a, T6R, T2u, T6P, T2v;
+ E T6L, T6M, T2E, T2G, T6I, T5Z, T2n, T63, T6G, T2r, T5H, T33, T5E, T2Q, T5z;
+ E T5C, T2S, T2M, T5q, T3a, T38, T5s, T2N, T5x, T5n, T3l, T5m, T3n, T5h, T5j;
+ E T3w, T3y, T58, T4a, T3t, T5d, T3r, T5e, T54, T4c, T4Z, T46, T4T, T4X, T47;
+ E T4l, T4N, T4i, T4g, T4O, T4n, T4R, T4E, T40, T4D, T42, T4y, T4A, T3J, T3L;
+ E T3R, T3G, T3E, T3P, T2i, Ta, Ty, Tf, Tw, T2, Tj, T3, Tc, T1E, T1B;
+ E T1F, T1A, T1R, T3x, T2m, T3K, T61, T1V, T60, T3I, T51, T52, T2V, T56, T5X;
+ E T3v, T55, T2X, T2q, T5W, T4w, T6E, Ta0, T8Q, Tac, T72, Tb, Tg, Th, T3e;
+ E T3f, T3h, T1a, T2x, T2B, TU, TV, TY, T1e, T2y, T2A, TC, TD, T1u, Tk;
+ E Tl, Tm, T39, T3U, T3W, T37, T3T, T3X, TQ, TR, TZ, T3c, T3d, T3i, Tx;
+ E Tz, T1t, TN, TX, T2f, T5V, Tao, T2h, T3D, T4f, T4h, T3F, T3q, T3s;
+ T12 = rio[WS(ios, 48)];
+ T67 = iio[-WS(ios, 48)];
+ T14 = iio[-WS(ios, 15)];
+ T66 = rio[WS(ios, 15)];
+ T6s = iio[-WS(ios, 8)];
+ T1b = rio[WS(ios, 8)];
+ T1f = iio[-WS(ios, 55)];
+ T6q = rio[WS(ios, 55)];
+ T1m = rio[WS(ios, 40)];
+ T6x = iio[-WS(ios, 40)];
+ T1w = rio[WS(ios, 56)];
+ T1q = iio[-WS(ios, 23)];
+ T6v = rio[WS(ios, 23)];
+ T6h = iio[-WS(ios, 56)];
+ T31 = rio[WS(ios, 50)];
+ T1D = rio[WS(ios, 24)];
+ T5I = iio[-WS(ios, 50)];
+ T1y = iio[-WS(ios, 7)];
+ T6g = rio[WS(ios, 7)];
+ T1S = rio[WS(ios, 36)];
+ T6m = iio[-WS(ios, 24)];
+ T1N = iio[-WS(ios, 59)];
+ T6W = rio[WS(ios, 59)];
+ T6Y = iio[-WS(ios, 4)];
+ T1M = rio[WS(ios, 4)];
+ T6k = rio[WS(ios, 39)];
+ T1H = iio[-WS(ios, 39)];
+ T2Y = iio[-WS(ios, 45)];
+ T5L = rio[WS(ios, 45)];
+ T2W = rio[WS(ios, 18)];
+ T5N = iio[-WS(ios, 18)];
+ T2b = iio[-WS(ios, 11)];
+ T74 = rio[WS(ios, 11)];
+ T2g = rio[WS(ios, 60)];
+ T29 = rio[WS(ios, 52)];
+ T75 = iio[-WS(ios, 52)];
+ T26 = iio[-WS(ios, 43)];
+ T78 = rio[WS(ios, 43)];
+ T1W = iio[-WS(ios, 27)];
+ T22 = rio[WS(ios, 20)];
+ T7a = iio[-WS(ios, 20)];
+ T6R = iio[-WS(ios, 12)];
+ T2u = rio[WS(ios, 12)];
+ T6P = rio[WS(ios, 51)];
+ T2v = iio[-WS(ios, 51)];
+ T6L = rio[WS(ios, 19)];
+ T6M = iio[-WS(ios, 44)];
+ T2E = rio[WS(ios, 44)];
+ T2G = iio[-WS(ios, 19)];
+ T6I = iio[-WS(ios, 28)];
+ T5Z = rio[WS(ios, 31)];
+ T2n = rio[WS(ios, 28)];
+ T63 = iio[-WS(ios, 32)];
+ T6G = rio[WS(ios, 35)];
+ T2r = iio[-WS(ios, 35)];
+ T5H = rio[WS(ios, 13)];
+ T33 = iio[-WS(ios, 13)];
+ T5E = iio[-WS(ios, 34)];
+ T2Q = rio[WS(ios, 34)];
+ T5z = iio[-WS(ios, 2)];
+ T5C = rio[WS(ios, 29)];
+ T2S = iio[-WS(ios, 29)];
+ T2M = rio[WS(ios, 2)];
+ T5q = rio[WS(ios, 53)];
+ T3a = iio[-WS(ios, 53)];
+ T38 = rio[WS(ios, 10)];
+ T5s = iio[-WS(ios, 10)];
+ T2N = iio[-WS(ios, 61)];
+ T5x = rio[WS(ios, 61)];
+ T5n = iio[-WS(ios, 42)];
+ T3l = rio[WS(ios, 42)];
+ T5m = rio[WS(ios, 21)];
+ T3n = iio[-WS(ios, 21)];
+ T5h = rio[WS(ios, 37)];
+ T5j = iio[-WS(ios, 26)];
+ T3w = rio[WS(ios, 26)];
+ T3y = iio[-WS(ios, 37)];
+ T58 = iio[-WS(ios, 38)];
+ T4a = rio[WS(ios, 38)];
+ T3t = iio[-WS(ios, 5)];
+ T5d = rio[WS(ios, 5)];
+ T3r = rio[WS(ios, 58)];
+ T5e = iio[-WS(ios, 58)];
+ T54 = rio[WS(ios, 25)];
+ T4c = iio[-WS(ios, 25)];
+ T4Z = iio[-WS(ios, 6)];
+ T46 = rio[WS(ios, 6)];
+ T4T = iio[-WS(ios, 22)];
+ T4X = rio[WS(ios, 57)];
+ T47 = iio[-WS(ios, 57)];
+ T4l = rio[WS(ios, 22)];
+ T4N = rio[WS(ios, 9)];
+ T4i = iio[-WS(ios, 9)];
+ T4g = rio[WS(ios, 54)];
+ T4O = iio[-WS(ios, 54)];
+ T4n = iio[-WS(ios, 41)];
+ T4R = rio[WS(ios, 41)];
+ T4E = iio[-WS(ios, 46)];
+ T40 = rio[WS(ios, 46)];
+ T4D = rio[WS(ios, 17)];
+ T42 = iio[-WS(ios, 17)];
+ T4y = rio[WS(ios, 33)];
+ T4A = iio[-WS(ios, 30)];
+ T3J = rio[WS(ios, 30)];
+ T3L = iio[-WS(ios, 33)];
+ T3R = iio[-WS(ios, 49)];
+ T3G = iio[-WS(ios, 1)];
+ T3E = rio[WS(ios, 62)];
+ T3P = rio[WS(ios, 14)];
+ T2i = iio[-WS(ios, 3)];
+ {
+ E T4u, T70, T71, T4v, T5T, T6C, T6D, T5U, T4, T7, T5, T8, TO, TP, T1U;
+ E T2p, T18, T2k, T2l, T2o, TT, TS, T19, T1c, T1T, T1P, T1Q, T1d;
+ T4u = rio[WS(ios, 1)];
+ T70 = rio[WS(ios, 27)];
+ T71 = iio[-WS(ios, 36)];
+ T4v = iio[-WS(ios, 62)];
+ T5T = rio[WS(ios, 63)];
+ T6C = rio[WS(ios, 3)];
+ T6D = iio[-WS(ios, 60)];
+ T5U = iio[0];
+ {
+ E T6, Te, T9, Td;
+ T4 = W[2];
+ T7 = W[3];
+ T5 = W[0];
+ T8 = W[1];
+ T6 = T4 * T5;
+ Te = T7 * T5;
+ T9 = T7 * T8;
+ Td = T4 * T8;
+ Ta = T6 - T9;
+ Ty = Td - Te;
+ Tf = Td + Te;
+ Tw = T6 + T9;
+ T2 = W[6];
+ Tj = W[7];
+ T3 = W[4];
+ Tc = W[5];
+ TO = T3 * T4;
+ TP = Tc * T7;
+ T1U = Tj * T3;
+ T2p = Tj * T5;
+ T18 = T3 * T5;
+ T2k = T2 * T5;
+ T2l = Tj * T8;
+ T2o = T2 * T8;
+ TT = Tc * T4;
+ TS = T3 * T7;
+ T19 = Tc * T8;
+ T1c = T3 * T8;
+ T1E = T2 * T7;
+ T1T = T2 * Tc;
+ T1B = Tj * T7;
+ T1F = Tj * T4;
+ T1P = T2 * T3;
+ T1Q = Tj * Tc;
+ T1A = T2 * T4;
+ T1d = Tc * T5;
+ }
+ T1R = T1P - T1Q;
+ T3x = T2o - T2p;
+ T2m = T2k - T2l;
+ T3K = T1E + T1F;
+ T61 = Tj * Ta;
+ T1V = T1T + T1U;
+ T60 = T2 * Tf;
+ T3I = T1A - T1B;
+ T51 = T2 * Tw;
+ T52 = Tj * Ty;
+ T2V = T1P + T1Q;
+ T56 = Tj * Tw;
+ T5X = Tj * Tf;
+ T3v = T2k + T2l;
+ T55 = T2 * Ty;
+ T2X = T1T - T1U;
+ T2q = T2o + T2p;
+ T5W = T2 * Ta;
+ T4w = FMA(T5, T4u, T8 * T4v);
+ T6E = FMA(T4, T6C, T7 * T6D);
+ Ta0 = FNMS(T7, T6C, T4 * T6D);
+ T8Q = FNMS(T8, T4u, T5 * T4v);
+ Tac = FNMS(Tj, T70, T2 * T71);
+ T72 = FMA(T2, T70, Tj * T71);
+ Tb = T3 * Ta;
+ Tg = Tc * Tf;
+ Th = Tb + Tg;
+ T3e = TS - TT;
+ T3f = Tj * T3e;
+ T3h = T2 * T3e;
+ T1a = T18 + T19;
+ T2x = T2 * T1a;
+ T2B = Tj * T1a;
+ TU = TS + TT;
+ TV = Tj * TU;
+ TY = T2 * TU;
+ T1e = T1c - T1d;
+ T2y = Tj * T1e;
+ T2A = T2 * T1e;
+ TC = T3 * Ty;
+ TD = Tc * Tw;
+ T1u = TC + TD;
+ Tk = T3 * Tf;
+ Tl = Tc * Ta;
+ Tm = Tk - Tl;
+ T39 = T1c + T1d;
+ T3U = Tj * T39;
+ T3W = T2 * T39;
+ T37 = T18 - T19;
+ T3T = T2 * T37;
+ T3X = Tj * T37;
+ TQ = TO - TP;
+ TR = T2 * TQ;
+ TZ = Tj * TQ;
+ T3c = TO + TP;
+ T3d = T2 * T3c;
+ T3i = Tj * T3c;
+ Tx = T3 * Tw;
+ Tz = Tc * Ty;
+ T1t = Tx - Tz;
+ TN = W[8];
+ TX = W[9];
+ T2f = FMA(TN, T4, TX * T7);
+ T5V = FMA(TN, T5T, TX * T5U);
+ Tao = FNMS(TX, T5T, TN * T5U);
+ T2h = FNMS(TX, T4, TN * T7);
+ T3D = FMA(TN, T5, TX * T8);
+ T4f = FMA(TN, T3, TX * Tc);
+ T4h = FNMS(TX, T3, TN * Tc);
+ T3F = FNMS(TX, T5, TN * T8);
+ }
+ T1g = FNMS(T1e, T1f, T1a * T1b);
+ T91 = FNMS(Tc, T4N, T3 * T4O);
+ T7W = FMA(Ty, T2M, Tw * T2N);
+ T7m = FMA(T1e, T1b, T1a * T1f);
+ T2O = FNMS(Ty, T2N, Tw * T2M);
+ T4j = FNMS(T4h, T4i, T4f * T4g);
+ T7P = FNMS(TU, T2u, TQ * T2v);
+ T4P = FMA(T3, T4N, Tc * T4O);
+ T8y = FMA(T3e, T46, T3c * T47);
+ T2w = FMA(TQ, T2u, TU * T2v);
+ {
+ E T1v, T1x, T1O, T1X;
+ T8t = FMA(T4h, T4g, T4f * T4i);
+ T2Z = FNMS(T2X, T2Y, T2V * T2W);
+ T8e = FMA(T2X, T2W, T2V * T2Y);
+ T48 = FNMS(T3e, T47, T3c * T46);
+ T1v = FMA(TN, T1t, TX * T1u);
+ T1x = FNMS(TX, T1t, TN * T1u);
+ T1z = FNMS(T1x, T1y, T1v * T1w);
+ T7s = FMA(T1x, T1w, T1v * T1y);
+ {
+ E T1C, T1G, T8n, T8o;
+ T1C = T1A + T1B;
+ T1G = T1E - T1F;
+ T1I = FNMS(T1G, T1H, T1C * T1D);
+ T7t = FMA(T1G, T1D, T1C * T1H);
+ T8n = FMA(T3F, T3E, T3D * T3G);
+ T8o = FNMS(T3K, T3J, T3I * T3L);
+ T8p = T8n - T8o;
+ Ten = T8n + T8o;
+ }
+ T1O = FMA(Ta, T1M, Tf * T1N);
+ T1X = FMA(T1R, T1S, T1V * T1W);
+ T1Y = T1O + T1X;
+ T7D = T1O - T1X;
+ {
+ E T2j, T2s, T7J, T7K;
+ T2j = FNMS(T2h, T2i, T2f * T2g);
+ T2s = FMA(T2m, T2n, T2q * T2r);
+ T2t = T2j + T2s;
+ T7O = T2j - T2s;
+ T7J = FMA(T2h, T2g, T2f * T2i);
+ T7K = FNMS(T2q, T2n, T2m * T2r);
+ T7L = T7J - T7K;
+ Te6 = T7J + T7K;
+ }
+ }
+ {
+ E T3H, T3M, T7y, T7z;
+ T3H = FNMS(T3F, T3G, T3D * T3E);
+ T3M = FMA(T3I, T3J, T3K * T3L);
+ T3N = T3H + T3M;
+ T8E = T3H - T3M;
+ T7y = FNMS(Tf, T1M, Ta * T1N);
+ T7z = FNMS(T1V, T1S, T1R * T1W);
+ T7A = T7y - T7z;
+ Te0 = T7y + T7z;
+ }
+ {
+ E T4B, T8R, T4x, T4z;
+ T4x = T3d + T3f;
+ T4z = T3h - T3i;
+ T4B = FNMS(T4z, T4A, T4x * T4y);
+ T8R = FMA(T4z, T4y, T4x * T4A);
+ T4C = T4w + T4B;
+ TeA = T8Q + T8R;
+ T8S = T8Q - T8R;
+ T9v = T4w - T4B;
+ }
+ {
+ E T64, Tap, T5Y, T62;
+ T5Y = T5W - T5X;
+ T62 = T60 + T61;
+ T64 = FMA(T5Y, T5Z, T62 * T63);
+ Tap = FNMS(T62, T5Z, T5Y * T63);
+ T65 = T5V + T64;
+ Tfi = Tao + Tap;
+ T9J = T5V - T64;
+ Taq = Tao - Tap;
+ }
+ {
+ E T6J, Ta1, T6F, T6H;
+ T6F = T2x + T2y;
+ T6H = T2A - T2B;
+ T6J = FNMS(T6H, T6I, T6F * T6G);
+ Ta1 = FMA(T6H, T6G, T6F * T6I);
+ T6K = T6E + T6J;
+ Tf6 = Ta0 + Ta1;
+ Ta2 = Ta0 - Ta1;
+ Ta5 = T6E - T6J;
+ }
+ {
+ E T6Z, Tab, T6V, T6X;
+ T6V = FMA(TN, Ta, TX * Tf);
+ T6X = FNMS(TX, Ta, TN * Tf);
+ T6Z = FNMS(T6X, T6Y, T6V * T6W);
+ Tab = FMA(T6X, T6W, T6V * T6Y);
+ T73 = T6Z + T72;
+ Tfc = Tab + Tac;
+ Tad = Tab - Tac;
+ Tag = T6Z - T72;
+ }
+ T3z = FNMS(T3x, T3y, T3v * T3w);
+ T83 = FMA(T3x, T3w, T3v * T3y);
+ T3q = FNMS(TX, Tm, TN * Th);
+ T3s = FMA(TN, Tm, TX * Th);
+ T3u = FMA(T3q, T3r, T3s * T3t);
+ T82 = FNMS(T3s, T3r, T3q * T3t);
+ T81 = T3u - T3z;
+ T84 = T82 - T83;
+ {
+ E TW, T10, T11, T13;
+ TW = TR + TV;
+ T10 = TY - TZ;
+ T11 = FNMS(TX, T10, TN * TW);
+ T13 = FMA(TN, T10, TX * TW);
+ T15 = FMA(T11, T12, T13 * T14);
+ T9K = FMA(T10, T66, TW * T67);
+ T68 = FNMS(T10, T67, TW * T66);
+ T7j = FNMS(T13, T12, T11 * T14);
+ }
+ {
+ E T3V, T3Y, T3Z, T41;
+ T3V = T3T + T3U;
+ T3Y = T3W - T3X;
+ T3Z = FNMS(TX, T3Y, TN * T3V);
+ T41 = FMA(TN, T3Y, TX * T3V);
+ T43 = FMA(T3Z, T40, T41 * T42);
+ T9w = FMA(T3Y, T4D, T3V * T4E);
+ T4F = FNMS(T3Y, T4E, T3V * T4D);
+ T8G = FNMS(T41, T40, T3Z * T42);
+ }
+ {
+ E T5f, T9i, T5k, T9j, T5g, T5i;
+ T5f = FNMS(Tm, T5e, Th * T5d);
+ T9i = FMA(Tm, T5d, Th * T5e);
+ T5g = T3T - T3U;
+ T5i = T3W + T3X;
+ T5k = FMA(T5g, T5h, T5i * T5j);
+ T9j = FNMS(T5i, T5h, T5g * T5j);
+ T5l = T5f + T5k;
+ TeL = T9i + T9j;
+ T9k = T9i - T9j;
+ T9n = T5f - T5k;
+ }
+ {
+ E T6i, T9O, T6n, T9P, T6j, T6l;
+ T6i = FMA(T1t, T6g, T1u * T6h);
+ T9O = FNMS(T1u, T6g, T1t * T6h);
+ T6j = TR - TV;
+ T6l = TY + TZ;
+ T6n = FMA(T6j, T6k, T6l * T6m);
+ T9P = FNMS(T6l, T6k, T6j * T6m);
+ T6o = T6i + T6n;
+ Tf2 = T9O + T9P;
+ T9Q = T9O - T9P;
+ T9R = T6i - T6n;
+ }
+ {
+ E T6t, T9U, T6y, T9V;
+ {
+ E T6p, T6r, T6u, T6w;
+ T6p = FNMS(TX, T1e, TN * T1a);
+ T6r = FMA(TN, T1e, TX * T1a);
+ T6t = FMA(T6p, T6q, T6r * T6s);
+ T9U = FNMS(T6r, T6q, T6p * T6s);
+ T6u = T5W + T5X;
+ T6w = T60 - T61;
+ T6y = FNMS(T6w, T6x, T6u * T6v);
+ T9V = FMA(T6w, T6v, T6u * T6x);
+ }
+ T6z = T6t + T6y;
+ Tf3 = T9U + T9V;
+ T9T = T6t - T6y;
+ T9W = T9U - T9V;
+ }
+ {
+ E Ti, Tn, T4k, Tq, Tr, T4m, T4Q, T4S;
+ Ti = T2 * Th;
+ Tn = Tj * Tm;
+ T4k = Ti - Tn;
+ Tq = T2 * Tm;
+ Tr = Tj * Th;
+ T4m = Tq + Tr;
+ To = Ti + Tn;
+ Ts = Tq - Tr;
+ T4o = FMA(T4k, T4l, T4m * T4n);
+ T8u = FNMS(T4m, T4l, T4k * T4n);
+ T4Q = FMA(TN, T4k, TX * T4m);
+ T4S = FNMS(TX, T4k, TN * T4m);
+ T4U = FNMS(T4S, T4T, T4Q * T4R);
+ T92 = FMA(T4S, T4R, T4Q * T4T);
+ }
+ {
+ E T50, T8W, T59, T8X;
+ {
+ E T4W, T4Y, T53, T57;
+ T4W = FNMS(TX, T3e, TN * T3c);
+ T4Y = FMA(TN, T3e, TX * T3c);
+ T50 = FMA(T4W, T4X, T4Y * T4Z);
+ T8W = FNMS(T4Y, T4X, T4W * T4Z);
+ T53 = T51 - T52;
+ T57 = T55 + T56;
+ T59 = FMA(T53, T54, T57 * T58);
+ T8X = FNMS(T57, T54, T53 * T58);
+ }
+ T5a = T50 + T59;
+ TeT = T8W + T8X;
+ T8V = T50 - T59;
+ T8Y = T8W - T8X;
+ }
+ {
+ E T5A, T9c, T5F, T9d;
+ {
+ E T5w, T5y, T5B, T5D;
+ T5w = FNMS(TX, Ty, TN * Tw);
+ T5y = FMA(TN, Ty, TX * Tw);
+ T5A = FMA(T5w, T5x, T5y * T5z);
+ T9c = FNMS(T5y, T5x, T5w * T5z);
+ T5B = T51 + T52;
+ T5D = T55 - T56;
+ T5F = FNMS(T5D, T5E, T5B * T5C);
+ T9d = FMA(T5D, T5C, T5B * T5E);
+ }
+ T5G = T5A + T5F;
+ TeG = T9c + T9d;
+ T97 = T5A - T5F;
+ T9e = T9c - T9d;
+ }
+ {
+ E T21, T2P, T25, T2R, T77, T79;
+ {
+ E T1Z, T20, T23, T24;
+ T1Z = T2 * T1t;
+ T20 = Tj * T1u;
+ T21 = T1Z + T20;
+ T2P = T1Z - T20;
+ T23 = T2 * T1u;
+ T24 = Tj * T1t;
+ T25 = T23 - T24;
+ T2R = T23 + T24;
+ }
+ T27 = FNMS(T25, T26, T21 * T22);
+ T7X = FNMS(T2R, T2Q, T2P * T2S);
+ T2T = FMA(T2P, T2Q, T2R * T2S);
+ T7E = FMA(T25, T22, T21 * T26);
+ T77 = FNMS(TX, T25, TN * T21);
+ T79 = FMA(TN, T25, TX * T21);
+ T7b = FMA(T77, T78, T79 * T7a);
+ Tai = FNMS(T79, T78, T77 * T7a);
+ }
+ {
+ E T6S, Ta7, T2D, Ta6, T2F, T6N;
+ {
+ E T6O, T6Q, T2z, T2C;
+ T6O = FMA(TN, TQ, TX * TU);
+ T6Q = FNMS(TX, TQ, TN * TU);
+ T6S = FNMS(T6Q, T6R, T6O * T6P);
+ Ta7 = FMA(T6Q, T6P, T6O * T6R);
+ T2z = T2x - T2y;
+ T2C = T2A + T2B;
+ T2D = FMA(TN, T2z, TX * T2C);
+ Ta6 = FNMS(T2C, T6L, T2z * T6M);
+ T2F = FNMS(TX, T2z, TN * T2C);
+ T6N = FMA(T2z, T6L, T2C * T6M);
+ }
+ T6T = T6N + T6S;
+ Ta3 = T6N - T6S;
+ Tf7 = Ta6 + Ta7;
+ Ta8 = Ta6 - Ta7;
+ T7Q = FMA(T2F, T2E, T2D * T2G);
+ T2H = FNMS(T2F, T2G, T2D * T2E);
+ }
+ {
+ E TA, TE, TB, TF, TJ, TI, T2a, T28, T49, T4b;
+ TA = Tx + Tz;
+ TE = TC - TD;
+ TB = T2 * TA;
+ TF = Tj * TE;
+ TJ = Tj * TA;
+ TI = T2 * TE;
+ T2a = FMA(TN, TE, TX * TA);
+ T28 = FNMS(TX, TE, TN * TA);
+ T2c = FMA(T28, T29, T2a * T2b);
+ T76 = FNMS(TE, T75, TA * T74);
+ Tah = FMA(TE, T74, TA * T75);
+ T7F = FNMS(T2a, T29, T28 * T2b);
+ T49 = TB + TF;
+ T4b = TI - TJ;
+ T4d = FNMS(T4b, T4c, T49 * T4a);
+ T8z = FMA(T4b, T4a, T49 * T4c);
+ TG = TB - TF;
+ TK = TI + TJ;
+ T69 = FMA(TN, TG, TX * TK);
+ T6b = FNMS(TX, TG, TN * TK);
+ }
+ {
+ E T5t, T9p, T3k, T9o, T3m, T5o;
+ T3b = FMA(T37, T38, T39 * T3a);
+ T87 = FNMS(T39, T38, T37 * T3a);
+ {
+ E T5p, T5r, T3g, T3j;
+ T5p = FMA(TN, T37, TX * T39);
+ T5r = FNMS(TX, T37, TN * T39);
+ T5t = FNMS(T5r, T5s, T5p * T5q);
+ T9p = FMA(T5r, T5q, T5p * T5s);
+ T3g = T3d - T3f;
+ T3j = T3h + T3i;
+ T3k = FMA(TN, T3g, TX * T3j);
+ T9o = FNMS(T3j, T5m, T3g * T5n);
+ T3m = FNMS(TX, T3g, TN * T3j);
+ T5o = FMA(T3g, T5m, T3j * T5n);
+ }
+ T5u = T5o + T5t;
+ T9l = T5o - T5t;
+ TeM = T9o + T9p;
+ T9q = T9o - T9p;
+ T88 = FMA(T3m, T3l, T3k * T3n);
+ T89 = T87 - T88;
+ T3o = FNMS(T3m, T3n, T3k * T3l);
+ T86 = T3b - T3o;
+ }
+ {
+ E T5O, T99, T1i, T1n, T1o, T1k, T30, T5J, T98, T32;
+ {
+ E T5K, T5M, T1h, T1j;
+ T5K = FNMS(TX, T2X, TN * T2V);
+ T5M = FMA(TN, T2X, TX * T2V);
+ T5O = FMA(T5K, T5L, T5M * T5N);
+ T99 = FNMS(T5M, T5L, T5K * T5N);
+ T1h = Tb - Tg;
+ T1j = Tk + Tl;
+ T1i = T2 * T1h;
+ T1n = T2 * T1j;
+ T1o = Tj * T1h;
+ T1k = Tj * T1j;
+ T30 = FMA(TN, T1h, TX * T1j);
+ T5J = FMA(T1h, T5H, T1j * T5I);
+ T98 = FNMS(T1j, T5H, T1h * T5I);
+ T32 = FNMS(TX, T1h, TN * T1j);
+ }
+ T5P = T5J + T5O;
+ T9f = T5J - T5O;
+ TeH = T98 + T99;
+ T9a = T98 - T99;
+ T34 = FNMS(T32, T33, T30 * T31);
+ T8f = FMA(T32, T31, T30 * T33);
+ {
+ E T1l, T1p, T3O, T3Q;
+ T1l = T1i - T1k;
+ T1p = T1n + T1o;
+ T1r = FMA(T1l, T1m, T1p * T1q);
+ T7n = FNMS(T1p, T1m, T1l * T1q);
+ T3O = T1i + T1k;
+ T3Q = T1n - T1o;
+ T3S = FNMS(T3Q, T3R, T3O * T3P);
+ T8F = FMA(T3Q, T3P, T3O * T3R);
+ T4G = FNMS(TX, T3Q, TN * T3O);
+ T4I = FMA(TN, T3Q, TX * T3O);
+ }
+ }
+ }
+ Tp = rio[WS(ios, 32)];
+ T6c = iio[-WS(ios, 16)];
+ TH = rio[WS(ios, 16)];
+ T6a = rio[WS(ios, 47)];
+ TL = iio[-WS(ios, 47)];
+ Ti1 = iio[-WS(ios, 63)];
+ T4H = rio[WS(ios, 49)];
+ T4J = iio[-WS(ios, 14)];
+ Tt = iio[-WS(ios, 31)];
+ {
+ E T5R, TgT, TgY, ThE, T9t, Tbe, T9G, Tbb, Tcl, Tdq, Tcs, Tdn, TeP, Tg4, TeY;
+ E Tg1, T7e, Th4, ThJ, Th9, Tfp, Tg8, Tfg, Tgb, T2K, TgC, Tih, ThX, TfQ, TiL;
+ E Tea, Tiv, Tam, Tbl, TcL, Tdu, Taz, Tbi, TcE, Tdx, T7U, Tjv, Tdc, Tjh, Tb0;
+ E TjL, TbU, TiZ, T8D, Tb5, Tc8, Tdi, T8M, Tb6, Tc5, Tdh, T4r, Thz, Tex, Tfz;
+ E TfX, Tgl, TgN, Thj, T8m, TaI, Tdg, TdG, Tb4, Tbu, Tc2, TcU, T3C, Thy, Tem;
+ E Tfy, TfU, Tgk, TgI, Thi, T6B, Th1, Tfm, Tga, Th8, ThI, T9Z, Tbh, Taw, Tbk;
+ E TcI, Tdw, Tf5, Tg7, Tcx, Tdt, T5c, TgV, TeV, Tg0, TgS, ThD, TeE, Tg3, T96;
+ E Tbd, Tce, Tdp, Tcp, Tdm, T9D, Tba, T1L, Tgz, Ti4, Tii, Tiy, TiM, TdZ, TfN;
+ E T7x, TaX, Tj4, Tji, Tjy, TjM, TbN, Td9;
+ {
+ E T5v, T5Q, TgW, TgX;
+ T5v = T5l + T5u;
+ T5Q = T5G + T5P;
+ T5R = T5v + T5Q;
+ TgT = T5Q - T5v;
+ TgW = TeL + TeM;
+ TgX = TeG + TeH;
+ TgY = TgW - TgX;
+ ThE = TgW + TgX;
+ }
+ {
+ E T9h, T9F, T9s, T9E;
+ {
+ E T9b, T9g, T9m, T9r;
+ T9b = T97 - T9a;
+ T9g = T9e + T9f;
+ T9h = FNMS(KP923879532, T9g, KP382683432 * T9b);
+ T9F = FMA(KP382683432, T9g, KP923879532 * T9b);
+ T9m = T9k + T9l;
+ T9r = T9n - T9q;
+ T9s = FMA(KP923879532, T9m, KP382683432 * T9r);
+ T9E = FNMS(KP923879532, T9r, KP382683432 * T9m);
+ }
+ T9t = T9h - T9s;
+ Tbe = T9E + T9F;
+ T9G = T9E - T9F;
+ Tbb = T9s + T9h;
+ }
+ {
+ E Tch, Tcr, Tck, Tcq;
+ {
+ E Tcf, Tcg, Tci, Tcj;
+ Tcf = T97 + T9a;
+ Tcg = T9e - T9f;
+ Tch = FNMS(KP382683432, Tcg, KP923879532 * Tcf);
+ Tcr = FMA(KP923879532, Tcg, KP382683432 * Tcf);
+ Tci = T9k - T9l;
+ Tcj = T9n + T9q;
+ Tck = FMA(KP382683432, Tci, KP923879532 * Tcj);
+ Tcq = FNMS(KP382683432, Tcj, KP923879532 * Tci);
+ }
+ Tcl = Tch - Tck;
+ Tdq = Tcq + Tcr;
+ Tcs = Tcq - Tcr;
+ Tdn = Tck + Tch;
+ }
+ {
+ E TeJ, TeX, TeO, TeW;
+ {
+ E TeF, TeI, TeK, TeN;
+ TeF = T5G - T5P;
+ TeI = TeG - TeH;
+ TeJ = TeF - TeI;
+ TeX = TeF + TeI;
+ TeK = T5l - T5u;
+ TeN = TeL - TeM;
+ TeO = TeK + TeN;
+ TeW = TeN - TeK;
+ }
+ TeP = KP707106781 * (TeJ - TeO);
+ Tg4 = KP707106781 * (TeW + TeX);
+ TeY = KP707106781 * (TeW - TeX);
+ Tg1 = KP707106781 * (TeO + TeJ);
+ }
+ {
+ E T6U, Th2, T7d, Tfb, Tfe, Th3, Tfa, Tfo, Tfn, Tff;
+ T6U = T6K + T6T;
+ Th2 = Tf6 + Tf7;
+ {
+ E T7c, Tfd, Tf8, Tf9;
+ T7c = T76 + T7b;
+ T7d = T73 + T7c;
+ Tfb = T73 - T7c;
+ Tfd = Tah + Tai;
+ Tfe = Tfc - Tfd;
+ Th3 = Tfc + Tfd;
+ Tf8 = Tf6 - Tf7;
+ Tf9 = T6K - T6T;
+ Tfa = Tf8 - Tf9;
+ Tfo = Tf9 + Tf8;
+ }
+ T7e = T6U + T7d;
+ Th4 = Th2 - Th3;
+ ThJ = Th2 + Th3;
+ Th9 = T7d - T6U;
+ Tfn = Tfb - Tfe;
+ Tfp = KP707106781 * (Tfn - Tfo);
+ Tg8 = KP707106781 * (Tfo + Tfn);
+ Tff = Tfb + Tfe;
+ Tfg = KP707106781 * (Tfa - Tff);
+ Tgb = KP707106781 * (Tfa + Tff);
+ }
+ {
+ E T2e, Te3, Te8, TgB, T2J, Te5, Te2, TgA;
+ {
+ E T2d, Te7, T2I, Te1;
+ T2d = T27 + T2c;
+ T2e = T1Y + T2d;
+ Te3 = T1Y - T2d;
+ Te7 = T7P + T7Q;
+ Te8 = Te6 - Te7;
+ TgB = Te6 + Te7;
+ T2I = T2w + T2H;
+ T2J = T2t + T2I;
+ Te5 = T2t - T2I;
+ Te1 = T7E + T7F;
+ Te2 = Te0 - Te1;
+ TgA = Te0 + Te1;
+ }
+ T2K = T2e + T2J;
+ TgC = TgA - TgB;
+ Tih = T2J - T2e;
+ ThX = TgA + TgB;
+ {
+ E TfO, TfP, Te4, Te9;
+ TfO = Te3 + Te2;
+ TfP = Te5 - Te8;
+ TfQ = KP707106781 * (TfO + TfP);
+ TiL = KP707106781 * (TfP - TfO);
+ Te4 = Te2 - Te3;
+ Te9 = Te5 + Te8;
+ Tea = KP707106781 * (Te4 - Te9);
+ Tiv = KP707106781 * (Te4 + Te9);
+ }
+ }
+ {
+ E Taf, TcB, Tak, TcC, Taa, Tay, TcA, TcK, Tae, Taj;
+ Tae = T76 - T7b;
+ Taf = Tad + Tae;
+ TcB = Tad - Tae;
+ Taj = Tah - Tai;
+ Tak = Tag - Taj;
+ TcC = Tag + Taj;
+ {
+ E Ta4, Ta9, Tcy, Tcz;
+ Ta4 = Ta2 + Ta3;
+ Ta9 = Ta5 - Ta8;
+ Taa = FNMS(KP923879532, Ta9, KP382683432 * Ta4);
+ Tay = FMA(KP923879532, Ta4, KP382683432 * Ta9);
+ Tcy = Ta2 - Ta3;
+ Tcz = Ta5 + Ta8;
+ TcA = FNMS(KP382683432, Tcz, KP923879532 * Tcy);
+ TcK = FMA(KP382683432, Tcy, KP923879532 * Tcz);
+ }
+ {
+ E Tal, TcJ, Tax, TcD;
+ Tal = FMA(KP382683432, Taf, KP923879532 * Tak);
+ Tam = Taa - Tal;
+ Tbl = Taa + Tal;
+ TcJ = FNMS(KP382683432, TcB, KP923879532 * TcC);
+ TcL = TcJ - TcK;
+ Tdu = TcK + TcJ;
+ Tax = FNMS(KP923879532, Taf, KP382683432 * Tak);
+ Taz = Tax - Tay;
+ Tbi = Tay + Tax;
+ TcD = FMA(KP923879532, TcB, KP382683432 * TcC);
+ TcE = TcA - TcD;
+ Tdx = TcA + TcD;
+ }
+ }
+ {
+ E T7C, TbO, T7S, TbS, T7H, TbP, T7N, TbR;
+ {
+ E T7B, T7R, T7G, T7M;
+ T7B = T27 - T2c;
+ T7C = T7A + T7B;
+ TbO = T7A - T7B;
+ T7R = T7P - T7Q;
+ T7S = T7O - T7R;
+ TbS = T7O + T7R;
+ T7G = T7E - T7F;
+ T7H = T7D - T7G;
+ TbP = T7D + T7G;
+ T7M = T2w - T2H;
+ T7N = T7L + T7M;
+ TbR = T7L - T7M;
+ }
+ {
+ E T7I, T7T, Tda, Tdb;
+ T7I = FNMS(KP923879532, T7H, KP382683432 * T7C);
+ T7T = FMA(KP382683432, T7N, KP923879532 * T7S);
+ T7U = T7I - T7T;
+ Tjv = T7I + T7T;
+ Tda = FMA(KP382683432, TbO, KP923879532 * TbP);
+ Tdb = FNMS(KP382683432, TbR, KP923879532 * TbS);
+ Tdc = Tda + Tdb;
+ Tjh = Tdb - Tda;
+ }
+ {
+ E TaY, TaZ, TbQ, TbT;
+ TaY = FMA(KP923879532, T7C, KP382683432 * T7H);
+ TaZ = FNMS(KP923879532, T7N, KP382683432 * T7S);
+ Tb0 = TaY + TaZ;
+ TjL = TaZ - TaY;
+ TbQ = FNMS(KP382683432, TbP, KP923879532 * TbO);
+ TbT = FMA(KP923879532, TbR, KP382683432 * TbS);
+ TbU = TbQ - TbT;
+ TiZ = TbQ + TbT;
+ }
+ }
+ {
+ E T8r, Tc6, T8I, Tc3, T8w, T8K, T8B, T8J, T8q, T8H;
+ T8q = T3S - T43;
+ T8r = T8p + T8q;
+ Tc6 = T8p - T8q;
+ T8H = T8F - T8G;
+ T8I = T8E - T8H;
+ Tc3 = T8E + T8H;
+ {
+ E T8s, T8v, T8x, T8A;
+ T8s = T4j - T4o;
+ T8v = T8t - T8u;
+ T8w = T8s - T8v;
+ T8K = T8s + T8v;
+ T8x = T48 - T4d;
+ T8A = T8y - T8z;
+ T8B = T8x + T8A;
+ T8J = T8A - T8x;
+ }
+ {
+ E T8C, Tc7, T8L, Tc4;
+ T8C = KP707106781 * (T8w - T8B);
+ T8D = T8r - T8C;
+ Tb5 = T8r + T8C;
+ Tc7 = KP707106781 * (T8J + T8K);
+ Tc8 = Tc6 - Tc7;
+ Tdi = Tc6 + Tc7;
+ T8L = KP707106781 * (T8J - T8K);
+ T8M = T8I - T8L;
+ Tb6 = T8I + T8L;
+ Tc4 = KP707106781 * (T8B + T8w);
+ Tc5 = Tc3 - Tc4;
+ Tdh = Tc3 + Tc4;
+ }
+ }
+ {
+ E T45, Tes, Tep, TgK, T4q, Teq, Tev, TgL, T44, Teo, Ter, Tew;
+ T44 = T3S + T43;
+ T45 = T3N + T44;
+ Tes = T3N - T44;
+ Teo = T8F + T8G;
+ Tep = Ten - Teo;
+ TgK = Ten + Teo;
+ {
+ E T4e, T4p, Tet, Teu;
+ T4e = T48 + T4d;
+ T4p = T4j + T4o;
+ T4q = T4e + T4p;
+ Teq = T4p - T4e;
+ Tet = T8y + T8z;
+ Teu = T8t + T8u;
+ Tev = Tet - Teu;
+ TgL = Tet + Teu;
+ }
+ T4r = T45 + T4q;
+ Thz = TgK + TgL;
+ Ter = Tep - Teq;
+ Tew = Tes - Tev;
+ Tex = FMA(KP382683432, Ter, KP923879532 * Tew);
+ Tfz = FNMS(KP923879532, Ter, KP382683432 * Tew);
+ {
+ E TfV, TfW, TgJ, TgM;
+ TfV = Tep + Teq;
+ TfW = Tes + Tev;
+ TfX = FMA(KP923879532, TfV, KP382683432 * TfW);
+ Tgl = FNMS(KP382683432, TfV, KP923879532 * TfW);
+ TgJ = T45 - T4q;
+ TgM = TgK - TgL;
+ TgN = TgJ + TgM;
+ Thj = TgJ - TgM;
+ }
+ }
+ {
+ E T80, TbW, T8k, TbX, T8b, Tc0, T8h, TbZ;
+ {
+ E T7Y, T7Z, T8i, T8j;
+ T7Y = T7W - T7X;
+ T7Z = T2Z - T34;
+ T80 = T7Y + T7Z;
+ TbW = T7Y - T7Z;
+ T8i = T89 - T86;
+ T8j = T81 + T84;
+ T8k = KP707106781 * (T8i - T8j);
+ TbX = KP707106781 * (T8i + T8j);
+ }
+ {
+ E T85, T8a, T8d, T8g;
+ T85 = T81 - T84;
+ T8a = T86 + T89;
+ T8b = KP707106781 * (T85 - T8a);
+ Tc0 = KP707106781 * (T8a + T85);
+ T8d = T2O - T2T;
+ T8g = T8e - T8f;
+ T8h = T8d - T8g;
+ TbZ = T8d + T8g;
+ }
+ {
+ E T8c, T8l, Tde, Tdf;
+ T8c = T80 - T8b;
+ T8l = T8h - T8k;
+ T8m = FNMS(KP980785280, T8l, KP195090322 * T8c);
+ TaI = FMA(KP980785280, T8c, KP195090322 * T8l);
+ Tde = TbW + TbX;
+ Tdf = TbZ + Tc0;
+ Tdg = FNMS(KP195090322, Tdf, KP980785280 * Tde);
+ TdG = FMA(KP980785280, Tdf, KP195090322 * Tde);
+ }
+ {
+ E Tb2, Tb3, TbY, Tc1;
+ Tb2 = T80 + T8b;
+ Tb3 = T8h + T8k;
+ Tb4 = FNMS(KP555570233, Tb3, KP831469612 * Tb2);
+ Tbu = FMA(KP555570233, Tb2, KP831469612 * Tb3);
+ TbY = TbW - TbX;
+ Tc1 = TbZ - Tc0;
+ Tc2 = FNMS(KP831469612, Tc1, KP555570233 * TbY);
+ TcU = FMA(KP555570233, Tc1, KP831469612 * TbY);
+ }
+ }
+ {
+ E T36, Teh, Tek, TgF, T3B, Tef, Tee, TgE, Teg, Tel;
+ {
+ E T2U, T35, Tei, Tej;
+ T2U = T2O + T2T;
+ T35 = T2Z + T34;
+ T36 = T2U + T35;
+ Teh = T2U - T35;
+ Tei = T87 + T88;
+ Tej = T82 + T83;
+ Tek = Tei - Tej;
+ TgF = Tei + Tej;
+ }
+ {
+ E T3p, T3A, Tec, Ted;
+ T3p = T3b + T3o;
+ T3A = T3u + T3z;
+ T3B = T3p + T3A;
+ Tef = T3A - T3p;
+ Tec = T7W + T7X;
+ Ted = T8e + T8f;
+ Tee = Tec - Ted;
+ TgE = Tec + Ted;
+ }
+ T3C = T36 + T3B;
+ Thy = TgE + TgF;
+ Teg = Tee - Tef;
+ Tel = Teh - Tek;
+ Tem = FNMS(KP923879532, Tel, KP382683432 * Teg);
+ Tfy = FMA(KP923879532, Teg, KP382683432 * Tel);
+ {
+ E TfS, TfT, TgG, TgH;
+ TfS = Tee + Tef;
+ TfT = Teh + Tek;
+ TfU = FNMS(KP382683432, TfT, KP923879532 * TfS);
+ Tgk = FMA(KP382683432, TfS, KP923879532 * TfT);
+ TgG = TgE - TgF;
+ TgH = T36 - T3B;
+ TgI = TgG - TgH;
+ Thi = TgH + TgG;
+ }
+ }
+ {
+ E T6A, Tfl, Th7, Tf4, T6e, Tar, T9Y, TcH, Tav, Tcw, T9M, Tfj;
+ T6A = T6o + T6z;
+ Tfl = T6z - T6o;
+ Th7 = Tf2 + Tf3;
+ Tf4 = Tf2 - Tf3;
+ {
+ E T6d, T9S, T9X, Tat, Tau, T9L;
+ T6d = FNMS(T6b, T6c, T69 * T6a);
+ T6e = T68 + T6d;
+ Tar = T68 - T6d;
+ T9S = T9Q - T9R;
+ T9X = T9T + T9W;
+ T9Y = KP707106781 * (T9S - T9X);
+ TcH = KP707106781 * (T9S + T9X);
+ Tat = T9T - T9W;
+ Tau = T9R + T9Q;
+ Tav = KP707106781 * (Tat - Tau);
+ Tcw = KP707106781 * (Tau + Tat);
+ T9L = FMA(T6b, T6a, T69 * T6c);
+ T9M = T9K - T9L;
+ Tfj = T9K + T9L;
+ }
+ {
+ E T6f, Tfk, Th6, T9N;
+ T6f = T65 + T6e;
+ T6B = T6f + T6A;
+ Th1 = T6f - T6A;
+ Tfk = Tfi - Tfj;
+ Tfm = Tfk - Tfl;
+ Tga = Tfk + Tfl;
+ Th6 = Tfi + Tfj;
+ Th8 = Th6 - Th7;
+ ThI = Th6 + Th7;
+ T9N = T9J - T9M;
+ T9Z = T9N - T9Y;
+ Tbh = T9N + T9Y;
+ }
+ {
+ E Tas, TcG, Tf1, Tcv;
+ Tas = Taq + Tar;
+ Taw = Tas - Tav;
+ Tbk = Tas + Tav;
+ TcG = Taq - Tar;
+ TcI = TcG - TcH;
+ Tdw = TcG + TcH;
+ Tf1 = T65 - T6e;
+ Tf5 = Tf1 - Tf4;
+ Tg7 = Tf1 + Tf4;
+ Tcv = T9J + T9M;
+ Tcx = Tcv - Tcw;
+ Tdt = Tcv + Tcw;
+ }
+ }
+ {
+ E T8Z, T9B, T5b, TeD, TeU, TgR, T94, T9A, T4L, T8T, T9y, TeB, T4V;
+ T8Z = T8V - T8Y;
+ T9B = T8V + T8Y;
+ T4V = T4P + T4U;
+ T5b = T4V + T5a;
+ TeD = T5a - T4V;
+ {
+ E TeS, T90, T93, T4K, T9x;
+ TeS = T91 + T92;
+ TeU = TeS - TeT;
+ TgR = TeS + TeT;
+ T90 = T4P - T4U;
+ T93 = T91 - T92;
+ T94 = T90 + T93;
+ T9A = T93 - T90;
+ T4K = FMA(T4G, T4H, T4I * T4J);
+ T4L = T4F + T4K;
+ T8T = T4F - T4K;
+ T9x = FNMS(T4I, T4H, T4G * T4J);
+ T9y = T9w - T9x;
+ TeB = T9w + T9x;
+ }
+ {
+ E T4M, TeR, TgQ, TeC;
+ T4M = T4C + T4L;
+ T5c = T4M + T5b;
+ TgV = T4M - T5b;
+ TeR = T4C - T4L;
+ TeV = TeR - TeU;
+ Tg0 = TeR + TeU;
+ TgQ = TeA + TeB;
+ TgS = TgQ - TgR;
+ ThD = TgQ + TgR;
+ TeC = TeA - TeB;
+ TeE = TeC - TeD;
+ Tg3 = TeC + TeD;
+ }
+ {
+ E T8U, T95, Tcc, Tcd;
+ T8U = T8S + T8T;
+ T95 = KP707106781 * (T8Z - T94);
+ T96 = T8U - T95;
+ Tbd = T8U + T95;
+ Tcc = T8S - T8T;
+ Tcd = KP707106781 * (T9A + T9B);
+ Tce = Tcc - Tcd;
+ Tdp = Tcc + Tcd;
+ }
+ {
+ E Tcn, Tco, T9z, T9C;
+ Tcn = T9v + T9y;
+ Tco = KP707106781 * (T94 + T8Z);
+ Tcp = Tcn - Tco;
+ Tdm = Tcn + Tco;
+ T9z = T9v - T9y;
+ T9C = KP707106781 * (T9A - T9B);
+ T9D = T9z - T9C;
+ Tba = T9z + T9C;
+ }
+ }
+ {
+ E Tv, T7h, TdY, ThY, Ti2, Tj1, T16, Tj2, T1K, Tiw, T7q, TbK, T7v, TbL, T7k;
+ E ThZ, T7r, T7u, T7i;
+ {
+ E Tu, TdW, TdX, Ti0, TM;
+ Tu = FNMS(Ts, Tt, To * Tp);
+ Tv = T1 + Tu;
+ T7h = T1 - Tu;
+ TdW = T7m + T7n;
+ TdX = T7s + T7t;
+ TdY = TdW - TdX;
+ ThY = TdW + TdX;
+ Ti0 = FMA(Ts, Tp, To * Tt);
+ Ti2 = Ti0 + Ti1;
+ Tj1 = Ti1 - Ti0;
+ TM = FMA(TG, TH, TK * TL);
+ T16 = TM + T15;
+ Tj2 = TM - T15;
+ }
+ {
+ E T1s, T1J, T7o, T7p;
+ T1s = T1g + T1r;
+ T1J = T1z + T1I;
+ T1K = T1s + T1J;
+ Tiw = T1J - T1s;
+ T7o = T7m - T7n;
+ T7p = T1g - T1r;
+ T7q = T7o - T7p;
+ TbK = T7p + T7o;
+ }
+ T7r = T1z - T1I;
+ T7u = T7s - T7t;
+ T7v = T7r + T7u;
+ TbL = T7r - T7u;
+ T7i = FNMS(TK, TH, TG * TL);
+ T7k = T7i - T7j;
+ ThZ = T7i + T7j;
+ {
+ E T17, Ti3, Tix, TdV;
+ T17 = Tv + T16;
+ T1L = T17 + T1K;
+ Tgz = T17 - T1K;
+ Ti3 = ThZ + Ti2;
+ Ti4 = ThY + Ti3;
+ Tii = Ti3 - ThY;
+ Tix = Ti2 - ThZ;
+ Tiy = Tiw + Tix;
+ TiM = Tix - Tiw;
+ TdV = Tv - T16;
+ TdZ = TdV - TdY;
+ TfN = TdV + TdY;
+ }
+ {
+ E T7l, T7w, Tj0, Tj3;
+ T7l = T7h - T7k;
+ T7w = KP707106781 * (T7q - T7v);
+ T7x = T7l - T7w;
+ TaX = T7l + T7w;
+ Tj0 = KP707106781 * (T7q + T7v);
+ Tj3 = Tj1 - Tj2;
+ Tj4 = Tj0 + Tj3;
+ Tji = Tj3 - Tj0;
+ }
+ {
+ E Tjw, Tjx, TbJ, TbM;
+ Tjw = KP707106781 * (TbL - TbK);
+ Tjx = Tj2 + Tj1;
+ Tjy = Tjw + Tjx;
+ TjM = Tjx - Tjw;
+ TbJ = T7h + T7k;
+ TbM = KP707106781 * (TbK + TbL);
+ TbN = TbJ - TbM;
+ Td9 = TbJ + TbM;
+ }
+ }
+ {
+ E T4t, ThR, Ti6, Ti8, T7g, Ti7, ThU, ThV;
+ {
+ E T2L, T4s, ThW, Ti5;
+ T2L = T1L + T2K;
+ T4s = T3C + T4r;
+ T4t = T2L + T4s;
+ ThR = T2L - T4s;
+ ThW = Thy + Thz;
+ Ti5 = ThX + Ti4;
+ Ti6 = ThW + Ti5;
+ Ti8 = Ti5 - ThW;
+ }
+ {
+ E T5S, T7f, ThS, ThT;
+ T5S = T5c + T5R;
+ T7f = T6B + T7e;
+ T7g = T5S + T7f;
+ Ti7 = T7f - T5S;
+ ThS = ThD + ThE;
+ ThT = ThI + ThJ;
+ ThU = ThS - ThT;
+ ThV = ThS + ThT;
+ }
+ iio[-WS(ios, 32)] = T4t - T7g;
+ rio[WS(ios, 32)] = ThV - Ti6;
+ rio[0] = T4t + T7g;
+ iio[0] = ThV + Ti6;
+ iio[-WS(ios, 48)] = ThR - ThU;
+ rio[WS(ios, 48)] = Ti7 - Ti8;
+ rio[WS(ios, 16)] = ThR + ThU;
+ iio[-WS(ios, 16)] = Ti7 + Ti8;
+ }
+ {
+ E ThB, ThN, Tic, Tie, ThG, ThO, ThL, ThP;
+ {
+ E Thx, ThA, Tia, Tib;
+ Thx = T1L - T2K;
+ ThA = Thy - Thz;
+ ThB = Thx + ThA;
+ ThN = Thx - ThA;
+ Tia = T4r - T3C;
+ Tib = Ti4 - ThX;
+ Tic = Tia + Tib;
+ Tie = Tib - Tia;
+ }
+ {
+ E ThC, ThF, ThH, ThK;
+ ThC = T5c - T5R;
+ ThF = ThD - ThE;
+ ThG = ThC + ThF;
+ ThO = ThF - ThC;
+ ThH = T6B - T7e;
+ ThK = ThI - ThJ;
+ ThL = ThH - ThK;
+ ThP = ThH + ThK;
+ }
+ {
+ E ThM, Ti9, ThQ, Tid;
+ ThM = KP707106781 * (ThG + ThL);
+ iio[-WS(ios, 40)] = ThB - ThM;
+ rio[WS(ios, 8)] = ThB + ThM;
+ Ti9 = KP707106781 * (ThO + ThP);
+ rio[WS(ios, 40)] = Ti9 - Tic;
+ iio[-WS(ios, 8)] = Ti9 + Tic;
+ ThQ = KP707106781 * (ThO - ThP);
+ iio[-WS(ios, 56)] = ThN - ThQ;
+ rio[WS(ios, 24)] = ThN + ThQ;
+ Tid = KP707106781 * (ThL - ThG);
+ rio[WS(ios, 56)] = Tid - Tie;
+ iio[-WS(ios, 24)] = Tid + Tie;
+ }
+ }
+ {
+ E TgP, Thd, Tiq, Tis, Th0, The, Thb, Thf;
+ {
+ E TgD, TgO, Tio, Tip;
+ TgD = Tgz - TgC;
+ TgO = KP707106781 * (TgI - TgN);
+ TgP = TgD + TgO;
+ Thd = TgD - TgO;
+ Tio = KP707106781 * (Thj - Thi);
+ Tip = Tii - Tih;
+ Tiq = Tio + Tip;
+ Tis = Tip - Tio;
+ }
+ {
+ E TgU, TgZ, Th5, Tha;
+ TgU = TgS - TgT;
+ TgZ = TgV - TgY;
+ Th0 = FMA(KP923879532, TgU, KP382683432 * TgZ);
+ The = FNMS(KP923879532, TgZ, KP382683432 * TgU);
+ Th5 = Th1 - Th4;
+ Tha = Th8 - Th9;
+ Thb = FNMS(KP923879532, Tha, KP382683432 * Th5);
+ Thf = FMA(KP382683432, Tha, KP923879532 * Th5);
+ }
+ {
+ E Thc, Tin, Thg, Tir;
+ Thc = Th0 + Thb;
+ iio[-WS(ios, 44)] = TgP - Thc;
+ rio[WS(ios, 12)] = TgP + Thc;
+ Tin = The + Thf;
+ rio[WS(ios, 44)] = Tin - Tiq;
+ iio[-WS(ios, 12)] = Tin + Tiq;
+ Thg = The - Thf;
+ iio[-WS(ios, 60)] = Thd - Thg;
+ rio[WS(ios, 28)] = Thd + Thg;
+ Tir = Thb - Th0;
+ rio[WS(ios, 60)] = Tir - Tis;
+ iio[-WS(ios, 28)] = Tir + Tis;
+ }
+ }
+ {
+ E TfB, TfJ, TiO, TiQ, TfE, TfK, TfH, TfL;
+ {
+ E Tfx, TfA, TiK, TiN;
+ Tfx = TdZ + Tea;
+ TfA = Tfy + Tfz;
+ TfB = Tfx + TfA;
+ TfJ = Tfx - TfA;
+ TiK = Tem + Tex;
+ TiN = TiL + TiM;
+ TiO = TiK + TiN;
+ TiQ = TiN - TiK;
+ }
+ {
+ E TfC, TfD, TfF, TfG;
+ TfC = TeE + TeP;
+ TfD = TeV + TeY;
+ TfE = FMA(KP555570233, TfC, KP831469612 * TfD);
+ TfK = FNMS(KP555570233, TfD, KP831469612 * TfC);
+ TfF = Tf5 + Tfg;
+ TfG = Tfm + Tfp;
+ TfH = FNMS(KP555570233, TfG, KP831469612 * TfF);
+ TfL = FMA(KP831469612, TfG, KP555570233 * TfF);
+ }
+ {
+ E TfI, TiJ, TfM, TiP;
+ TfI = TfE + TfH;
+ iio[-WS(ios, 38)] = TfB - TfI;
+ rio[WS(ios, 6)] = TfB + TfI;
+ TiJ = TfK + TfL;
+ rio[WS(ios, 38)] = TiJ - TiO;
+ iio[-WS(ios, 6)] = TiJ + TiO;
+ TfM = TfK - TfL;
+ iio[-WS(ios, 54)] = TfJ - TfM;
+ rio[WS(ios, 22)] = TfJ + TfM;
+ TiP = TfH - TfE;
+ rio[WS(ios, 54)] = TiP - TiQ;
+ iio[-WS(ios, 22)] = TiP + TiQ;
+ }
+ }
+ {
+ E Thl, Tht, Tik, Tim, Tho, Thu, Thr, Thv;
+ {
+ E Thh, Thk, Tig, Tij;
+ Thh = Tgz + TgC;
+ Thk = KP707106781 * (Thi + Thj);
+ Thl = Thh + Thk;
+ Tht = Thh - Thk;
+ Tig = KP707106781 * (TgI + TgN);
+ Tij = Tih + Tii;
+ Tik = Tig + Tij;
+ Tim = Tij - Tig;
+ }
+ {
+ E Thm, Thn, Thp, Thq;
+ Thm = TgS + TgT;
+ Thn = TgV + TgY;
+ Tho = FMA(KP382683432, Thm, KP923879532 * Thn);
+ Thu = FNMS(KP382683432, Thn, KP923879532 * Thm);
+ Thp = Th1 + Th4;
+ Thq = Th8 + Th9;
+ Thr = FNMS(KP382683432, Thq, KP923879532 * Thp);
+ Thv = FMA(KP923879532, Thq, KP382683432 * Thp);
+ }
+ {
+ E Ths, Tif, Thw, Til;
+ Ths = Tho + Thr;
+ iio[-WS(ios, 36)] = Thl - Ths;
+ rio[WS(ios, 4)] = Thl + Ths;
+ Tif = Thu + Thv;
+ rio[WS(ios, 36)] = Tif - Tik;
+ iio[-WS(ios, 4)] = Tif + Tik;
+ Thw = Thu - Thv;
+ iio[-WS(ios, 52)] = Tht - Thw;
+ rio[WS(ios, 20)] = Tht + Thw;
+ Til = Thr - Tho;
+ rio[WS(ios, 52)] = Til - Tim;
+ iio[-WS(ios, 20)] = Til + Tim;
+ }
+ }
+ {
+ E Tez, Tft, TiU, TiW, Tf0, Tfu, Tfr, Tfv;
+ {
+ E Teb, Tey, TiS, TiT;
+ Teb = TdZ - Tea;
+ Tey = Tem - Tex;
+ Tez = Teb + Tey;
+ Tft = Teb - Tey;
+ TiS = Tfz - Tfy;
+ TiT = TiM - TiL;
+ TiU = TiS + TiT;
+ TiW = TiT - TiS;
+ }
+ {
+ E TeQ, TeZ, Tfh, Tfq;
+ TeQ = TeE - TeP;
+ TeZ = TeV - TeY;
+ Tf0 = FMA(KP980785280, TeQ, KP195090322 * TeZ);
+ Tfu = FNMS(KP980785280, TeZ, KP195090322 * TeQ);
+ Tfh = Tf5 - Tfg;
+ Tfq = Tfm - Tfp;
+ Tfr = FNMS(KP980785280, Tfq, KP195090322 * Tfh);
+ Tfv = FMA(KP195090322, Tfq, KP980785280 * Tfh);
+ }
+ {
+ E Tfs, TiR, Tfw, TiV;
+ Tfs = Tf0 + Tfr;
+ iio[-WS(ios, 46)] = Tez - Tfs;
+ rio[WS(ios, 14)] = Tez + Tfs;
+ TiR = Tfu + Tfv;
+ rio[WS(ios, 46)] = TiR - TiU;
+ iio[-WS(ios, 14)] = TiR + TiU;
+ Tfw = Tfu - Tfv;
+ iio[-WS(ios, 62)] = Tft - Tfw;
+ rio[WS(ios, 30)] = Tft + Tfw;
+ TiV = Tfr - Tf0;
+ rio[WS(ios, 62)] = TiV - TiW;
+ iio[-WS(ios, 30)] = TiV + TiW;
+ }
+ }
+ {
+ E TfZ, Tgf, TiG, TiI, Tg6, Tgg, Tgd, Tgh;
+ {
+ E TfR, TfY, TiE, TiF;
+ TfR = TfN - TfQ;
+ TfY = TfU - TfX;
+ TfZ = TfR + TfY;
+ Tgf = TfR - TfY;
+ TiE = Tgl - Tgk;
+ TiF = Tiy - Tiv;
+ TiG = TiE + TiF;
+ TiI = TiF - TiE;
+ }
+ {
+ E Tg2, Tg5, Tg9, Tgc;
+ Tg2 = Tg0 - Tg1;
+ Tg5 = Tg3 - Tg4;
+ Tg6 = FMA(KP555570233, Tg2, KP831469612 * Tg5);
+ Tgg = FNMS(KP831469612, Tg2, KP555570233 * Tg5);
+ Tg9 = Tg7 - Tg8;
+ Tgc = Tga - Tgb;
+ Tgd = FNMS(KP831469612, Tgc, KP555570233 * Tg9);
+ Tgh = FMA(KP831469612, Tg9, KP555570233 * Tgc);
+ }
+ {
+ E Tge, TiD, Tgi, TiH;
+ Tge = Tg6 + Tgd;
+ iio[-WS(ios, 42)] = TfZ - Tge;
+ rio[WS(ios, 10)] = TfZ + Tge;
+ TiD = Tgg + Tgh;
+ rio[WS(ios, 42)] = TiD - TiG;
+ iio[-WS(ios, 10)] = TiD + TiG;
+ Tgi = Tgg - Tgh;
+ iio[-WS(ios, 58)] = Tgf - Tgi;
+ rio[WS(ios, 26)] = Tgf + Tgi;
+ TiH = Tgd - Tg6;
+ rio[WS(ios, 58)] = TiH - TiI;
+ iio[-WS(ios, 26)] = TiH + TiI;
+ }
+ }
+ {
+ E Tgn, Tgv, TiA, TiC, Tgq, Tgw, Tgt, Tgx;
+ {
+ E Tgj, Tgm, Tiu, Tiz;
+ Tgj = TfN + TfQ;
+ Tgm = Tgk + Tgl;
+ Tgn = Tgj + Tgm;
+ Tgv = Tgj - Tgm;
+ Tiu = TfU + TfX;
+ Tiz = Tiv + Tiy;
+ TiA = Tiu + Tiz;
+ TiC = Tiz - Tiu;
+ }
+ {
+ E Tgo, Tgp, Tgr, Tgs;
+ Tgo = Tg0 + Tg1;
+ Tgp = Tg3 + Tg4;
+ Tgq = FMA(KP980785280, Tgo, KP195090322 * Tgp);
+ Tgw = FNMS(KP195090322, Tgo, KP980785280 * Tgp);
+ Tgr = Tg7 + Tg8;
+ Tgs = Tga + Tgb;
+ Tgt = FNMS(KP195090322, Tgs, KP980785280 * Tgr);
+ Tgx = FMA(KP195090322, Tgr, KP980785280 * Tgs);
+ }
+ {
+ E Tgu, Tit, Tgy, TiB;
+ Tgu = Tgq + Tgt;
+ iio[-WS(ios, 34)] = Tgn - Tgu;
+ rio[WS(ios, 2)] = Tgn + Tgu;
+ Tit = Tgw + Tgx;
+ rio[WS(ios, 34)] = Tit - TiA;
+ iio[-WS(ios, 2)] = Tit + TiA;
+ Tgy = Tgw - Tgx;
+ iio[-WS(ios, 50)] = Tgv - Tgy;
+ rio[WS(ios, 18)] = Tgv + Tgy;
+ TiB = Tgt - Tgq;
+ rio[WS(ios, 50)] = TiB - TiC;
+ iio[-WS(ios, 18)] = TiB + TiC;
+ }
+ }
+ {
+ E T7V, TjN, TjT, TaH, T8O, TjK, TaK, TjS, TaO, TaU, T9I, TaE, TaR, TaV, TaB;
+ E TaF, T8N;
+ T7V = T7x - T7U;
+ TjN = TjL + TjM;
+ TjT = TjM - TjL;
+ TaH = T7x + T7U;
+ T8N = FMA(KP195090322, T8D, KP980785280 * T8M);
+ T8O = T8m - T8N;
+ TjK = T8m + T8N;
+ {
+ E TaJ, TaM, TaN, T9u, T9H;
+ TaJ = FNMS(KP980785280, T8D, KP195090322 * T8M);
+ TaK = TaI + TaJ;
+ TjS = TaJ - TaI;
+ TaM = T96 + T9t;
+ TaN = T9D + T9G;
+ TaO = FMA(KP634393284, TaM, KP773010453 * TaN);
+ TaU = FNMS(KP634393284, TaN, KP773010453 * TaM);
+ T9u = T96 - T9t;
+ T9H = T9D - T9G;
+ T9I = FMA(KP995184726, T9u, KP098017140 * T9H);
+ TaE = FNMS(KP995184726, T9H, KP098017140 * T9u);
+ {
+ E TaP, TaQ, Tan, TaA;
+ TaP = T9Z + Tam;
+ TaQ = Taw + Taz;
+ TaR = FNMS(KP634393284, TaQ, KP773010453 * TaP);
+ TaV = FMA(KP773010453, TaQ, KP634393284 * TaP);
+ Tan = T9Z - Tam;
+ TaA = Taw - Taz;
+ TaB = FNMS(KP995184726, TaA, KP098017140 * Tan);
+ TaF = FMA(KP098017140, TaA, KP995184726 * Tan);
+ }
+ }
+ {
+ E T8P, TaC, TjR, TjU;
+ T8P = T7V + T8O;
+ TaC = T9I + TaB;
+ iio[-WS(ios, 47)] = T8P - TaC;
+ rio[WS(ios, 15)] = T8P + TaC;
+ TjR = TaE + TaF;
+ TjU = TjS + TjT;
+ rio[WS(ios, 47)] = TjR - TjU;
+ iio[-WS(ios, 15)] = TjR + TjU;
+ }
+ {
+ E TaD, TaG, TjV, TjW;
+ TaD = T7V - T8O;
+ TaG = TaE - TaF;
+ iio[-WS(ios, 63)] = TaD - TaG;
+ rio[WS(ios, 31)] = TaD + TaG;
+ TjV = TaB - T9I;
+ TjW = TjT - TjS;
+ rio[WS(ios, 63)] = TjV - TjW;
+ iio[-WS(ios, 31)] = TjV + TjW;
+ }
+ {
+ E TaL, TaS, TjJ, TjO;
+ TaL = TaH + TaK;
+ TaS = TaO + TaR;
+ iio[-WS(ios, 39)] = TaL - TaS;
+ rio[WS(ios, 7)] = TaL + TaS;
+ TjJ = TaU + TaV;
+ TjO = TjK + TjN;
+ rio[WS(ios, 39)] = TjJ - TjO;
+ iio[-WS(ios, 7)] = TjJ + TjO;
+ }
+ {
+ E TaT, TaW, TjP, TjQ;
+ TaT = TaH - TaK;
+ TaW = TaU - TaV;
+ iio[-WS(ios, 55)] = TaT - TaW;
+ rio[WS(ios, 23)] = TaT + TaW;
+ TjP = TaR - TaO;
+ TjQ = TjN - TjK;
+ rio[WS(ios, 55)] = TjP - TjQ;
+ iio[-WS(ios, 23)] = TjP + TjQ;
+ }
+ }
+ {
+ E TbV, Tjj, Tjp, TcT, Tca, Tjg, TcW, Tjo, Td0, Td6, Tcu, TcQ, Td3, Td7, TcN;
+ E TcR, Tc9;
+ TbV = TbN - TbU;
+ Tjj = Tjh + Tji;
+ Tjp = Tji - Tjh;
+ TcT = TbN + TbU;
+ Tc9 = FMA(KP831469612, Tc5, KP555570233 * Tc8);
+ Tca = Tc2 - Tc9;
+ Tjg = Tc2 + Tc9;
+ {
+ E TcV, TcY, TcZ, Tcm, Tct;
+ TcV = FNMS(KP831469612, Tc8, KP555570233 * Tc5);
+ TcW = TcU + TcV;
+ Tjo = TcV - TcU;
+ TcY = Tce + Tcl;
+ TcZ = Tcp + Tcs;
+ Td0 = FMA(KP471396736, TcY, KP881921264 * TcZ);
+ Td6 = FNMS(KP471396736, TcZ, KP881921264 * TcY);
+ Tcm = Tce - Tcl;
+ Tct = Tcp - Tcs;
+ Tcu = FMA(KP956940335, Tcm, KP290284677 * Tct);
+ TcQ = FNMS(KP956940335, Tct, KP290284677 * Tcm);
+ {
+ E Td1, Td2, TcF, TcM;
+ Td1 = Tcx + TcE;
+ Td2 = TcI + TcL;
+ Td3 = FNMS(KP471396736, Td2, KP881921264 * Td1);
+ Td7 = FMA(KP881921264, Td2, KP471396736 * Td1);
+ TcF = Tcx - TcE;
+ TcM = TcI - TcL;
+ TcN = FNMS(KP956940335, TcM, KP290284677 * TcF);
+ TcR = FMA(KP290284677, TcM, KP956940335 * TcF);
+ }
+ }
+ {
+ E Tcb, TcO, Tjn, Tjq;
+ Tcb = TbV + Tca;
+ TcO = Tcu + TcN;
+ iio[-WS(ios, 45)] = Tcb - TcO;
+ rio[WS(ios, 13)] = Tcb + TcO;
+ Tjn = TcQ + TcR;
+ Tjq = Tjo + Tjp;
+ rio[WS(ios, 45)] = Tjn - Tjq;
+ iio[-WS(ios, 13)] = Tjn + Tjq;
+ }
+ {
+ E TcP, TcS, Tjr, Tjs;
+ TcP = TbV - Tca;
+ TcS = TcQ - TcR;
+ iio[-WS(ios, 61)] = TcP - TcS;
+ rio[WS(ios, 29)] = TcP + TcS;
+ Tjr = TcN - Tcu;
+ Tjs = Tjp - Tjo;
+ rio[WS(ios, 61)] = Tjr - Tjs;
+ iio[-WS(ios, 29)] = Tjr + Tjs;
+ }
+ {
+ E TcX, Td4, Tjf, Tjk;
+ TcX = TcT + TcW;
+ Td4 = Td0 + Td3;
+ iio[-WS(ios, 37)] = TcX - Td4;
+ rio[WS(ios, 5)] = TcX + Td4;
+ Tjf = Td6 + Td7;
+ Tjk = Tjg + Tjj;
+ rio[WS(ios, 37)] = Tjf - Tjk;
+ iio[-WS(ios, 5)] = Tjf + Tjk;
+ }
+ {
+ E Td5, Td8, Tjl, Tjm;
+ Td5 = TcT - TcW;
+ Td8 = Td6 - Td7;
+ iio[-WS(ios, 53)] = Td5 - Td8;
+ rio[WS(ios, 21)] = Td5 + Td8;
+ Tjl = Td3 - Td0;
+ Tjm = Tjj - Tjg;
+ rio[WS(ios, 53)] = Tjl - Tjm;
+ iio[-WS(ios, 21)] = Tjl + Tjm;
+ }
+ }
+ {
+ E Tb1, Tjz, TjF, Tbt, Tb8, Tju, Tbw, TjE, TbA, TbG, Tbg, Tbq, TbD, TbH, Tbn;
+ E Tbr, Tb7;
+ Tb1 = TaX - Tb0;
+ Tjz = Tjv + Tjy;
+ TjF = Tjy - Tjv;
+ Tbt = TaX + Tb0;
+ Tb7 = FMA(KP831469612, Tb5, KP555570233 * Tb6);
+ Tb8 = Tb4 - Tb7;
+ Tju = Tb4 + Tb7;
+ {
+ E Tbv, Tby, Tbz, Tbc, Tbf;
+ Tbv = FNMS(KP555570233, Tb5, KP831469612 * Tb6);
+ Tbw = Tbu + Tbv;
+ TjE = Tbv - Tbu;
+ Tby = Tba + Tbb;
+ Tbz = Tbd + Tbe;
+ TbA = FMA(KP956940335, Tby, KP290284677 * Tbz);
+ TbG = FNMS(KP290284677, Tby, KP956940335 * Tbz);
+ Tbc = Tba - Tbb;
+ Tbf = Tbd - Tbe;
+ Tbg = FMA(KP471396736, Tbc, KP881921264 * Tbf);
+ Tbq = FNMS(KP881921264, Tbc, KP471396736 * Tbf);
+ {
+ E TbB, TbC, Tbj, Tbm;
+ TbB = Tbh + Tbi;
+ TbC = Tbk + Tbl;
+ TbD = FNMS(KP290284677, TbC, KP956940335 * TbB);
+ TbH = FMA(KP290284677, TbB, KP956940335 * TbC);
+ Tbj = Tbh - Tbi;
+ Tbm = Tbk - Tbl;
+ Tbn = FNMS(KP881921264, Tbm, KP471396736 * Tbj);
+ Tbr = FMA(KP881921264, Tbj, KP471396736 * Tbm);
+ }
+ }
+ {
+ E Tb9, Tbo, TjD, TjG;
+ Tb9 = Tb1 + Tb8;
+ Tbo = Tbg + Tbn;
+ iio[-WS(ios, 43)] = Tb9 - Tbo;
+ rio[WS(ios, 11)] = Tb9 + Tbo;
+ TjD = Tbq + Tbr;
+ TjG = TjE + TjF;
+ rio[WS(ios, 43)] = TjD - TjG;
+ iio[-WS(ios, 11)] = TjD + TjG;
+ }
+ {
+ E Tbp, Tbs, TjH, TjI;
+ Tbp = Tb1 - Tb8;
+ Tbs = Tbq - Tbr;
+ iio[-WS(ios, 59)] = Tbp - Tbs;
+ rio[WS(ios, 27)] = Tbp + Tbs;
+ TjH = Tbn - Tbg;
+ TjI = TjF - TjE;
+ rio[WS(ios, 59)] = TjH - TjI;
+ iio[-WS(ios, 27)] = TjH + TjI;
+ }
+ {
+ E Tbx, TbE, Tjt, TjA;
+ Tbx = Tbt + Tbw;
+ TbE = TbA + TbD;
+ iio[-WS(ios, 35)] = Tbx - TbE;
+ rio[WS(ios, 3)] = Tbx + TbE;
+ Tjt = TbG + TbH;
+ TjA = Tju + Tjz;
+ rio[WS(ios, 35)] = Tjt - TjA;
+ iio[-WS(ios, 3)] = Tjt + TjA;
+ }
+ {
+ E TbF, TbI, TjB, TjC;
+ TbF = Tbt - Tbw;
+ TbI = TbG - TbH;
+ iio[-WS(ios, 51)] = TbF - TbI;
+ rio[WS(ios, 19)] = TbF + TbI;
+ TjB = TbD - TbA;
+ TjC = Tjz - Tju;
+ rio[WS(ios, 51)] = TjB - TjC;
+ iio[-WS(ios, 19)] = TjB + TjC;
+ }
+ }
+ {
+ E Tdd, Tj5, Tjb, TdF, Tdk, TiY, TdI, Tja, TdM, TdS, Tds, TdC, TdP, TdT, Tdz;
+ E TdD, Tdj;
+ Tdd = Td9 - Tdc;
+ Tj5 = TiZ + Tj4;
+ Tjb = Tj4 - TiZ;
+ TdF = Td9 + Tdc;
+ Tdj = FMA(KP195090322, Tdh, KP980785280 * Tdi);
+ Tdk = Tdg - Tdj;
+ TiY = Tdg + Tdj;
+ {
+ E TdH, TdK, TdL, Tdo, Tdr;
+ TdH = FNMS(KP195090322, Tdi, KP980785280 * Tdh);
+ TdI = TdG + TdH;
+ Tja = TdH - TdG;
+ TdK = Tdm + Tdn;
+ TdL = Tdp + Tdq;
+ TdM = FMA(KP995184726, TdK, KP098017140 * TdL);
+ TdS = FNMS(KP098017140, TdK, KP995184726 * TdL);
+ Tdo = Tdm - Tdn;
+ Tdr = Tdp - Tdq;
+ Tds = FMA(KP634393284, Tdo, KP773010453 * Tdr);
+ TdC = FNMS(KP773010453, Tdo, KP634393284 * Tdr);
+ {
+ E TdN, TdO, Tdv, Tdy;
+ TdN = Tdt + Tdu;
+ TdO = Tdw + Tdx;
+ TdP = FNMS(KP098017140, TdO, KP995184726 * TdN);
+ TdT = FMA(KP098017140, TdN, KP995184726 * TdO);
+ Tdv = Tdt - Tdu;
+ Tdy = Tdw - Tdx;
+ Tdz = FNMS(KP773010453, Tdy, KP634393284 * Tdv);
+ TdD = FMA(KP773010453, Tdv, KP634393284 * Tdy);
+ }
+ }
+ {
+ E Tdl, TdA, Tj9, Tjc;
+ Tdl = Tdd + Tdk;
+ TdA = Tds + Tdz;
+ iio[-WS(ios, 41)] = Tdl - TdA;
+ rio[WS(ios, 9)] = Tdl + TdA;
+ Tj9 = TdC + TdD;
+ Tjc = Tja + Tjb;
+ rio[WS(ios, 41)] = Tj9 - Tjc;
+ iio[-WS(ios, 9)] = Tj9 + Tjc;
+ }
+ {
+ E TdB, TdE, Tjd, Tje;
+ TdB = Tdd - Tdk;
+ TdE = TdC - TdD;
+ iio[-WS(ios, 57)] = TdB - TdE;
+ rio[WS(ios, 25)] = TdB + TdE;
+ Tjd = Tdz - Tds;
+ Tje = Tjb - Tja;
+ rio[WS(ios, 57)] = Tjd - Tje;
+ iio[-WS(ios, 25)] = Tjd + Tje;
+ }
+ {
+ E TdJ, TdQ, TiX, Tj6;
+ TdJ = TdF + TdI;
+ TdQ = TdM + TdP;
+ iio[-WS(ios, 33)] = TdJ - TdQ;
+ rio[WS(ios, 1)] = TdJ + TdQ;
+ TiX = TdS + TdT;
+ Tj6 = TiY + Tj5;
+ rio[WS(ios, 33)] = TiX - Tj6;
+ iio[-WS(ios, 1)] = TiX + Tj6;
+ }
+ {
+ E TdR, TdU, Tj7, Tj8;
+ TdR = TdF - TdI;
+ TdU = TdS - TdT;
+ iio[-WS(ios, 49)] = TdR - TdU;
+ rio[WS(ios, 17)] = TdR + TdU;
+ Tj7 = TdP - TdM;
+ Tj8 = Tj5 - TiY;
+ rio[WS(ios, 49)] = Tj7 - Tj8;
+ iio[-WS(ios, 17)] = Tj7 + Tj8;
+ }
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_COS, 0, 1},
+ {TW_SIN, 0, 1},
+ {TW_COS, 0, 3},
+ {TW_SIN, 0, 3},
+ {TW_COS, 0, 9},
+ {TW_SIN, 0, 9},
+ {TW_COS, 0, 27},
+ {TW_SIN, 0, 27},
+ {TW_COS, 0, 63},
+ {TW_SIN, 0, 63},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 64, "hf2_64", twinstr, {880, 386, 274, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf2_64) (planner *p) {
+ X(khc2hc_dit_register) (p, hf2_64, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf2_8.c b/src/fftw3/rdft/codelets/r2hc/hf2_8.c
new file mode 100644
index 0000000..663e8dd
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf2_8.c
@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:27 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -twiddle-log3 -n 8 -dit -name hf2_8 -include hf.h */
+
+/*
+ * This function contains 74 FP additions, 44 FP multiplications,
+ * (or, 56 additions, 26 multiplications, 18 fused multiply/add),
+ * 50 stack variables, and 32 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf2_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf2_8(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 6) {
+ E T1, T1c, TJ, T17, TY, TV, TR, Tk, Tr, TN, TM, Tw, TB, TS, Te;
+ E T1b;
+ T1 = rio[0];
+ T1c = iio[-WS(ios, 7)];
+ {
+ E T9, T3, T6, T4, Tb, T7, Ta, Tg, Ti, TI, TX, Tl, Tm, Tn, TW;
+ E Tp, TF, Td, TA, Th, Ty, Tj, Tv, To, Tq, Tu;
+ T9 = rio[WS(ios, 4)];
+ {
+ E TD, TH, TE, TG, T2, T5;
+ TD = rio[WS(ios, 7)];
+ TH = iio[-WS(ios, 4)];
+ TE = iio[0];
+ TG = rio[WS(ios, 3)];
+ T2 = W[2];
+ T5 = W[3];
+ T3 = W[0];
+ T6 = W[1];
+ T4 = T2 * T3;
+ Tb = T5 * T3;
+ T7 = T5 * T6;
+ Ta = T2 * T6;
+ Tg = T4 + T7;
+ Ti = Ta - Tb;
+ TI = FMA(T2, TG, T5 * TH);
+ TX = FNMS(T5, TG, T2 * TH);
+ Tl = W[4];
+ Tm = W[5];
+ Tn = FMA(Tl, T3, Tm * T6);
+ TW = FNMS(Tm, TD, Tl * TE);
+ Tp = FNMS(Tm, T3, Tl * T6);
+ TF = FMA(Tl, TD, Tm * TE);
+ }
+ Td = iio[-WS(ios, 3)];
+ TA = iio[-WS(ios, 2)];
+ Th = rio[WS(ios, 2)];
+ Ty = rio[WS(ios, 5)];
+ Tj = iio[-WS(ios, 5)];
+ Tv = iio[-WS(ios, 6)];
+ To = rio[WS(ios, 6)];
+ Tq = iio[-WS(ios, 1)];
+ Tu = rio[WS(ios, 1)];
+ TJ = TF + TI;
+ T17 = TW + TX;
+ TY = TW - TX;
+ TV = TF - TI;
+ TR = FNMS(T6, Tu, T3 * Tv);
+ Tk = FNMS(Ti, Tj, Tg * Th);
+ Tr = FNMS(Tp, Tq, Tn * To);
+ TN = FMA(Tp, To, Tn * Tq);
+ TM = FMA(Ti, Th, Tg * Tj);
+ Tw = FMA(T3, Tu, T6 * Tv);
+ {
+ E Tx, Tz, T8, Tc;
+ Tx = FNMS(Tm, Ti, Tl * Tg);
+ Tz = FMA(Tl, Ti, Tm * Tg);
+ TB = FMA(Tx, Ty, Tz * TA);
+ TS = FNMS(Tz, Ty, Tx * TA);
+ T8 = T4 - T7;
+ Tc = Ta + Tb;
+ Te = FMA(T8, T9, Tc * Td);
+ T1b = FNMS(Tc, T9, T8 * Td);
+ }
+ }
+ {
+ E TK, T1f, T18, T19, Tt, T15, T1e, T1g, TC, T16;
+ TC = Tw + TB;
+ TK = TC + TJ;
+ T1f = TJ - TC;
+ T16 = TR + TS;
+ T18 = T16 - T17;
+ T19 = T16 + T17;
+ {
+ E Tf, Ts, T1a, T1d;
+ Tf = T1 + Te;
+ Ts = Tk + Tr;
+ Tt = Tf + Ts;
+ T15 = Tf - Ts;
+ T1a = TM + TN;
+ T1d = T1b + T1c;
+ T1e = T1a + T1d;
+ T1g = T1d - T1a;
+ }
+ iio[-WS(ios, 4)] = Tt - TK;
+ rio[WS(ios, 4)] = T19 - T1e;
+ rio[0] = Tt + TK;
+ iio[0] = T19 + T1e;
+ iio[-WS(ios, 6)] = T15 - T18;
+ rio[WS(ios, 6)] = T1f - T1g;
+ rio[WS(ios, 2)] = T15 + T18;
+ iio[-WS(ios, 2)] = T1f + T1g;
+ }
+ {
+ E TZ, T13, TP, T11, TU, T12, T1k, T1m, TL, TO;
+ TZ = TV - TY;
+ T13 = TV + TY;
+ TL = T1 - Te;
+ TO = TM - TN;
+ TP = TL + TO;
+ T11 = TL - TO;
+ {
+ E TQ, TT, T1i, T1j;
+ TQ = Tw - TB;
+ TT = TR - TS;
+ TU = TQ + TT;
+ T12 = TT - TQ;
+ T1i = T1c - T1b;
+ T1j = Tk - Tr;
+ T1k = T1i - T1j;
+ T1m = T1j + T1i;
+ }
+ {
+ E T10, T1h, T14, T1l;
+ T10 = KP707106781 * (TU + TZ);
+ iio[-WS(ios, 5)] = TP - T10;
+ rio[WS(ios, 1)] = TP + T10;
+ T1h = KP707106781 * (T12 + T13);
+ rio[WS(ios, 5)] = T1h - T1k;
+ iio[-WS(ios, 1)] = T1h + T1k;
+ T14 = KP707106781 * (T12 - T13);
+ iio[-WS(ios, 7)] = T11 - T14;
+ rio[WS(ios, 3)] = T11 + T14;
+ T1l = KP707106781 * (TZ - TU);
+ rio[WS(ios, 7)] = T1l - T1m;
+ iio[-WS(ios, 3)] = T1l + T1m;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_COS, 0, 1},
+ {TW_SIN, 0, 1},
+ {TW_COS, 0, 3},
+ {TW_SIN, 0, 3},
+ {TW_COS, 0, 7},
+ {TW_SIN, 0, 7},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 8, "hf2_8", twinstr, {56, 26, 18, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf2_8) (planner *p) {
+ X(khc2hc_dit_register) (p, hf2_8, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_10.c b/src/fftw3/rdft/codelets/r2hc/hf_10.c
new file mode 100644
index 0000000..bb970fa
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_10.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:02 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 10 -dit -name hf_10 -include hf.h */
+
+/*
+ * This function contains 102 FP additions, 60 FP multiplications,
+ * (or, 72 additions, 30 multiplications, 30 fused multiply/add),
+ * 45 stack variables, and 40 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_10(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 18) {
+ E T7, T1O, TT, T1C, TF, TQ, TR, T1r, T1s, T1L, TX, TY, TZ, T16, T19;
+ E T1y, Ti, Tt, Tu, T1o, T1p, T1M, TU, TV, TW, T1d, T1g, T1x;
+ {
+ E T1, T1B, T6, T1A;
+ T1 = rio[0];
+ T1B = iio[-WS(ios, 9)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 5)];
+ T5 = iio[-WS(ios, 4)];
+ T2 = W[8];
+ T4 = W[9];
+ T6 = FMA(T2, T3, T4 * T5);
+ T1A = FNMS(T4, T3, T2 * T5);
+ }
+ T7 = T1 - T6;
+ T1O = T1B - T1A;
+ TT = T1 + T6;
+ T1C = T1A + T1B;
+ }
+ {
+ E Tz, T14, TP, T18, TE, T15, TK, T17;
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 4)];
+ Ty = iio[-WS(ios, 5)];
+ Tv = W[6];
+ Tx = W[7];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T14 = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TM, TO, TL, TN;
+ TM = rio[WS(ios, 1)];
+ TO = iio[-WS(ios, 8)];
+ TL = W[0];
+ TN = W[1];
+ TP = FMA(TL, TM, TN * TO);
+ T18 = FNMS(TN, TM, TL * TO);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 9)];
+ TD = iio[0];
+ TA = W[16];
+ TC = W[17];
+ TE = FMA(TA, TB, TC * TD);
+ T15 = FNMS(TC, TB, TA * TD);
+ }
+ {
+ E TH, TJ, TG, TI;
+ TH = rio[WS(ios, 6)];
+ TJ = iio[-WS(ios, 3)];
+ TG = W[10];
+ TI = W[11];
+ TK = FMA(TG, TH, TI * TJ);
+ T17 = FNMS(TI, TH, TG * TJ);
+ }
+ TF = Tz - TE;
+ TQ = TK - TP;
+ TR = TF + TQ;
+ T1r = T14 - T15;
+ T1s = T18 - T17;
+ T1L = T1s - T1r;
+ TX = Tz + TE;
+ TY = TK + TP;
+ TZ = TX + TY;
+ T16 = T14 + T15;
+ T19 = T17 + T18;
+ T1y = T16 + T19;
+ }
+ {
+ E Tc, T1b, Th, T1c, Tn, T1e, Ts, T1f;
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 2)];
+ Tb = iio[-WS(ios, 7)];
+ T8 = W[2];
+ Ta = W[3];
+ Tc = FMA(T8, T9, Ta * Tb);
+ T1b = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 7)];
+ Tg = iio[-WS(ios, 2)];
+ Td = W[12];
+ Tf = W[13];
+ Th = FMA(Td, Te, Tf * Tg);
+ T1c = FNMS(Tf, Te, Td * Tg);
+ }
+ {
+ E Tk, Tm, Tj, Tl;
+ Tk = rio[WS(ios, 8)];
+ Tm = iio[-WS(ios, 1)];
+ Tj = W[14];
+ Tl = W[15];
+ Tn = FMA(Tj, Tk, Tl * Tm);
+ T1e = FNMS(Tl, Tk, Tj * Tm);
+ }
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 3)];
+ Tr = iio[-WS(ios, 6)];
+ To = W[4];
+ Tq = W[5];
+ Ts = FMA(To, Tp, Tq * Tr);
+ T1f = FNMS(Tq, Tp, To * Tr);
+ }
+ Ti = Tc - Th;
+ Tt = Tn - Ts;
+ Tu = Ti + Tt;
+ T1o = T1b - T1c;
+ T1p = T1e - T1f;
+ T1M = T1o + T1p;
+ TU = Tc + Th;
+ TV = Tn + Ts;
+ TW = TU + TV;
+ T1d = T1b + T1c;
+ T1g = T1e + T1f;
+ T1x = T1d + T1g;
+ }
+ {
+ E T1l, TS, T1m, T1u, T1w, T1q, T1t, T1v, T1n;
+ T1l = KP559016994 * (Tu - TR);
+ TS = Tu + TR;
+ T1m = FNMS(KP250000000, TS, T7);
+ T1q = T1o - T1p;
+ T1t = T1r + T1s;
+ T1u = FMA(KP951056516, T1q, KP587785252 * T1t);
+ T1w = FNMS(KP587785252, T1q, KP951056516 * T1t);
+ iio[-WS(ios, 5)] = T7 + TS;
+ T1v = T1m - T1l;
+ iio[-WS(ios, 7)] = T1v - T1w;
+ rio[WS(ios, 3)] = T1v + T1w;
+ T1n = T1l + T1m;
+ iio[-WS(ios, 9)] = T1n - T1u;
+ rio[WS(ios, 1)] = T1n + T1u;
+ }
+ {
+ E T1S, T1N, T1T, T1R, T1V, T1P, T1Q, T1W, T1U;
+ T1S = KP559016994 * (T1M + T1L);
+ T1N = T1L - T1M;
+ T1T = FMA(KP250000000, T1N, T1O);
+ T1P = TQ - TF;
+ T1Q = Ti - Tt;
+ T1R = FNMS(KP951056516, T1Q, KP587785252 * T1P);
+ T1V = FMA(KP587785252, T1Q, KP951056516 * T1P);
+ rio[WS(ios, 5)] = T1N - T1O;
+ T1W = T1T - T1S;
+ rio[WS(ios, 7)] = T1V - T1W;
+ iio[-WS(ios, 3)] = T1V + T1W;
+ T1U = T1S + T1T;
+ rio[WS(ios, 9)] = T1R - T1U;
+ iio[-WS(ios, 1)] = T1R + T1U;
+ }
+ {
+ E T12, T10, T11, T1i, T1k, T1a, T1h, T1j, T13;
+ T12 = KP559016994 * (TW - TZ);
+ T10 = TW + TZ;
+ T11 = FNMS(KP250000000, T10, TT);
+ T1a = T16 - T19;
+ T1h = T1d - T1g;
+ T1i = FNMS(KP587785252, T1h, KP951056516 * T1a);
+ T1k = FMA(KP951056516, T1h, KP587785252 * T1a);
+ rio[0] = TT + T10;
+ T1j = T12 + T11;
+ rio[WS(ios, 4)] = T1j - T1k;
+ iio[-WS(ios, 6)] = T1j + T1k;
+ T13 = T11 - T12;
+ rio[WS(ios, 2)] = T13 - T1i;
+ iio[-WS(ios, 8)] = T13 + T1i;
+ }
+ {
+ E T1H, T1z, T1G, T1F, T1J, T1D, T1E, T1K, T1I;
+ T1H = KP559016994 * (T1x - T1y);
+ T1z = T1x + T1y;
+ T1G = FNMS(KP250000000, T1z, T1C);
+ T1D = TX - TY;
+ T1E = TU - TV;
+ T1F = FNMS(KP587785252, T1E, KP951056516 * T1D);
+ T1J = FMA(KP951056516, T1E, KP587785252 * T1D);
+ iio[0] = T1z + T1C;
+ T1K = T1H + T1G;
+ rio[WS(ios, 6)] = T1J - T1K;
+ iio[-WS(ios, 4)] = T1J + T1K;
+ T1I = T1G - T1H;
+ rio[WS(ios, 8)] = T1F - T1I;
+ iio[-WS(ios, 2)] = T1F + T1I;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 10},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 10, "hf_10", twinstr, {72, 30, 30, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_10) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_10, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_12.c b/src/fftw3/rdft/codelets/r2hc/hf_12.c
new file mode 100644
index 0000000..e399159
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_12.c
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:06 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 12 -dit -name hf_12 -include hf.h */
+
+/*
+ * This function contains 118 FP additions, 60 FP multiplications,
+ * (or, 88 additions, 30 multiplications, 30 fused multiply/add),
+ * 47 stack variables, and 48 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_12(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 22) {
+ E T1, T1W, T18, T22, Tc, T15, T1V, T23, TA, T1y, T1j, T1B, TL, T1g, T1z;
+ E T1A, Ti, T1S, T1d, T25, Tt, T1a, T1T, T26, TR, T1E, T1o, T1D, T12, T1l;
+ E T1F, T1G;
+ {
+ E T6, T16, Tb, T17;
+ T1 = rio[0];
+ T1W = iio[-WS(ios, 11)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 4)];
+ T5 = iio[-WS(ios, 7)];
+ T2 = W[6];
+ T4 = W[7];
+ T6 = FMA(T2, T3, T4 * T5);
+ T16 = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 8)];
+ Ta = iio[-WS(ios, 3)];
+ T7 = W[14];
+ T9 = W[15];
+ Tb = FMA(T7, T8, T9 * Ta);
+ T17 = FNMS(T9, T8, T7 * Ta);
+ }
+ T18 = KP866025403 * (T16 - T17);
+ T22 = KP866025403 * (Tb - T6);
+ Tc = T6 + Tb;
+ T15 = FNMS(KP500000000, Tc, T1);
+ T1V = T16 + T17;
+ T23 = FNMS(KP500000000, T1V, T1W);
+ }
+ {
+ E TK, T1i, TF, T1h;
+ {
+ E Tx, Tz, Tw, Ty;
+ Tx = rio[WS(ios, 3)];
+ Tz = iio[-WS(ios, 8)];
+ Tw = W[4];
+ Ty = W[5];
+ TA = FMA(Tw, Tx, Ty * Tz);
+ T1y = FNMS(Ty, Tx, Tw * Tz);
+ }
+ {
+ E TH, TJ, TG, TI;
+ TH = rio[WS(ios, 11)];
+ TJ = iio[0];
+ TG = W[20];
+ TI = W[21];
+ TK = FMA(TG, TH, TI * TJ);
+ T1i = FNMS(TI, TH, TG * TJ);
+ }
+ {
+ E TC, TE, TB, TD;
+ TC = rio[WS(ios, 7)];
+ TE = iio[-WS(ios, 4)];
+ TB = W[12];
+ TD = W[13];
+ TF = FMA(TB, TC, TD * TE);
+ T1h = FNMS(TD, TC, TB * TE);
+ }
+ T1j = KP866025403 * (T1h - T1i);
+ T1B = KP866025403 * (TK - TF);
+ TL = TF + TK;
+ T1g = FNMS(KP500000000, TL, TA);
+ T1z = T1h + T1i;
+ T1A = FNMS(KP500000000, T1z, T1y);
+ }
+ {
+ E Ts, T1c, Tn, T1b;
+ {
+ E Tf, Th, Te, Tg;
+ Tf = rio[WS(ios, 6)];
+ Th = iio[-WS(ios, 5)];
+ Te = W[10];
+ Tg = W[11];
+ Ti = FMA(Te, Tf, Tg * Th);
+ T1S = FNMS(Tg, Tf, Te * Th);
+ }
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 2)];
+ Tr = iio[-WS(ios, 9)];
+ To = W[2];
+ Tq = W[3];
+ Ts = FMA(To, Tp, Tq * Tr);
+ T1c = FNMS(Tq, Tp, To * Tr);
+ }
+ {
+ E Tk, Tm, Tj, Tl;
+ Tk = rio[WS(ios, 10)];
+ Tm = iio[-WS(ios, 1)];
+ Tj = W[18];
+ Tl = W[19];
+ Tn = FMA(Tj, Tk, Tl * Tm);
+ T1b = FNMS(Tl, Tk, Tj * Tm);
+ }
+ T1d = KP866025403 * (T1b - T1c);
+ T25 = KP866025403 * (Ts - Tn);
+ Tt = Tn + Ts;
+ T1a = FNMS(KP500000000, Tt, Ti);
+ T1T = T1b + T1c;
+ T26 = FNMS(KP500000000, T1T, T1S);
+ }
+ {
+ E T11, T1n, TW, T1m;
+ {
+ E TO, TQ, TN, TP;
+ TO = rio[WS(ios, 9)];
+ TQ = iio[-WS(ios, 2)];
+ TN = W[16];
+ TP = W[17];
+ TR = FMA(TN, TO, TP * TQ);
+ T1E = FNMS(TP, TO, TN * TQ);
+ }
+ {
+ E TY, T10, TX, TZ;
+ TY = rio[WS(ios, 5)];
+ T10 = iio[-WS(ios, 6)];
+ TX = W[8];
+ TZ = W[9];
+ T11 = FMA(TX, TY, TZ * T10);
+ T1n = FNMS(TZ, TY, TX * T10);
+ }
+ {
+ E TT, TV, TS, TU;
+ TT = rio[WS(ios, 1)];
+ TV = iio[-WS(ios, 10)];
+ TS = W[0];
+ TU = W[1];
+ TW = FMA(TS, TT, TU * TV);
+ T1m = FNMS(TU, TT, TS * TV);
+ }
+ T1o = KP866025403 * (T1m - T1n);
+ T1D = KP866025403 * (T11 - TW);
+ T12 = TW + T11;
+ T1l = FNMS(KP500000000, T12, TR);
+ T1F = T1m + T1n;
+ T1G = FNMS(KP500000000, T1F, T1E);
+ }
+ {
+ E Tv, T1N, T1Y, T20, T14, T1Z, T1Q, T1R;
+ {
+ E Td, Tu, T1U, T1X;
+ Td = T1 + Tc;
+ Tu = Ti + Tt;
+ Tv = Td + Tu;
+ T1N = Td - Tu;
+ T1U = T1S + T1T;
+ T1X = T1V + T1W;
+ T1Y = T1U + T1X;
+ T20 = T1X - T1U;
+ }
+ {
+ E TM, T13, T1O, T1P;
+ TM = TA + TL;
+ T13 = TR + T12;
+ T14 = TM + T13;
+ T1Z = TM - T13;
+ T1O = T1y + T1z;
+ T1P = T1E + T1F;
+ T1Q = T1O - T1P;
+ T1R = T1O + T1P;
+ }
+ iio[-WS(ios, 6)] = Tv - T14;
+ rio[WS(ios, 6)] = T1R - T1Y;
+ rio[0] = Tv + T14;
+ iio[0] = T1R + T1Y;
+ rio[WS(ios, 3)] = T1N - T1Q;
+ iio[-WS(ios, 3)] = T1Z + T20;
+ iio[-WS(ios, 9)] = T1N + T1Q;
+ rio[WS(ios, 9)] = T1Z - T20;
+ }
+ {
+ E T1t, T1J, T28, T2a, T1w, T21, T1M, T29;
+ {
+ E T1r, T1s, T24, T27;
+ T1r = T15 + T18;
+ T1s = T1a + T1d;
+ T1t = T1r + T1s;
+ T1J = T1r - T1s;
+ T24 = T22 + T23;
+ T27 = T25 + T26;
+ T28 = T24 - T27;
+ T2a = T27 + T24;
+ }
+ {
+ E T1u, T1v, T1K, T1L;
+ T1u = T1g + T1j;
+ T1v = T1l + T1o;
+ T1w = T1u + T1v;
+ T21 = T1v - T1u;
+ T1K = T1B + T1A;
+ T1L = T1D + T1G;
+ T1M = T1K - T1L;
+ T29 = T1K + T1L;
+ }
+ iio[-WS(ios, 10)] = T1t - T1w;
+ rio[WS(ios, 10)] = T29 - T2a;
+ rio[WS(ios, 4)] = T1t + T1w;
+ iio[-WS(ios, 4)] = T29 + T2a;
+ iio[-WS(ios, 7)] = T1J - T1M;
+ rio[WS(ios, 7)] = T21 - T28;
+ rio[WS(ios, 1)] = T1J + T1M;
+ iio[-WS(ios, 1)] = T21 + T28;
+ }
+ {
+ E T1f, T1x, T2e, T2g, T1q, T2f, T1I, T2b;
+ {
+ E T19, T1e, T2c, T2d;
+ T19 = T15 - T18;
+ T1e = T1a - T1d;
+ T1f = T19 + T1e;
+ T1x = T19 - T1e;
+ T2c = T26 - T25;
+ T2d = T23 - T22;
+ T2e = T2c + T2d;
+ T2g = T2d - T2c;
+ }
+ {
+ E T1k, T1p, T1C, T1H;
+ T1k = T1g - T1j;
+ T1p = T1l - T1o;
+ T1q = T1k + T1p;
+ T2f = T1p - T1k;
+ T1C = T1A - T1B;
+ T1H = T1D - T1G;
+ T1I = T1C + T1H;
+ T2b = T1H - T1C;
+ }
+ rio[WS(ios, 2)] = T1f - T1q;
+ iio[-WS(ios, 2)] = T2b + T2e;
+ iio[-WS(ios, 8)] = T1f + T1q;
+ rio[WS(ios, 8)] = T2b - T2e;
+ iio[-WS(ios, 11)] = T1x - T1I;
+ rio[WS(ios, 11)] = T2f - T2g;
+ rio[WS(ios, 5)] = T1x + T1I;
+ iio[-WS(ios, 5)] = T2f + T2g;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 12},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 12, "hf_12", twinstr, {88, 30, 30, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_12) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_12, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_15.c b/src/fftw3/rdft/codelets/r2hc/hf_15.c
new file mode 100644
index 0000000..71a3b40
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_15.c
@@ -0,0 +1,405 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:07 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 15 -dit -name hf_15 -include hf.h */
+
+/*
+ * This function contains 184 FP additions, 112 FP multiplications,
+ * (or, 128 additions, 56 multiplications, 56 fused multiply/add),
+ * 65 stack variables, and 60 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_15(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 28) {
+ E T1q, T34, Td, T1n, T2S, T35, T13, T1k, T1l, T2E, T2F, T2O, T1H, T1T, T2k;
+ E T2t, T2f, T2s, T1M, T1U, Tu, TL, TM, T2H, T2I, T2N, T1w, T1Q, T29, T2w;
+ E T24, T2v, T1B, T1R;
+ {
+ E T1, T2R, T6, T1o, Tb, T1p, Tc, T2Q;
+ T1 = rio[0];
+ T2R = iio[-WS(ios, 14)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 5)];
+ T5 = iio[-WS(ios, 9)];
+ T2 = W[8];
+ T4 = W[9];
+ T6 = FMA(T2, T3, T4 * T5);
+ T1o = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 10)];
+ Ta = iio[-WS(ios, 4)];
+ T7 = W[18];
+ T9 = W[19];
+ Tb = FMA(T7, T8, T9 * Ta);
+ T1p = FNMS(T9, T8, T7 * Ta);
+ }
+ T1q = KP866025403 * (T1o - T1p);
+ T34 = KP866025403 * (Tb - T6);
+ Tc = T6 + Tb;
+ Td = T1 + Tc;
+ T1n = FNMS(KP500000000, Tc, T1);
+ T2Q = T1o + T1p;
+ T2S = T2Q + T2R;
+ T35 = FNMS(KP500000000, T2Q, T2R);
+ }
+ {
+ E TR, T2c, T18, T2h, TW, T1E, T11, T1F, T12, T2d, T1d, T1J, T1i, T1K, T1j;
+ E T2i;
+ {
+ E TO, TQ, TN, TP;
+ TO = rio[WS(ios, 6)];
+ TQ = iio[-WS(ios, 8)];
+ TN = W[10];
+ TP = W[11];
+ TR = FMA(TN, TO, TP * TQ);
+ T2c = FNMS(TP, TO, TN * TQ);
+ }
+ {
+ E T15, T17, T14, T16;
+ T15 = rio[WS(ios, 9)];
+ T17 = iio[-WS(ios, 5)];
+ T14 = W[16];
+ T16 = W[17];
+ T18 = FMA(T14, T15, T16 * T17);
+ T2h = FNMS(T16, T15, T14 * T17);
+ }
+ {
+ E TT, TV, TS, TU;
+ TT = rio[WS(ios, 11)];
+ TV = iio[-WS(ios, 3)];
+ TS = W[20];
+ TU = W[21];
+ TW = FMA(TS, TT, TU * TV);
+ T1E = FNMS(TU, TT, TS * TV);
+ }
+ {
+ E TY, T10, TX, TZ;
+ TY = rio[WS(ios, 1)];
+ T10 = iio[-WS(ios, 13)];
+ TX = W[0];
+ TZ = W[1];
+ T11 = FMA(TX, TY, TZ * T10);
+ T1F = FNMS(TZ, TY, TX * T10);
+ }
+ T12 = TW + T11;
+ T2d = T1E + T1F;
+ {
+ E T1a, T1c, T19, T1b;
+ T1a = rio[WS(ios, 14)];
+ T1c = iio[0];
+ T19 = W[26];
+ T1b = W[27];
+ T1d = FMA(T19, T1a, T1b * T1c);
+ T1J = FNMS(T1b, T1a, T19 * T1c);
+ }
+ {
+ E T1f, T1h, T1e, T1g;
+ T1f = rio[WS(ios, 4)];
+ T1h = iio[-WS(ios, 10)];
+ T1e = W[6];
+ T1g = W[7];
+ T1i = FMA(T1e, T1f, T1g * T1h);
+ T1K = FNMS(T1g, T1f, T1e * T1h);
+ }
+ T1j = T1d + T1i;
+ T2i = T1J + T1K;
+ {
+ E T1D, T1G, T2g, T2j;
+ T13 = TR + T12;
+ T1k = T18 + T1j;
+ T1l = T13 + T1k;
+ T2E = T2c + T2d;
+ T2F = T2h + T2i;
+ T2O = T2E + T2F;
+ T1D = FNMS(KP500000000, T12, TR);
+ T1G = KP866025403 * (T1E - T1F);
+ T1H = T1D - T1G;
+ T1T = T1D + T1G;
+ T2g = KP866025403 * (T1d - T1i);
+ T2j = FNMS(KP500000000, T2i, T2h);
+ T2k = T2g - T2j;
+ T2t = T2g + T2j;
+ {
+ E T2b, T2e, T1I, T1L;
+ T2b = KP866025403 * (T11 - TW);
+ T2e = FNMS(KP500000000, T2d, T2c);
+ T2f = T2b + T2e;
+ T2s = T2e - T2b;
+ T1I = FNMS(KP500000000, T1j, T18);
+ T1L = KP866025403 * (T1J - T1K);
+ T1M = T1I - T1L;
+ T1U = T1I + T1L;
+ }
+ }
+ }
+ {
+ E Ti, T21, Tz, T26, TE, T1y, TJ, T1z, TK, T27, Tn, T1t, Ts, T1u, Tt;
+ E T22;
+ {
+ E Tf, Th, Te, Tg;
+ Tf = rio[WS(ios, 3)];
+ Th = iio[-WS(ios, 11)];
+ Te = W[4];
+ Tg = W[5];
+ Ti = FMA(Te, Tf, Tg * Th);
+ T21 = FNMS(Tg, Tf, Te * Th);
+ }
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 12)];
+ Ty = iio[-WS(ios, 2)];
+ Tv = W[22];
+ Tx = W[23];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T26 = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 2)];
+ TD = iio[-WS(ios, 12)];
+ TA = W[2];
+ TC = W[3];
+ TE = FMA(TA, TB, TC * TD);
+ T1y = FNMS(TC, TB, TA * TD);
+ }
+ {
+ E TG, TI, TF, TH;
+ TG = rio[WS(ios, 7)];
+ TI = iio[-WS(ios, 7)];
+ TF = W[12];
+ TH = W[13];
+ TJ = FMA(TF, TG, TH * TI);
+ T1z = FNMS(TH, TG, TF * TI);
+ }
+ TK = TE + TJ;
+ T27 = T1y + T1z;
+ {
+ E Tk, Tm, Tj, Tl;
+ Tk = rio[WS(ios, 8)];
+ Tm = iio[-WS(ios, 6)];
+ Tj = W[14];
+ Tl = W[15];
+ Tn = FMA(Tj, Tk, Tl * Tm);
+ T1t = FNMS(Tl, Tk, Tj * Tm);
+ }
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 13)];
+ Tr = iio[-WS(ios, 1)];
+ To = W[24];
+ Tq = W[25];
+ Ts = FMA(To, Tp, Tq * Tr);
+ T1u = FNMS(Tq, Tp, To * Tr);
+ }
+ Tt = Tn + Ts;
+ T22 = T1t + T1u;
+ {
+ E T1s, T1v, T25, T28;
+ Tu = Ti + Tt;
+ TL = Tz + TK;
+ TM = Tu + TL;
+ T2H = T21 + T22;
+ T2I = T26 + T27;
+ T2N = T2H + T2I;
+ T1s = FNMS(KP500000000, Tt, Ti);
+ T1v = KP866025403 * (T1t - T1u);
+ T1w = T1s - T1v;
+ T1Q = T1s + T1v;
+ T25 = KP866025403 * (TJ - TE);
+ T28 = FNMS(KP500000000, T27, T26);
+ T29 = T25 + T28;
+ T2w = T28 - T25;
+ {
+ E T20, T23, T1x, T1A;
+ T20 = KP866025403 * (Ts - Tn);
+ T23 = FNMS(KP500000000, T22, T21);
+ T24 = T20 + T23;
+ T2v = T23 - T20;
+ T1x = FNMS(KP500000000, TK, Tz);
+ T1A = KP866025403 * (T1y - T1z);
+ T1B = T1x - T1A;
+ T1R = T1x + T1A;
+ }
+ }
+ }
+ {
+ E T2C, T1m, T2B, T2K, T2M, T2G, T2J, T2L, T2D;
+ T2C = KP559016994 * (TM - T1l);
+ T1m = TM + T1l;
+ T2B = FNMS(KP250000000, T1m, Td);
+ T2G = T2E - T2F;
+ T2J = T2H - T2I;
+ T2K = FNMS(KP587785252, T2J, KP951056516 * T2G);
+ T2M = FMA(KP951056516, T2J, KP587785252 * T2G);
+ rio[0] = Td + T1m;
+ T2L = T2C + T2B;
+ iio[-WS(ios, 9)] = T2L - T2M;
+ rio[WS(ios, 6)] = T2L + T2M;
+ T2D = T2B - T2C;
+ iio[-WS(ios, 12)] = T2D - T2K;
+ rio[WS(ios, 3)] = T2D + T2K;
+ }
+ {
+ E T2X, T2P, T2W, T2V, T2Z, T2T, T2U, T30, T2Y;
+ T2X = KP559016994 * (T2N - T2O);
+ T2P = T2N + T2O;
+ T2W = FNMS(KP250000000, T2P, T2S);
+ T2T = Tu - TL;
+ T2U = T1k - T13;
+ T2V = FMA(KP587785252, T2T, KP951056516 * T2U);
+ T2Z = FNMS(KP951056516, T2T, KP587785252 * T2U);
+ iio[0] = T2P + T2S;
+ T30 = T2X + T2W;
+ rio[WS(ios, 9)] = T2Z - T30;
+ iio[-WS(ios, 6)] = T2Z + T30;
+ T2Y = T2W - T2X;
+ rio[WS(ios, 12)] = T2V - T2Y;
+ iio[-WS(ios, 3)] = T2V + T2Y;
+ }
+ {
+ E T2y, T2A, T1r, T1O, T2p, T2q, T2z, T2r;
+ {
+ E T2u, T2x, T1C, T1N;
+ T2u = T2s - T2t;
+ T2x = T2v - T2w;
+ T2y = FNMS(KP587785252, T2x, KP951056516 * T2u);
+ T2A = FMA(KP951056516, T2x, KP587785252 * T2u);
+ T1r = T1n - T1q;
+ T1C = T1w + T1B;
+ T1N = T1H + T1M;
+ T1O = T1C + T1N;
+ T2p = FNMS(KP250000000, T1O, T1r);
+ T2q = KP559016994 * (T1C - T1N);
+ }
+ rio[WS(ios, 5)] = T1r + T1O;
+ T2z = T2q + T2p;
+ iio[-WS(ios, 14)] = T2z - T2A;
+ iio[-WS(ios, 11)] = T2z + T2A;
+ T2r = T2p - T2q;
+ rio[WS(ios, 2)] = T2r - T2y;
+ iio[-WS(ios, 8)] = T2r + T2y;
+ }
+ {
+ E T3h, T3p, T3l, T3m, T3k, T3n, T3q, T3o;
+ {
+ E T3f, T3g, T3i, T3j;
+ T3f = T1w - T1B;
+ T3g = T1H - T1M;
+ T3h = FMA(KP951056516, T3f, KP587785252 * T3g);
+ T3p = FNMS(KP587785252, T3f, KP951056516 * T3g);
+ T3l = T35 - T34;
+ T3i = T2s + T2t;
+ T3j = T2v + T2w;
+ T3m = T3j + T3i;
+ T3k = KP559016994 * (T3i - T3j);
+ T3n = FNMS(KP250000000, T3m, T3l);
+ }
+ iio[-WS(ios, 5)] = T3m + T3l;
+ T3q = T3k + T3n;
+ rio[WS(ios, 8)] = T3p - T3q;
+ iio[-WS(ios, 2)] = T3p + T3q;
+ T3o = T3k - T3n;
+ rio[WS(ios, 11)] = T3h + T3o;
+ rio[WS(ios, 14)] = T3o - T3h;
+ }
+ {
+ E T3c, T3d, T36, T33, T37, T38, T3e, T39;
+ {
+ E T3a, T3b, T31, T32;
+ T3a = T1Q - T1R;
+ T3b = T1T - T1U;
+ T3c = FMA(KP951056516, T3a, KP587785252 * T3b);
+ T3d = FNMS(KP587785252, T3a, KP951056516 * T3b);
+ T36 = T34 + T35;
+ T31 = T2k - T2f;
+ T32 = T24 + T29;
+ T33 = T31 - T32;
+ T37 = KP559016994 * (T32 + T31);
+ T38 = FMA(KP250000000, T33, T36);
+ }
+ rio[WS(ios, 10)] = T33 - T36;
+ T3e = T38 - T37;
+ rio[WS(ios, 13)] = T3d - T3e;
+ iio[-WS(ios, 7)] = T3d + T3e;
+ T39 = T37 + T38;
+ iio[-WS(ios, 1)] = T39 - T3c;
+ iio[-WS(ios, 4)] = T3c + T39;
+ }
+ {
+ E T2m, T2o, T1P, T1W, T1X, T1Y, T2n, T1Z;
+ {
+ E T2a, T2l, T1S, T1V;
+ T2a = T24 - T29;
+ T2l = T2f + T2k;
+ T2m = FMA(KP951056516, T2a, KP587785252 * T2l);
+ T2o = FNMS(KP587785252, T2a, KP951056516 * T2l);
+ T1P = T1n + T1q;
+ T1S = T1Q + T1R;
+ T1V = T1T + T1U;
+ T1W = T1S + T1V;
+ T1X = KP559016994 * (T1S - T1V);
+ T1Y = FNMS(KP250000000, T1W, T1P);
+ }
+ iio[-WS(ios, 10)] = T1P + T1W;
+ T2n = T1Y - T1X;
+ rio[WS(ios, 7)] = T2n - T2o;
+ iio[-WS(ios, 13)] = T2n + T2o;
+ T1Z = T1X + T1Y;
+ rio[WS(ios, 4)] = T1Z - T2m;
+ rio[WS(ios, 1)] = T1Z + T2m;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 15},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 15, "hf_15", twinstr, {128, 56, 56, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_15) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_15, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_16.c b/src/fftw3/rdft/codelets/r2hc/hf_16.c
new file mode 100644
index 0000000..ff3145d
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_16.c
@@ -0,0 +1,406 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:07 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 16 -dit -name hf_16 -include hf.h */
+
+/*
+ * This function contains 174 FP additions, 84 FP multiplications,
+ * (or, 136 additions, 46 multiplications, 38 fused multiply/add),
+ * 52 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_16(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 30) {
+ E T7, T37, T1t, T2U, Ti, T38, T1w, T2R, Tu, T2s, T1C, T2c, TF, T2t, T1H;
+ E T2d, TS, T13, T2w, T2x, T2y, T2z, T1O, T2g, T1T, T2h, T1f, T1q, T2B, T2C;
+ E T2D, T2E, T1Z, T2j, T24, T2k;
+ {
+ E T1, T2T, T6, T2S;
+ T1 = rio[0];
+ T2T = iio[-WS(ios, 15)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 8)];
+ T5 = iio[-WS(ios, 7)];
+ T2 = W[14];
+ T4 = W[15];
+ T6 = FMA(T2, T3, T4 * T5);
+ T2S = FNMS(T4, T3, T2 * T5);
+ }
+ T7 = T1 + T6;
+ T37 = T2T - T2S;
+ T1t = T1 - T6;
+ T2U = T2S + T2T;
+ }
+ {
+ E Tc, T1u, Th, T1v;
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 4)];
+ Tb = iio[-WS(ios, 11)];
+ T8 = W[6];
+ Ta = W[7];
+ Tc = FMA(T8, T9, Ta * Tb);
+ T1u = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 12)];
+ Tg = iio[-WS(ios, 3)];
+ Td = W[22];
+ Tf = W[23];
+ Th = FMA(Td, Te, Tf * Tg);
+ T1v = FNMS(Tf, Te, Td * Tg);
+ }
+ Ti = Tc + Th;
+ T38 = Tc - Th;
+ T1w = T1u - T1v;
+ T2R = T1u + T1v;
+ }
+ {
+ E To, T1y, Tt, T1z, T1A, T1B;
+ {
+ E Tl, Tn, Tk, Tm;
+ Tl = rio[WS(ios, 2)];
+ Tn = iio[-WS(ios, 13)];
+ Tk = W[2];
+ Tm = W[3];
+ To = FMA(Tk, Tl, Tm * Tn);
+ T1y = FNMS(Tm, Tl, Tk * Tn);
+ }
+ {
+ E Tq, Ts, Tp, Tr;
+ Tq = rio[WS(ios, 10)];
+ Ts = iio[-WS(ios, 5)];
+ Tp = W[18];
+ Tr = W[19];
+ Tt = FMA(Tp, Tq, Tr * Ts);
+ T1z = FNMS(Tr, Tq, Tp * Ts);
+ }
+ Tu = To + Tt;
+ T2s = T1y + T1z;
+ T1A = T1y - T1z;
+ T1B = To - Tt;
+ T1C = T1A - T1B;
+ T2c = T1B + T1A;
+ }
+ {
+ E Tz, T1E, TE, T1F, T1D, T1G;
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 14)];
+ Ty = iio[-WS(ios, 1)];
+ Tv = W[26];
+ Tx = W[27];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T1E = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 6)];
+ TD = iio[-WS(ios, 9)];
+ TA = W[10];
+ TC = W[11];
+ TE = FMA(TA, TB, TC * TD);
+ T1F = FNMS(TC, TB, TA * TD);
+ }
+ TF = Tz + TE;
+ T2t = T1E + T1F;
+ T1D = Tz - TE;
+ T1G = T1E - T1F;
+ T1H = T1D + T1G;
+ T2d = T1D - T1G;
+ }
+ {
+ E TM, T1K, T12, T1R, TR, T1L, TX, T1Q;
+ {
+ E TJ, TL, TI, TK;
+ TJ = rio[WS(ios, 1)];
+ TL = iio[-WS(ios, 14)];
+ TI = W[0];
+ TK = W[1];
+ TM = FMA(TI, TJ, TK * TL);
+ T1K = FNMS(TK, TJ, TI * TL);
+ }
+ {
+ E TZ, T11, TY, T10;
+ TZ = rio[WS(ios, 13)];
+ T11 = iio[-WS(ios, 2)];
+ TY = W[24];
+ T10 = W[25];
+ T12 = FMA(TY, TZ, T10 * T11);
+ T1R = FNMS(T10, TZ, TY * T11);
+ }
+ {
+ E TO, TQ, TN, TP;
+ TO = rio[WS(ios, 9)];
+ TQ = iio[-WS(ios, 6)];
+ TN = W[16];
+ TP = W[17];
+ TR = FMA(TN, TO, TP * TQ);
+ T1L = FNMS(TP, TO, TN * TQ);
+ }
+ {
+ E TU, TW, TT, TV;
+ TU = rio[WS(ios, 5)];
+ TW = iio[-WS(ios, 10)];
+ TT = W[8];
+ TV = W[9];
+ TX = FMA(TT, TU, TV * TW);
+ T1Q = FNMS(TV, TU, TT * TW);
+ }
+ TS = TM + TR;
+ T13 = TX + T12;
+ T2w = TS - T13;
+ T2x = T1K + T1L;
+ T2y = T1Q + T1R;
+ T2z = T2x - T2y;
+ {
+ E T1M, T1N, T1P, T1S;
+ T1M = T1K - T1L;
+ T1N = TX - T12;
+ T1O = T1M + T1N;
+ T2g = T1M - T1N;
+ T1P = TM - TR;
+ T1S = T1Q - T1R;
+ T1T = T1P - T1S;
+ T2h = T1P + T1S;
+ }
+ }
+ {
+ E T19, T20, T1p, T1X, T1e, T21, T1k, T1W;
+ {
+ E T16, T18, T15, T17;
+ T16 = rio[WS(ios, 15)];
+ T18 = iio[0];
+ T15 = W[28];
+ T17 = W[29];
+ T19 = FMA(T15, T16, T17 * T18);
+ T20 = FNMS(T17, T16, T15 * T18);
+ }
+ {
+ E T1m, T1o, T1l, T1n;
+ T1m = rio[WS(ios, 11)];
+ T1o = iio[-WS(ios, 4)];
+ T1l = W[20];
+ T1n = W[21];
+ T1p = FMA(T1l, T1m, T1n * T1o);
+ T1X = FNMS(T1n, T1m, T1l * T1o);
+ }
+ {
+ E T1b, T1d, T1a, T1c;
+ T1b = rio[WS(ios, 7)];
+ T1d = iio[-WS(ios, 8)];
+ T1a = W[12];
+ T1c = W[13];
+ T1e = FMA(T1a, T1b, T1c * T1d);
+ T21 = FNMS(T1c, T1b, T1a * T1d);
+ }
+ {
+ E T1h, T1j, T1g, T1i;
+ T1h = rio[WS(ios, 3)];
+ T1j = iio[-WS(ios, 12)];
+ T1g = W[4];
+ T1i = W[5];
+ T1k = FMA(T1g, T1h, T1i * T1j);
+ T1W = FNMS(T1i, T1h, T1g * T1j);
+ }
+ T1f = T19 + T1e;
+ T1q = T1k + T1p;
+ T2B = T1f - T1q;
+ T2C = T20 + T21;
+ T2D = T1W + T1X;
+ T2E = T2C - T2D;
+ {
+ E T1V, T1Y, T22, T23;
+ T1V = T19 - T1e;
+ T1Y = T1W - T1X;
+ T1Z = T1V - T1Y;
+ T2j = T1V + T1Y;
+ T22 = T20 - T21;
+ T23 = T1k - T1p;
+ T24 = T22 + T23;
+ T2k = T22 - T23;
+ }
+ }
+ {
+ E T1J, T27, T3g, T3i, T26, T3h, T2a, T3d;
+ {
+ E T1x, T1I, T3e, T3f;
+ T1x = T1t - T1w;
+ T1I = KP707106781 * (T1C - T1H);
+ T1J = T1x + T1I;
+ T27 = T1x - T1I;
+ T3e = KP707106781 * (T2d - T2c);
+ T3f = T38 + T37;
+ T3g = T3e + T3f;
+ T3i = T3f - T3e;
+ }
+ {
+ E T1U, T25, T28, T29;
+ T1U = FMA(KP923879532, T1O, KP382683432 * T1T);
+ T25 = FNMS(KP923879532, T24, KP382683432 * T1Z);
+ T26 = T1U + T25;
+ T3h = T25 - T1U;
+ T28 = FNMS(KP923879532, T1T, KP382683432 * T1O);
+ T29 = FMA(KP382683432, T24, KP923879532 * T1Z);
+ T2a = T28 - T29;
+ T3d = T28 + T29;
+ }
+ iio[-WS(ios, 11)] = T1J - T26;
+ rio[WS(ios, 11)] = T3d - T3g;
+ rio[WS(ios, 3)] = T1J + T26;
+ iio[-WS(ios, 3)] = T3d + T3g;
+ iio[-WS(ios, 15)] = T27 - T2a;
+ rio[WS(ios, 15)] = T3h - T3i;
+ rio[WS(ios, 7)] = T27 + T2a;
+ iio[-WS(ios, 7)] = T3h + T3i;
+ }
+ {
+ E T2v, T2H, T32, T34, T2G, T33, T2K, T2Z;
+ {
+ E T2r, T2u, T30, T31;
+ T2r = T7 - Ti;
+ T2u = T2s - T2t;
+ T2v = T2r + T2u;
+ T2H = T2r - T2u;
+ T30 = TF - Tu;
+ T31 = T2U - T2R;
+ T32 = T30 + T31;
+ T34 = T31 - T30;
+ }
+ {
+ E T2A, T2F, T2I, T2J;
+ T2A = T2w + T2z;
+ T2F = T2B - T2E;
+ T2G = KP707106781 * (T2A + T2F);
+ T33 = KP707106781 * (T2F - T2A);
+ T2I = T2z - T2w;
+ T2J = T2B + T2E;
+ T2K = KP707106781 * (T2I - T2J);
+ T2Z = KP707106781 * (T2I + T2J);
+ }
+ iio[-WS(ios, 10)] = T2v - T2G;
+ rio[WS(ios, 10)] = T2Z - T32;
+ rio[WS(ios, 2)] = T2v + T2G;
+ iio[-WS(ios, 2)] = T2Z + T32;
+ iio[-WS(ios, 14)] = T2H - T2K;
+ rio[WS(ios, 14)] = T33 - T34;
+ rio[WS(ios, 6)] = T2H + T2K;
+ iio[-WS(ios, 6)] = T33 + T34;
+ }
+ {
+ E T2f, T2n, T3a, T3c, T2m, T3b, T2q, T35;
+ {
+ E T2b, T2e, T36, T39;
+ T2b = T1t + T1w;
+ T2e = KP707106781 * (T2c + T2d);
+ T2f = T2b + T2e;
+ T2n = T2b - T2e;
+ T36 = KP707106781 * (T1C + T1H);
+ T39 = T37 - T38;
+ T3a = T36 + T39;
+ T3c = T39 - T36;
+ }
+ {
+ E T2i, T2l, T2o, T2p;
+ T2i = FMA(KP382683432, T2g, KP923879532 * T2h);
+ T2l = FNMS(KP382683432, T2k, KP923879532 * T2j);
+ T2m = T2i + T2l;
+ T3b = T2l - T2i;
+ T2o = FNMS(KP382683432, T2h, KP923879532 * T2g);
+ T2p = FMA(KP923879532, T2k, KP382683432 * T2j);
+ T2q = T2o - T2p;
+ T35 = T2o + T2p;
+ }
+ iio[-WS(ios, 9)] = T2f - T2m;
+ rio[WS(ios, 9)] = T35 - T3a;
+ rio[WS(ios, 1)] = T2f + T2m;
+ iio[-WS(ios, 1)] = T35 + T3a;
+ iio[-WS(ios, 13)] = T2n - T2q;
+ rio[WS(ios, 13)] = T3b - T3c;
+ rio[WS(ios, 5)] = T2n + T2q;
+ iio[-WS(ios, 5)] = T3b + T3c;
+ }
+ {
+ E TH, T2L, T2W, T2Y, T1s, T2X, T2O, T2P;
+ {
+ E Tj, TG, T2Q, T2V;
+ Tj = T7 + Ti;
+ TG = Tu + TF;
+ TH = Tj + TG;
+ T2L = Tj - TG;
+ T2Q = T2s + T2t;
+ T2V = T2R + T2U;
+ T2W = T2Q + T2V;
+ T2Y = T2V - T2Q;
+ }
+ {
+ E T14, T1r, T2M, T2N;
+ T14 = TS + T13;
+ T1r = T1f + T1q;
+ T1s = T14 + T1r;
+ T2X = T1r - T14;
+ T2M = T2x + T2y;
+ T2N = T2C + T2D;
+ T2O = T2M - T2N;
+ T2P = T2M + T2N;
+ }
+ iio[-WS(ios, 8)] = TH - T1s;
+ rio[WS(ios, 8)] = T2P - T2W;
+ rio[0] = TH + T1s;
+ iio[0] = T2P + T2W;
+ iio[-WS(ios, 12)] = T2L - T2O;
+ rio[WS(ios, 12)] = T2X - T2Y;
+ rio[WS(ios, 4)] = T2L + T2O;
+ iio[-WS(ios, 4)] = T2X + T2Y;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 16},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 16, "hf_16", twinstr, {136, 46, 38, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_16) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_16, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_2.c b/src/fftw3/rdft/codelets/r2hc/hf_2.c
new file mode 100644
index 0000000..7de094c
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_2.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:51 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 2 -dit -name hf_2 -include hf.h */
+
+/*
+ * This function contains 6 FP additions, 4 FP multiplications,
+ * (or, 4 additions, 2 multiplications, 2 fused multiply/add),
+ * 9 stack variables, and 8 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_2(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 2) {
+ E T1, T8, T6, T7;
+ T1 = rio[0];
+ T8 = iio[-WS(ios, 1)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 1)];
+ T5 = iio[0];
+ T2 = W[0];
+ T4 = W[1];
+ T6 = FMA(T2, T3, T4 * T5);
+ T7 = FNMS(T4, T3, T2 * T5);
+ }
+ iio[-WS(ios, 1)] = T1 - T6;
+ rio[WS(ios, 1)] = T7 - T8;
+ rio[0] = T1 + T6;
+ iio[0] = T7 + T8;
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 2},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 2, "hf_2", twinstr, {4, 2, 2, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_2) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_2, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_3.c b/src/fftw3/rdft/codelets/r2hc/hf_3.c
new file mode 100644
index 0000000..fce963f
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_3.c
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:51 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 3 -dit -name hf_3 -include hf.h */
+
+/*
+ * This function contains 16 FP additions, 12 FP multiplications,
+ * (or, 10 additions, 6 multiplications, 6 fused multiply/add),
+ * 15 stack variables, and 12 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_3(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 4) {
+ E T1, Ti, T6, Te, Tb, Tf, Tc, Th;
+ T1 = rio[0];
+ Ti = iio[-WS(ios, 2)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 1)];
+ T5 = iio[-WS(ios, 1)];
+ T2 = W[0];
+ T4 = W[1];
+ T6 = FMA(T2, T3, T4 * T5);
+ Te = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 2)];
+ Ta = iio[0];
+ T7 = W[2];
+ T9 = W[3];
+ Tb = FMA(T7, T8, T9 * Ta);
+ Tf = FNMS(T9, T8, T7 * Ta);
+ }
+ Tc = T6 + Tb;
+ Th = Te + Tf;
+ rio[0] = T1 + Tc;
+ iio[0] = Th + Ti;
+ {
+ E Td, Tg, Tj, Tk;
+ Td = FNMS(KP500000000, Tc, T1);
+ Tg = KP866025403 * (Te - Tf);
+ iio[-WS(ios, 2)] = Td - Tg;
+ rio[WS(ios, 1)] = Td + Tg;
+ Tj = KP866025403 * (Tb - T6);
+ Tk = FNMS(KP500000000, Th, Ti);
+ rio[WS(ios, 2)] = Tj - Tk;
+ iio[-WS(ios, 1)] = Tj + Tk;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 3},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 3, "hf_3", twinstr, {10, 6, 6, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_3) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_3, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_32.c b/src/fftw3/rdft/codelets/r2hc/hf_32.c
new file mode 100644
index 0000000..262ef43
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_32.c
@@ -0,0 +1,892 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:08 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 32 -dit -name hf_32 -include hf.h */
+
+/*
+ * This function contains 434 FP additions, 208 FP multiplications,
+ * (or, 340 additions, 114 multiplications, 94 fused multiply/add),
+ * 96 stack variables, and 128 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_32(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 62) {
+ E Tj, T5F, T7C, T7Q, T35, T4T, T78, T7m, T2B, T67, T6e, T6O, T4b, T5d, T4s;
+ E T5g, TG, T7l, T5I, T73, T3a, T4U, T3f, T4V, T1Q, T61, T5Y, T6J, T3K, T59;
+ E T41, T56, T1r, T5P, T5S, T6F, T3x, T51, T3C, T52, T14, T5N, T5M, T6E, T3m;
+ E T4Y, T3r, T4Z, T2d, T5Z, T64, T6K, T3V, T57, T44, T5a, T2Y, T6f, T6a, T6P;
+ E T4m, T5h, T4v, T5e;
+ {
+ E T1, T76, T6, T75, Tc, T32, Th, T33;
+ T1 = rio[0];
+ T76 = iio[-WS(ios, 31)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 16)];
+ T5 = iio[-WS(ios, 15)];
+ T2 = W[30];
+ T4 = W[31];
+ T6 = FMA(T2, T3, T4 * T5);
+ T75 = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 8)];
+ Tb = iio[-WS(ios, 23)];
+ T8 = W[14];
+ Ta = W[15];
+ Tc = FMA(T8, T9, Ta * Tb);
+ T32 = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 24)];
+ Tg = iio[-WS(ios, 7)];
+ Td = W[46];
+ Tf = W[47];
+ Th = FMA(Td, Te, Tf * Tg);
+ T33 = FNMS(Tf, Te, Td * Tg);
+ }
+ {
+ E T7, Ti, T7A, T7B;
+ T7 = T1 + T6;
+ Ti = Tc + Th;
+ Tj = T7 + Ti;
+ T5F = T7 - Ti;
+ T7A = T76 - T75;
+ T7B = Tc - Th;
+ T7C = T7A - T7B;
+ T7Q = T7B + T7A;
+ }
+ {
+ E T31, T34, T74, T77;
+ T31 = T1 - T6;
+ T34 = T32 - T33;
+ T35 = T31 - T34;
+ T4T = T31 + T34;
+ T74 = T32 + T33;
+ T77 = T75 + T76;
+ T78 = T74 + T77;
+ T7m = T77 - T74;
+ }
+ }
+ {
+ E T2j, T4o, T2z, T49, T2o, T4p, T2u, T48;
+ {
+ E T2g, T2i, T2f, T2h;
+ T2g = rio[WS(ios, 31)];
+ T2i = iio[0];
+ T2f = W[60];
+ T2h = W[61];
+ T2j = FMA(T2f, T2g, T2h * T2i);
+ T4o = FNMS(T2h, T2g, T2f * T2i);
+ }
+ {
+ E T2w, T2y, T2v, T2x;
+ T2w = rio[WS(ios, 23)];
+ T2y = iio[-WS(ios, 8)];
+ T2v = W[44];
+ T2x = W[45];
+ T2z = FMA(T2v, T2w, T2x * T2y);
+ T49 = FNMS(T2x, T2w, T2v * T2y);
+ }
+ {
+ E T2l, T2n, T2k, T2m;
+ T2l = rio[WS(ios, 15)];
+ T2n = iio[-WS(ios, 16)];
+ T2k = W[28];
+ T2m = W[29];
+ T2o = FMA(T2k, T2l, T2m * T2n);
+ T4p = FNMS(T2m, T2l, T2k * T2n);
+ }
+ {
+ E T2r, T2t, T2q, T2s;
+ T2r = rio[WS(ios, 7)];
+ T2t = iio[-WS(ios, 24)];
+ T2q = W[12];
+ T2s = W[13];
+ T2u = FMA(T2q, T2r, T2s * T2t);
+ T48 = FNMS(T2s, T2r, T2q * T2t);
+ }
+ {
+ E T2p, T2A, T6c, T6d;
+ T2p = T2j + T2o;
+ T2A = T2u + T2z;
+ T2B = T2p + T2A;
+ T67 = T2p - T2A;
+ T6c = T4o + T4p;
+ T6d = T48 + T49;
+ T6e = T6c - T6d;
+ T6O = T6c + T6d;
+ }
+ {
+ E T47, T4a, T4q, T4r;
+ T47 = T2j - T2o;
+ T4a = T48 - T49;
+ T4b = T47 - T4a;
+ T5d = T47 + T4a;
+ T4q = T4o - T4p;
+ T4r = T2u - T2z;
+ T4s = T4q + T4r;
+ T5g = T4q - T4r;
+ }
+ }
+ {
+ E To, T36, TE, T3d, Tt, T37, Tz, T3c;
+ {
+ E Tl, Tn, Tk, Tm;
+ Tl = rio[WS(ios, 4)];
+ Tn = iio[-WS(ios, 27)];
+ Tk = W[6];
+ Tm = W[7];
+ To = FMA(Tk, Tl, Tm * Tn);
+ T36 = FNMS(Tm, Tl, Tk * Tn);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 12)];
+ TD = iio[-WS(ios, 19)];
+ TA = W[22];
+ TC = W[23];
+ TE = FMA(TA, TB, TC * TD);
+ T3d = FNMS(TC, TB, TA * TD);
+ }
+ {
+ E Tq, Ts, Tp, Tr;
+ Tq = rio[WS(ios, 20)];
+ Ts = iio[-WS(ios, 11)];
+ Tp = W[38];
+ Tr = W[39];
+ Tt = FMA(Tp, Tq, Tr * Ts);
+ T37 = FNMS(Tr, Tq, Tp * Ts);
+ }
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 28)];
+ Ty = iio[-WS(ios, 3)];
+ Tv = W[54];
+ Tx = W[55];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T3c = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E Tu, TF, T5G, T5H;
+ Tu = To + Tt;
+ TF = Tz + TE;
+ TG = Tu + TF;
+ T7l = TF - Tu;
+ T5G = T36 + T37;
+ T5H = T3c + T3d;
+ T5I = T5G - T5H;
+ T73 = T5G + T5H;
+ }
+ {
+ E T38, T39, T3b, T3e;
+ T38 = T36 - T37;
+ T39 = To - Tt;
+ T3a = T38 - T39;
+ T4U = T39 + T38;
+ T3b = Tz - TE;
+ T3e = T3c - T3d;
+ T3f = T3b + T3e;
+ T4V = T3b - T3e;
+ }
+ }
+ {
+ E T1y, T3G, T1O, T3Z, T1D, T3H, T1J, T3Y;
+ {
+ E T1v, T1x, T1u, T1w;
+ T1v = rio[WS(ios, 1)];
+ T1x = iio[-WS(ios, 30)];
+ T1u = W[0];
+ T1w = W[1];
+ T1y = FMA(T1u, T1v, T1w * T1x);
+ T3G = FNMS(T1w, T1v, T1u * T1x);
+ }
+ {
+ E T1L, T1N, T1K, T1M;
+ T1L = rio[WS(ios, 25)];
+ T1N = iio[-WS(ios, 6)];
+ T1K = W[48];
+ T1M = W[49];
+ T1O = FMA(T1K, T1L, T1M * T1N);
+ T3Z = FNMS(T1M, T1L, T1K * T1N);
+ }
+ {
+ E T1A, T1C, T1z, T1B;
+ T1A = rio[WS(ios, 17)];
+ T1C = iio[-WS(ios, 14)];
+ T1z = W[32];
+ T1B = W[33];
+ T1D = FMA(T1z, T1A, T1B * T1C);
+ T3H = FNMS(T1B, T1A, T1z * T1C);
+ }
+ {
+ E T1G, T1I, T1F, T1H;
+ T1G = rio[WS(ios, 9)];
+ T1I = iio[-WS(ios, 22)];
+ T1F = W[16];
+ T1H = W[17];
+ T1J = FMA(T1F, T1G, T1H * T1I);
+ T3Y = FNMS(T1H, T1G, T1F * T1I);
+ }
+ {
+ E T1E, T1P, T5W, T5X;
+ T1E = T1y + T1D;
+ T1P = T1J + T1O;
+ T1Q = T1E + T1P;
+ T61 = T1E - T1P;
+ T5W = T3G + T3H;
+ T5X = T3Y + T3Z;
+ T5Y = T5W - T5X;
+ T6J = T5W + T5X;
+ }
+ {
+ E T3I, T3J, T3X, T40;
+ T3I = T3G - T3H;
+ T3J = T1J - T1O;
+ T3K = T3I + T3J;
+ T59 = T3I - T3J;
+ T3X = T1y - T1D;
+ T40 = T3Y - T3Z;
+ T41 = T3X - T40;
+ T56 = T3X + T40;
+ }
+ }
+ {
+ E T19, T3t, T1p, T3A, T1e, T3u, T1k, T3z;
+ {
+ E T16, T18, T15, T17;
+ T16 = rio[WS(ios, 30)];
+ T18 = iio[-WS(ios, 1)];
+ T15 = W[58];
+ T17 = W[59];
+ T19 = FMA(T15, T16, T17 * T18);
+ T3t = FNMS(T17, T16, T15 * T18);
+ }
+ {
+ E T1m, T1o, T1l, T1n;
+ T1m = rio[WS(ios, 22)];
+ T1o = iio[-WS(ios, 9)];
+ T1l = W[42];
+ T1n = W[43];
+ T1p = FMA(T1l, T1m, T1n * T1o);
+ T3A = FNMS(T1n, T1m, T1l * T1o);
+ }
+ {
+ E T1b, T1d, T1a, T1c;
+ T1b = rio[WS(ios, 14)];
+ T1d = iio[-WS(ios, 17)];
+ T1a = W[26];
+ T1c = W[27];
+ T1e = FMA(T1a, T1b, T1c * T1d);
+ T3u = FNMS(T1c, T1b, T1a * T1d);
+ }
+ {
+ E T1h, T1j, T1g, T1i;
+ T1h = rio[WS(ios, 6)];
+ T1j = iio[-WS(ios, 25)];
+ T1g = W[10];
+ T1i = W[11];
+ T1k = FMA(T1g, T1h, T1i * T1j);
+ T3z = FNMS(T1i, T1h, T1g * T1j);
+ }
+ {
+ E T1f, T1q, T5Q, T5R;
+ T1f = T19 + T1e;
+ T1q = T1k + T1p;
+ T1r = T1f + T1q;
+ T5P = T1f - T1q;
+ T5Q = T3t + T3u;
+ T5R = T3z + T3A;
+ T5S = T5Q - T5R;
+ T6F = T5Q + T5R;
+ }
+ {
+ E T3v, T3w, T3y, T3B;
+ T3v = T3t - T3u;
+ T3w = T1k - T1p;
+ T3x = T3v + T3w;
+ T51 = T3v - T3w;
+ T3y = T19 - T1e;
+ T3B = T3z - T3A;
+ T3C = T3y - T3B;
+ T52 = T3y + T3B;
+ }
+ }
+ {
+ E TM, T3i, T12, T3p, TR, T3j, TX, T3o;
+ {
+ E TJ, TL, TI, TK;
+ TJ = rio[WS(ios, 2)];
+ TL = iio[-WS(ios, 29)];
+ TI = W[2];
+ TK = W[3];
+ TM = FMA(TI, TJ, TK * TL);
+ T3i = FNMS(TK, TJ, TI * TL);
+ }
+ {
+ E TZ, T11, TY, T10;
+ TZ = rio[WS(ios, 26)];
+ T11 = iio[-WS(ios, 5)];
+ TY = W[50];
+ T10 = W[51];
+ T12 = FMA(TY, TZ, T10 * T11);
+ T3p = FNMS(T10, TZ, TY * T11);
+ }
+ {
+ E TO, TQ, TN, TP;
+ TO = rio[WS(ios, 18)];
+ TQ = iio[-WS(ios, 13)];
+ TN = W[34];
+ TP = W[35];
+ TR = FMA(TN, TO, TP * TQ);
+ T3j = FNMS(TP, TO, TN * TQ);
+ }
+ {
+ E TU, TW, TT, TV;
+ TU = rio[WS(ios, 10)];
+ TW = iio[-WS(ios, 21)];
+ TT = W[18];
+ TV = W[19];
+ TX = FMA(TT, TU, TV * TW);
+ T3o = FNMS(TV, TU, TT * TW);
+ }
+ {
+ E TS, T13, T5K, T5L;
+ TS = TM + TR;
+ T13 = TX + T12;
+ T14 = TS + T13;
+ T5N = TS - T13;
+ T5K = T3i + T3j;
+ T5L = T3o + T3p;
+ T5M = T5K - T5L;
+ T6E = T5K + T5L;
+ }
+ {
+ E T3k, T3l, T3n, T3q;
+ T3k = T3i - T3j;
+ T3l = TX - T12;
+ T3m = T3k + T3l;
+ T4Y = T3k - T3l;
+ T3n = TM - TR;
+ T3q = T3o - T3p;
+ T3r = T3n - T3q;
+ T4Z = T3n + T3q;
+ }
+ }
+ {
+ E T1V, T3R, T20, T3S, T3Q, T3T, T26, T3M, T2b, T3N, T3L, T3O;
+ {
+ E T1S, T1U, T1R, T1T;
+ T1S = rio[WS(ios, 5)];
+ T1U = iio[-WS(ios, 26)];
+ T1R = W[8];
+ T1T = W[9];
+ T1V = FMA(T1R, T1S, T1T * T1U);
+ T3R = FNMS(T1T, T1S, T1R * T1U);
+ }
+ {
+ E T1X, T1Z, T1W, T1Y;
+ T1X = rio[WS(ios, 21)];
+ T1Z = iio[-WS(ios, 10)];
+ T1W = W[40];
+ T1Y = W[41];
+ T20 = FMA(T1W, T1X, T1Y * T1Z);
+ T3S = FNMS(T1Y, T1X, T1W * T1Z);
+ }
+ T3Q = T1V - T20;
+ T3T = T3R - T3S;
+ {
+ E T23, T25, T22, T24;
+ T23 = rio[WS(ios, 29)];
+ T25 = iio[-WS(ios, 2)];
+ T22 = W[56];
+ T24 = W[57];
+ T26 = FMA(T22, T23, T24 * T25);
+ T3M = FNMS(T24, T23, T22 * T25);
+ }
+ {
+ E T28, T2a, T27, T29;
+ T28 = rio[WS(ios, 13)];
+ T2a = iio[-WS(ios, 18)];
+ T27 = W[24];
+ T29 = W[25];
+ T2b = FMA(T27, T28, T29 * T2a);
+ T3N = FNMS(T29, T28, T27 * T2a);
+ }
+ T3L = T26 - T2b;
+ T3O = T3M - T3N;
+ {
+ E T21, T2c, T62, T63;
+ T21 = T1V + T20;
+ T2c = T26 + T2b;
+ T2d = T21 + T2c;
+ T5Z = T2c - T21;
+ T62 = T3R + T3S;
+ T63 = T3M + T3N;
+ T64 = T62 - T63;
+ T6K = T62 + T63;
+ }
+ {
+ E T3P, T3U, T42, T43;
+ T3P = T3L - T3O;
+ T3U = T3Q + T3T;
+ T3V = KP707106781 * (T3P - T3U);
+ T57 = KP707106781 * (T3U + T3P);
+ T42 = T3T - T3Q;
+ T43 = T3L + T3O;
+ T44 = KP707106781 * (T42 - T43);
+ T5a = KP707106781 * (T42 + T43);
+ }
+ }
+ {
+ E T2G, T4c, T2L, T4d, T4e, T4f, T2R, T4i, T2W, T4j, T4h, T4k;
+ {
+ E T2D, T2F, T2C, T2E;
+ T2D = rio[WS(ios, 3)];
+ T2F = iio[-WS(ios, 28)];
+ T2C = W[4];
+ T2E = W[5];
+ T2G = FMA(T2C, T2D, T2E * T2F);
+ T4c = FNMS(T2E, T2D, T2C * T2F);
+ }
+ {
+ E T2I, T2K, T2H, T2J;
+ T2I = rio[WS(ios, 19)];
+ T2K = iio[-WS(ios, 12)];
+ T2H = W[36];
+ T2J = W[37];
+ T2L = FMA(T2H, T2I, T2J * T2K);
+ T4d = FNMS(T2J, T2I, T2H * T2K);
+ }
+ T4e = T4c - T4d;
+ T4f = T2G - T2L;
+ {
+ E T2O, T2Q, T2N, T2P;
+ T2O = rio[WS(ios, 27)];
+ T2Q = iio[-WS(ios, 4)];
+ T2N = W[52];
+ T2P = W[53];
+ T2R = FMA(T2N, T2O, T2P * T2Q);
+ T4i = FNMS(T2P, T2O, T2N * T2Q);
+ }
+ {
+ E T2T, T2V, T2S, T2U;
+ T2T = rio[WS(ios, 11)];
+ T2V = iio[-WS(ios, 20)];
+ T2S = W[20];
+ T2U = W[21];
+ T2W = FMA(T2S, T2T, T2U * T2V);
+ T4j = FNMS(T2U, T2T, T2S * T2V);
+ }
+ T4h = T2R - T2W;
+ T4k = T4i - T4j;
+ {
+ E T2M, T2X, T68, T69;
+ T2M = T2G + T2L;
+ T2X = T2R + T2W;
+ T2Y = T2M + T2X;
+ T6f = T2X - T2M;
+ T68 = T4c + T4d;
+ T69 = T4i + T4j;
+ T6a = T68 - T69;
+ T6P = T68 + T69;
+ }
+ {
+ E T4g, T4l, T4t, T4u;
+ T4g = T4e - T4f;
+ T4l = T4h + T4k;
+ T4m = KP707106781 * (T4g - T4l);
+ T5h = KP707106781 * (T4g + T4l);
+ T4t = T4h - T4k;
+ T4u = T4f + T4e;
+ T4v = KP707106781 * (T4t - T4u);
+ T5e = KP707106781 * (T4u + T4t);
+ }
+ }
+ {
+ E T1t, T6X, T7a, T7c, T30, T7b, T70, T71;
+ {
+ E TH, T1s, T72, T79;
+ TH = Tj + TG;
+ T1s = T14 + T1r;
+ T1t = TH + T1s;
+ T6X = TH - T1s;
+ T72 = T6E + T6F;
+ T79 = T73 + T78;
+ T7a = T72 + T79;
+ T7c = T79 - T72;
+ }
+ {
+ E T2e, T2Z, T6Y, T6Z;
+ T2e = T1Q + T2d;
+ T2Z = T2B + T2Y;
+ T30 = T2e + T2Z;
+ T7b = T2Z - T2e;
+ T6Y = T6J + T6K;
+ T6Z = T6O + T6P;
+ T70 = T6Y - T6Z;
+ T71 = T6Y + T6Z;
+ }
+ iio[-WS(ios, 16)] = T1t - T30;
+ rio[WS(ios, 16)] = T71 - T7a;
+ rio[0] = T1t + T30;
+ iio[0] = T71 + T7a;
+ iio[-WS(ios, 24)] = T6X - T70;
+ rio[WS(ios, 24)] = T7b - T7c;
+ rio[WS(ios, 8)] = T6X + T70;
+ iio[-WS(ios, 8)] = T7b + T7c;
+ }
+ {
+ E T6H, T6T, T7g, T7i, T6M, T6U, T6R, T6V;
+ {
+ E T6D, T6G, T7e, T7f;
+ T6D = Tj - TG;
+ T6G = T6E - T6F;
+ T6H = T6D + T6G;
+ T6T = T6D - T6G;
+ T7e = T1r - T14;
+ T7f = T78 - T73;
+ T7g = T7e + T7f;
+ T7i = T7f - T7e;
+ }
+ {
+ E T6I, T6L, T6N, T6Q;
+ T6I = T1Q - T2d;
+ T6L = T6J - T6K;
+ T6M = T6I + T6L;
+ T6U = T6L - T6I;
+ T6N = T2B - T2Y;
+ T6Q = T6O - T6P;
+ T6R = T6N - T6Q;
+ T6V = T6N + T6Q;
+ }
+ {
+ E T6S, T7d, T6W, T7h;
+ T6S = KP707106781 * (T6M + T6R);
+ iio[-WS(ios, 20)] = T6H - T6S;
+ rio[WS(ios, 4)] = T6H + T6S;
+ T7d = KP707106781 * (T6U + T6V);
+ rio[WS(ios, 20)] = T7d - T7g;
+ iio[-WS(ios, 4)] = T7d + T7g;
+ T6W = KP707106781 * (T6U - T6V);
+ iio[-WS(ios, 28)] = T6T - T6W;
+ rio[WS(ios, 12)] = T6T + T6W;
+ T7h = KP707106781 * (T6R - T6M);
+ rio[WS(ios, 28)] = T7h - T7i;
+ iio[-WS(ios, 12)] = T7h + T7i;
+ }
+ }
+ {
+ E T5J, T7n, T7t, T6n, T5U, T7k, T6x, T6B, T6q, T7s, T66, T6k, T6u, T6A, T6h;
+ E T6l;
+ {
+ E T5O, T5T, T60, T65;
+ T5J = T5F - T5I;
+ T7n = T7l + T7m;
+ T7t = T7m - T7l;
+ T6n = T5F + T5I;
+ T5O = T5M - T5N;
+ T5T = T5P + T5S;
+ T5U = KP707106781 * (T5O - T5T);
+ T7k = KP707106781 * (T5O + T5T);
+ {
+ E T6v, T6w, T6o, T6p;
+ T6v = T67 + T6a;
+ T6w = T6e + T6f;
+ T6x = FNMS(KP382683432, T6w, KP923879532 * T6v);
+ T6B = FMA(KP923879532, T6w, KP382683432 * T6v);
+ T6o = T5N + T5M;
+ T6p = T5P - T5S;
+ T6q = KP707106781 * (T6o + T6p);
+ T7s = KP707106781 * (T6p - T6o);
+ }
+ T60 = T5Y - T5Z;
+ T65 = T61 - T64;
+ T66 = FMA(KP923879532, T60, KP382683432 * T65);
+ T6k = FNMS(KP923879532, T65, KP382683432 * T60);
+ {
+ E T6s, T6t, T6b, T6g;
+ T6s = T5Y + T5Z;
+ T6t = T61 + T64;
+ T6u = FMA(KP382683432, T6s, KP923879532 * T6t);
+ T6A = FNMS(KP382683432, T6t, KP923879532 * T6s);
+ T6b = T67 - T6a;
+ T6g = T6e - T6f;
+ T6h = FNMS(KP923879532, T6g, KP382683432 * T6b);
+ T6l = FMA(KP382683432, T6g, KP923879532 * T6b);
+ }
+ }
+ {
+ E T5V, T6i, T7r, T7u;
+ T5V = T5J + T5U;
+ T6i = T66 + T6h;
+ iio[-WS(ios, 22)] = T5V - T6i;
+ rio[WS(ios, 6)] = T5V + T6i;
+ T7r = T6k + T6l;
+ T7u = T7s + T7t;
+ rio[WS(ios, 22)] = T7r - T7u;
+ iio[-WS(ios, 6)] = T7r + T7u;
+ }
+ {
+ E T6j, T6m, T7v, T7w;
+ T6j = T5J - T5U;
+ T6m = T6k - T6l;
+ iio[-WS(ios, 30)] = T6j - T6m;
+ rio[WS(ios, 14)] = T6j + T6m;
+ T7v = T6h - T66;
+ T7w = T7t - T7s;
+ rio[WS(ios, 30)] = T7v - T7w;
+ iio[-WS(ios, 14)] = T7v + T7w;
+ }
+ {
+ E T6r, T6y, T7j, T7o;
+ T6r = T6n + T6q;
+ T6y = T6u + T6x;
+ iio[-WS(ios, 18)] = T6r - T6y;
+ rio[WS(ios, 2)] = T6r + T6y;
+ T7j = T6A + T6B;
+ T7o = T7k + T7n;
+ rio[WS(ios, 18)] = T7j - T7o;
+ iio[-WS(ios, 2)] = T7j + T7o;
+ }
+ {
+ E T6z, T6C, T7p, T7q;
+ T6z = T6n - T6q;
+ T6C = T6A - T6B;
+ iio[-WS(ios, 26)] = T6z - T6C;
+ rio[WS(ios, 10)] = T6z + T6C;
+ T7p = T6x - T6u;
+ T7q = T7n - T7k;
+ rio[WS(ios, 26)] = T7p - T7q;
+ iio[-WS(ios, 10)] = T7p + T7q;
+ }
+ }
+ {
+ E T3h, T4D, T7R, T7X, T3E, T7O, T4N, T4R, T46, T4A, T4G, T7W, T4K, T4Q, T4x;
+ E T4B, T3g, T7P;
+ T3g = KP707106781 * (T3a - T3f);
+ T3h = T35 - T3g;
+ T4D = T35 + T3g;
+ T7P = KP707106781 * (T4V - T4U);
+ T7R = T7P + T7Q;
+ T7X = T7Q - T7P;
+ {
+ E T3s, T3D, T4L, T4M;
+ T3s = FNMS(KP923879532, T3r, KP382683432 * T3m);
+ T3D = FMA(KP382683432, T3x, KP923879532 * T3C);
+ T3E = T3s - T3D;
+ T7O = T3s + T3D;
+ T4L = T4b + T4m;
+ T4M = T4s + T4v;
+ T4N = FNMS(KP555570233, T4M, KP831469612 * T4L);
+ T4R = FMA(KP831469612, T4M, KP555570233 * T4L);
+ }
+ {
+ E T3W, T45, T4E, T4F;
+ T3W = T3K - T3V;
+ T45 = T41 - T44;
+ T46 = FMA(KP980785280, T3W, KP195090322 * T45);
+ T4A = FNMS(KP980785280, T45, KP195090322 * T3W);
+ T4E = FMA(KP923879532, T3m, KP382683432 * T3r);
+ T4F = FNMS(KP923879532, T3x, KP382683432 * T3C);
+ T4G = T4E + T4F;
+ T7W = T4F - T4E;
+ }
+ {
+ E T4I, T4J, T4n, T4w;
+ T4I = T3K + T3V;
+ T4J = T41 + T44;
+ T4K = FMA(KP555570233, T4I, KP831469612 * T4J);
+ T4Q = FNMS(KP555570233, T4J, KP831469612 * T4I);
+ T4n = T4b - T4m;
+ T4w = T4s - T4v;
+ T4x = FNMS(KP980785280, T4w, KP195090322 * T4n);
+ T4B = FMA(KP195090322, T4w, KP980785280 * T4n);
+ }
+ {
+ E T3F, T4y, T7V, T7Y;
+ T3F = T3h + T3E;
+ T4y = T46 + T4x;
+ iio[-WS(ios, 23)] = T3F - T4y;
+ rio[WS(ios, 7)] = T3F + T4y;
+ T7V = T4A + T4B;
+ T7Y = T7W + T7X;
+ rio[WS(ios, 23)] = T7V - T7Y;
+ iio[-WS(ios, 7)] = T7V + T7Y;
+ }
+ {
+ E T4z, T4C, T7Z, T80;
+ T4z = T3h - T3E;
+ T4C = T4A - T4B;
+ iio[-WS(ios, 31)] = T4z - T4C;
+ rio[WS(ios, 15)] = T4z + T4C;
+ T7Z = T4x - T46;
+ T80 = T7X - T7W;
+ rio[WS(ios, 31)] = T7Z - T80;
+ iio[-WS(ios, 15)] = T7Z + T80;
+ }
+ {
+ E T4H, T4O, T7N, T7S;
+ T4H = T4D + T4G;
+ T4O = T4K + T4N;
+ iio[-WS(ios, 19)] = T4H - T4O;
+ rio[WS(ios, 3)] = T4H + T4O;
+ T7N = T4Q + T4R;
+ T7S = T7O + T7R;
+ rio[WS(ios, 19)] = T7N - T7S;
+ iio[-WS(ios, 3)] = T7N + T7S;
+ }
+ {
+ E T4P, T4S, T7T, T7U;
+ T4P = T4D - T4G;
+ T4S = T4Q - T4R;
+ iio[-WS(ios, 27)] = T4P - T4S;
+ rio[WS(ios, 11)] = T4P + T4S;
+ T7T = T4N - T4K;
+ T7U = T7R - T7O;
+ rio[WS(ios, 27)] = T7T - T7U;
+ iio[-WS(ios, 11)] = T7T + T7U;
+ }
+ }
+ {
+ E T4X, T5p, T7D, T7J, T54, T7y, T5z, T5D, T5c, T5m, T5s, T7I, T5w, T5C, T5j;
+ E T5n, T4W, T7z;
+ T4W = KP707106781 * (T4U + T4V);
+ T4X = T4T - T4W;
+ T5p = T4T + T4W;
+ T7z = KP707106781 * (T3a + T3f);
+ T7D = T7z + T7C;
+ T7J = T7C - T7z;
+ {
+ E T50, T53, T5x, T5y;
+ T50 = FNMS(KP382683432, T4Z, KP923879532 * T4Y);
+ T53 = FMA(KP923879532, T51, KP382683432 * T52);
+ T54 = T50 - T53;
+ T7y = T50 + T53;
+ T5x = T5d + T5e;
+ T5y = T5g + T5h;
+ T5z = FNMS(KP195090322, T5y, KP980785280 * T5x);
+ T5D = FMA(KP195090322, T5x, KP980785280 * T5y);
+ }
+ {
+ E T58, T5b, T5q, T5r;
+ T58 = T56 - T57;
+ T5b = T59 - T5a;
+ T5c = FMA(KP555570233, T58, KP831469612 * T5b);
+ T5m = FNMS(KP831469612, T58, KP555570233 * T5b);
+ T5q = FMA(KP382683432, T4Y, KP923879532 * T4Z);
+ T5r = FNMS(KP382683432, T51, KP923879532 * T52);
+ T5s = T5q + T5r;
+ T7I = T5r - T5q;
+ }
+ {
+ E T5u, T5v, T5f, T5i;
+ T5u = T56 + T57;
+ T5v = T59 + T5a;
+ T5w = FMA(KP980785280, T5u, KP195090322 * T5v);
+ T5C = FNMS(KP195090322, T5u, KP980785280 * T5v);
+ T5f = T5d - T5e;
+ T5i = T5g - T5h;
+ T5j = FNMS(KP831469612, T5i, KP555570233 * T5f);
+ T5n = FMA(KP831469612, T5f, KP555570233 * T5i);
+ }
+ {
+ E T55, T5k, T7H, T7K;
+ T55 = T4X + T54;
+ T5k = T5c + T5j;
+ iio[-WS(ios, 21)] = T55 - T5k;
+ rio[WS(ios, 5)] = T55 + T5k;
+ T7H = T5m + T5n;
+ T7K = T7I + T7J;
+ rio[WS(ios, 21)] = T7H - T7K;
+ iio[-WS(ios, 5)] = T7H + T7K;
+ }
+ {
+ E T5l, T5o, T7L, T7M;
+ T5l = T4X - T54;
+ T5o = T5m - T5n;
+ iio[-WS(ios, 29)] = T5l - T5o;
+ rio[WS(ios, 13)] = T5l + T5o;
+ T7L = T5j - T5c;
+ T7M = T7J - T7I;
+ rio[WS(ios, 29)] = T7L - T7M;
+ iio[-WS(ios, 13)] = T7L + T7M;
+ }
+ {
+ E T5t, T5A, T7x, T7E;
+ T5t = T5p + T5s;
+ T5A = T5w + T5z;
+ iio[-WS(ios, 17)] = T5t - T5A;
+ rio[WS(ios, 1)] = T5t + T5A;
+ T7x = T5C + T5D;
+ T7E = T7y + T7D;
+ rio[WS(ios, 17)] = T7x - T7E;
+ iio[-WS(ios, 1)] = T7x + T7E;
+ }
+ {
+ E T5B, T5E, T7F, T7G;
+ T5B = T5p - T5s;
+ T5E = T5C - T5D;
+ iio[-WS(ios, 25)] = T5B - T5E;
+ rio[WS(ios, 9)] = T5B + T5E;
+ T7F = T5z - T5w;
+ T7G = T7D - T7y;
+ rio[WS(ios, 25)] = T7F - T7G;
+ iio[-WS(ios, 9)] = T7F + T7G;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 32},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 32, "hf_32", twinstr, {340, 114, 94, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_32) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_4.c b/src/fftw3/rdft/codelets/r2hc/hf_4.c
new file mode 100644
index 0000000..f4468dd
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_4.c
@@ -0,0 +1,111 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:51 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 4 -dit -name hf_4 -include hf.h */
+
+/*
+ * This function contains 22 FP additions, 12 FP multiplications,
+ * (or, 16 additions, 6 multiplications, 6 fused multiply/add),
+ * 13 stack variables, and 16 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_4(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 6) {
+ E T1, Th, Tl, Tp, T6, To, Tc, Tk;
+ T1 = rio[0];
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 3)];
+ Tg = iio[0];
+ Td = W[4];
+ Tf = W[5];
+ Th = FMA(Td, Te, Tf * Tg);
+ Tl = FNMS(Tf, Te, Td * Tg);
+ }
+ Tp = iio[-WS(ios, 3)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 2)];
+ T5 = iio[-WS(ios, 1)];
+ T2 = W[2];
+ T4 = W[3];
+ T6 = FMA(T2, T3, T4 * T5);
+ To = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 1)];
+ Tb = iio[-WS(ios, 2)];
+ T8 = W[0];
+ Ta = W[1];
+ Tc = FMA(T8, T9, Ta * Tb);
+ Tk = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E T7, Ti, Tn, Tq;
+ T7 = T1 + T6;
+ Ti = Tc + Th;
+ iio[-WS(ios, 2)] = T7 - Ti;
+ rio[0] = T7 + Ti;
+ Tn = Tk + Tl;
+ Tq = To + Tp;
+ rio[WS(ios, 2)] = Tn - Tq;
+ iio[0] = Tn + Tq;
+ }
+ {
+ E Tj, Tm, Tr, Ts;
+ Tj = T1 - T6;
+ Tm = Tk - Tl;
+ iio[-WS(ios, 3)] = Tj - Tm;
+ rio[WS(ios, 1)] = Tj + Tm;
+ Tr = Th - Tc;
+ Ts = Tp - To;
+ rio[WS(ios, 3)] = Tr - Ts;
+ iio[-WS(ios, 1)] = Tr + Ts;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 4},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 4, "hf_4", twinstr, {16, 6, 6, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_4) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_4, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_5.c b/src/fftw3/rdft/codelets/r2hc/hf_5.c
new file mode 100644
index 0000000..2f02461
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_5.c
@@ -0,0 +1,143 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:52 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 5 -dit -name hf_5 -include hf.h */
+
+/*
+ * This function contains 40 FP additions, 28 FP multiplications,
+ * (or, 26 additions, 14 multiplications, 14 fused multiply/add),
+ * 29 stack variables, and 20 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_5(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 8) {
+ E T1, TE, Tu, Tx, TG, TF, TB, TC, TD, Tc, Tn, To;
+ T1 = rio[0];
+ TE = iio[-WS(ios, 4)];
+ {
+ E T6, Ts, Tm, Tw, Tb, Tt, Th, Tv;
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 1)];
+ T5 = iio[-WS(ios, 3)];
+ T2 = W[0];
+ T4 = W[1];
+ T6 = FMA(T2, T3, T4 * T5);
+ Ts = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E Tj, Tl, Ti, Tk;
+ Tj = rio[WS(ios, 3)];
+ Tl = iio[-WS(ios, 1)];
+ Ti = W[4];
+ Tk = W[5];
+ Tm = FMA(Ti, Tj, Tk * Tl);
+ Tw = FNMS(Tk, Tj, Ti * Tl);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 4)];
+ Ta = iio[0];
+ T7 = W[6];
+ T9 = W[7];
+ Tb = FMA(T7, T8, T9 * Ta);
+ Tt = FNMS(T9, T8, T7 * Ta);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 2)];
+ Tg = iio[-WS(ios, 2)];
+ Td = W[2];
+ Tf = W[3];
+ Th = FMA(Td, Te, Tf * Tg);
+ Tv = FNMS(Tf, Te, Td * Tg);
+ }
+ Tu = Ts - Tt;
+ Tx = Tv - Tw;
+ TG = Th - Tm;
+ TF = Tb - T6;
+ TB = Ts + Tt;
+ TC = Tv + Tw;
+ TD = TB + TC;
+ Tc = T6 + Tb;
+ Tn = Th + Tm;
+ To = Tc + Tn;
+ }
+ rio[0] = T1 + To;
+ iio[0] = TD + TE;
+ {
+ E Ty, TA, Tr, Tz, Tp, Tq;
+ Ty = FMA(KP951056516, Tu, KP587785252 * Tx);
+ TA = FNMS(KP587785252, Tu, KP951056516 * Tx);
+ Tp = KP559016994 * (Tc - Tn);
+ Tq = FNMS(KP250000000, To, T1);
+ Tr = Tp + Tq;
+ Tz = Tq - Tp;
+ iio[-WS(ios, 4)] = Tr - Ty;
+ iio[-WS(ios, 3)] = Tz + TA;
+ rio[WS(ios, 1)] = Tr + Ty;
+ rio[WS(ios, 2)] = Tz - TA;
+ }
+ {
+ E TH, TL, TK, TM, TI, TJ;
+ TH = FNMS(KP587785252, TG, KP951056516 * TF);
+ TL = FMA(KP587785252, TF, KP951056516 * TG);
+ TI = KP559016994 * (TB - TC);
+ TJ = FNMS(KP250000000, TD, TE);
+ TK = TI + TJ;
+ TM = TJ - TI;
+ rio[WS(ios, 4)] = TH - TK;
+ iio[-WS(ios, 2)] = TL + TM;
+ iio[-WS(ios, 1)] = TH + TK;
+ rio[WS(ios, 3)] = TL - TM;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 5},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 5, "hf_5", twinstr, {26, 14, 14, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_5) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_5, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_6.c b/src/fftw3/rdft/codelets/r2hc/hf_6.c
new file mode 100644
index 0000000..e4c9f8d
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_6.c
@@ -0,0 +1,160 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:54 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 6 -dit -name hf_6 -include hf.h */
+
+/*
+ * This function contains 46 FP additions, 28 FP multiplications,
+ * (or, 32 additions, 14 multiplications, 14 fused multiply/add),
+ * 23 stack variables, and 24 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_6(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 10) {
+ E T7, TS, Tv, TO, Ti, TI, Tw, TC, Tt, TJ, Tx, TF;
+ {
+ E T1, TN, T6, TM;
+ T1 = rio[0];
+ TN = iio[-WS(ios, 5)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 3)];
+ T5 = iio[-WS(ios, 2)];
+ T2 = W[4];
+ T4 = W[5];
+ T6 = FMA(T2, T3, T4 * T5);
+ TM = FNMS(T4, T3, T2 * T5);
+ }
+ T7 = T1 - T6;
+ TS = TN - TM;
+ Tv = T1 + T6;
+ TO = TM + TN;
+ }
+ {
+ E Tc, TA, Th, TB;
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 2)];
+ Tb = iio[-WS(ios, 3)];
+ T8 = W[2];
+ Ta = W[3];
+ Tc = FMA(T8, T9, Ta * Tb);
+ TA = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 5)];
+ Tg = iio[0];
+ Td = W[8];
+ Tf = W[9];
+ Th = FMA(Td, Te, Tf * Tg);
+ TB = FNMS(Tf, Te, Td * Tg);
+ }
+ Ti = Tc - Th;
+ TI = TA - TB;
+ Tw = Tc + Th;
+ TC = TA + TB;
+ }
+ {
+ E Tn, TD, Ts, TE;
+ {
+ E Tk, Tm, Tj, Tl;
+ Tk = rio[WS(ios, 4)];
+ Tm = iio[-WS(ios, 1)];
+ Tj = W[6];
+ Tl = W[7];
+ Tn = FMA(Tj, Tk, Tl * Tm);
+ TD = FNMS(Tl, Tk, Tj * Tm);
+ }
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 1)];
+ Tr = iio[-WS(ios, 4)];
+ To = W[0];
+ Tq = W[1];
+ Ts = FMA(To, Tp, Tq * Tr);
+ TE = FNMS(Tq, Tp, To * Tr);
+ }
+ Tt = Tn - Ts;
+ TJ = TE - TD;
+ Tx = Tn + Ts;
+ TF = TD + TE;
+ }
+ {
+ E TK, Tu, TH, TT, TR, TU;
+ TK = KP866025403 * (TI + TJ);
+ Tu = Ti + Tt;
+ TH = FNMS(KP500000000, Tu, T7);
+ iio[-WS(ios, 3)] = T7 + Tu;
+ rio[WS(ios, 1)] = TH + TK;
+ iio[-WS(ios, 5)] = TH - TK;
+ TT = KP866025403 * (Tt - Ti);
+ TR = TJ - TI;
+ TU = FMA(KP500000000, TR, TS);
+ rio[WS(ios, 3)] = TR - TS;
+ iio[-WS(ios, 1)] = TT + TU;
+ rio[WS(ios, 5)] = TT - TU;
+ }
+ {
+ E TG, Ty, Tz, TP, TL, TQ;
+ TG = KP866025403 * (TC - TF);
+ Ty = Tw + Tx;
+ Tz = FNMS(KP500000000, Ty, Tv);
+ rio[0] = Tv + Ty;
+ iio[-WS(ios, 4)] = Tz + TG;
+ rio[WS(ios, 2)] = Tz - TG;
+ TP = KP866025403 * (Tw - Tx);
+ TL = TC + TF;
+ TQ = FNMS(KP500000000, TL, TO);
+ iio[0] = TL + TO;
+ iio[-WS(ios, 2)] = TP + TQ;
+ rio[WS(ios, 4)] = TP - TQ;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 6},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 6, "hf_6", twinstr, {32, 14, 14, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_6) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_6, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_64.c b/src/fftw3/rdft/codelets/r2hc/hf_64.c
new file mode 100644
index 0000000..3e99d63
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_64.c
@@ -0,0 +1,2001 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:11 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 64 -dit -name hf_64 -include hf.h */
+
+/*
+ * This function contains 1038 FP additions, 500 FP multiplications,
+ * (or, 808 additions, 270 multiplications, 230 fused multiply/add),
+ * 176 stack variables, and 256 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_64(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 126) {
+ E Tj, TcL, ThT, Tin, T6b, Taz, TgT, Thn, TG, Thm, TcO, TgO, T6m, ThQ, TaC;
+ E Tim, T14, Tfq, T6y, T9O, TaG, Tc0, TcU, TeE, T1r, Tfr, T6J, T9P, TaJ, Tc1;
+ E TcZ, TeF, T1Q, T2d, Tfx, Tfu, Tfv, Tfw, T6Q, TaM, Tdb, TeJ, T71, TaQ, T7a;
+ E TaN, Td6, TeI, T77, TaP, T2B, T2Y, Tfz, TfA, TfB, TfC, T7h, TaW, Tdm, TeM;
+ E T7s, TaU, T7B, TaX, Tdh, TeL, T7y, TaT, T3M, TfL, TdL, TeQ, TfI, Tgt, T7K;
+ E Tb2, T7V, Tbe, T8s, Tb3, Tdu, TeT, T8p, Tbd, T5j, TfR, Tec, Tf0, TfY, Tgy;
+ E T8D, Tbl, T8O, Tbx, T9l, Tbm, TdV, TeX, T9i, Tbw, T64, TfZ, Te5, Ted, TfU;
+ E Tgz, T90, T9o, T9b, T9n, Tbt, Tbz, Te0, Tee, Tbq, TbA, T4x, TfJ, TdE, TdM;
+ E TfO, Tgu, T87, T8v, T8i, T8u, Tba, Tbg, Tdz, TdN, Tb7, Tbh;
+ {
+ E T1, TgR, T6, TgQ, Tc, T68, Th, T69;
+ T1 = rio[0];
+ TgR = iio[-WS(ios, 63)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 32)];
+ T5 = iio[-WS(ios, 31)];
+ T2 = W[62];
+ T4 = W[63];
+ T6 = FMA(T2, T3, T4 * T5);
+ TgQ = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 16)];
+ Tb = iio[-WS(ios, 47)];
+ T8 = W[30];
+ Ta = W[31];
+ Tc = FMA(T8, T9, Ta * Tb);
+ T68 = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 48)];
+ Tg = iio[-WS(ios, 15)];
+ Td = W[94];
+ Tf = W[95];
+ Th = FMA(Td, Te, Tf * Tg);
+ T69 = FNMS(Tf, Te, Td * Tg);
+ }
+ {
+ E T7, Ti, ThR, ThS;
+ T7 = T1 + T6;
+ Ti = Tc + Th;
+ Tj = T7 + Ti;
+ TcL = T7 - Ti;
+ ThR = TgR - TgQ;
+ ThS = Tc - Th;
+ ThT = ThR - ThS;
+ Tin = ThS + ThR;
+ }
+ {
+ E T67, T6a, TgP, TgS;
+ T67 = T1 - T6;
+ T6a = T68 - T69;
+ T6b = T67 - T6a;
+ Taz = T67 + T6a;
+ TgP = T68 + T69;
+ TgS = TgQ + TgR;
+ TgT = TgP + TgS;
+ Thn = TgS - TgP;
+ }
+ }
+ {
+ E To, T6c, Tt, T6d, T6e, T6f, Tz, T6i, TE, T6j, T6h, T6k;
+ {
+ E Tl, Tn, Tk, Tm;
+ Tl = rio[WS(ios, 8)];
+ Tn = iio[-WS(ios, 55)];
+ Tk = W[14];
+ Tm = W[15];
+ To = FMA(Tk, Tl, Tm * Tn);
+ T6c = FNMS(Tm, Tl, Tk * Tn);
+ }
+ {
+ E Tq, Ts, Tp, Tr;
+ Tq = rio[WS(ios, 40)];
+ Ts = iio[-WS(ios, 23)];
+ Tp = W[78];
+ Tr = W[79];
+ Tt = FMA(Tp, Tq, Tr * Ts);
+ T6d = FNMS(Tr, Tq, Tp * Ts);
+ }
+ T6e = T6c - T6d;
+ T6f = To - Tt;
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 56)];
+ Ty = iio[-WS(ios, 7)];
+ Tv = W[110];
+ Tx = W[111];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T6i = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 24)];
+ TD = iio[-WS(ios, 39)];
+ TA = W[46];
+ TC = W[47];
+ TE = FMA(TA, TB, TC * TD);
+ T6j = FNMS(TC, TB, TA * TD);
+ }
+ T6h = Tz - TE;
+ T6k = T6i - T6j;
+ {
+ E Tu, TF, TcM, TcN;
+ Tu = To + Tt;
+ TF = Tz + TE;
+ TG = Tu + TF;
+ Thm = TF - Tu;
+ TcM = T6c + T6d;
+ TcN = T6i + T6j;
+ TcO = TcM - TcN;
+ TgO = TcM + TcN;
+ }
+ {
+ E T6g, T6l, TaA, TaB;
+ T6g = T6e - T6f;
+ T6l = T6h + T6k;
+ T6m = KP707106781 * (T6g - T6l);
+ ThQ = KP707106781 * (T6g + T6l);
+ TaA = T6f + T6e;
+ TaB = T6h - T6k;
+ TaC = KP707106781 * (TaA + TaB);
+ Tim = KP707106781 * (TaB - TaA);
+ }
+ }
+ {
+ E TS, TcQ, T6q, T6t, T13, TcR, T6r, T6w, T6s, T6x;
+ {
+ E TM, T6o, TR, T6p;
+ {
+ E TJ, TL, TI, TK;
+ TJ = rio[WS(ios, 4)];
+ TL = iio[-WS(ios, 59)];
+ TI = W[6];
+ TK = W[7];
+ TM = FMA(TI, TJ, TK * TL);
+ T6o = FNMS(TK, TJ, TI * TL);
+ }
+ {
+ E TO, TQ, TN, TP;
+ TO = rio[WS(ios, 36)];
+ TQ = iio[-WS(ios, 27)];
+ TN = W[70];
+ TP = W[71];
+ TR = FMA(TN, TO, TP * TQ);
+ T6p = FNMS(TP, TO, TN * TQ);
+ }
+ TS = TM + TR;
+ TcQ = T6o + T6p;
+ T6q = T6o - T6p;
+ T6t = TM - TR;
+ }
+ {
+ E TX, T6u, T12, T6v;
+ {
+ E TU, TW, TT, TV;
+ TU = rio[WS(ios, 20)];
+ TW = iio[-WS(ios, 43)];
+ TT = W[38];
+ TV = W[39];
+ TX = FMA(TT, TU, TV * TW);
+ T6u = FNMS(TV, TU, TT * TW);
+ }
+ {
+ E TZ, T11, TY, T10;
+ TZ = rio[WS(ios, 52)];
+ T11 = iio[-WS(ios, 11)];
+ TY = W[102];
+ T10 = W[103];
+ T12 = FMA(TY, TZ, T10 * T11);
+ T6v = FNMS(T10, TZ, TY * T11);
+ }
+ T13 = TX + T12;
+ TcR = T6u + T6v;
+ T6r = TX - T12;
+ T6w = T6u - T6v;
+ }
+ T14 = TS + T13;
+ Tfq = TcQ + TcR;
+ T6s = T6q + T6r;
+ T6x = T6t - T6w;
+ T6y = FNMS(KP923879532, T6x, KP382683432 * T6s);
+ T9O = FMA(KP923879532, T6s, KP382683432 * T6x);
+ {
+ E TaE, TaF, TcS, TcT;
+ TaE = T6q - T6r;
+ TaF = T6t + T6w;
+ TaG = FNMS(KP382683432, TaF, KP923879532 * TaE);
+ Tc0 = FMA(KP382683432, TaE, KP923879532 * TaF);
+ TcS = TcQ - TcR;
+ TcT = TS - T13;
+ TcU = TcS - TcT;
+ TeE = TcT + TcS;
+ }
+ }
+ {
+ E T1f, TcW, T6B, T6E, T1q, TcX, T6C, T6H, T6D, T6I;
+ {
+ E T19, T6z, T1e, T6A;
+ {
+ E T16, T18, T15, T17;
+ T16 = rio[WS(ios, 60)];
+ T18 = iio[-WS(ios, 3)];
+ T15 = W[118];
+ T17 = W[119];
+ T19 = FMA(T15, T16, T17 * T18);
+ T6z = FNMS(T17, T16, T15 * T18);
+ }
+ {
+ E T1b, T1d, T1a, T1c;
+ T1b = rio[WS(ios, 28)];
+ T1d = iio[-WS(ios, 35)];
+ T1a = W[54];
+ T1c = W[55];
+ T1e = FMA(T1a, T1b, T1c * T1d);
+ T6A = FNMS(T1c, T1b, T1a * T1d);
+ }
+ T1f = T19 + T1e;
+ TcW = T6z + T6A;
+ T6B = T6z - T6A;
+ T6E = T19 - T1e;
+ }
+ {
+ E T1k, T6F, T1p, T6G;
+ {
+ E T1h, T1j, T1g, T1i;
+ T1h = rio[WS(ios, 12)];
+ T1j = iio[-WS(ios, 51)];
+ T1g = W[22];
+ T1i = W[23];
+ T1k = FMA(T1g, T1h, T1i * T1j);
+ T6F = FNMS(T1i, T1h, T1g * T1j);
+ }
+ {
+ E T1m, T1o, T1l, T1n;
+ T1m = rio[WS(ios, 44)];
+ T1o = iio[-WS(ios, 19)];
+ T1l = W[86];
+ T1n = W[87];
+ T1p = FMA(T1l, T1m, T1n * T1o);
+ T6G = FNMS(T1n, T1m, T1l * T1o);
+ }
+ T1q = T1k + T1p;
+ TcX = T6F + T6G;
+ T6C = T1k - T1p;
+ T6H = T6F - T6G;
+ }
+ T1r = T1f + T1q;
+ Tfr = TcW + TcX;
+ T6D = T6B + T6C;
+ T6I = T6E - T6H;
+ T6J = FMA(KP382683432, T6D, KP923879532 * T6I);
+ T9P = FNMS(KP923879532, T6D, KP382683432 * T6I);
+ {
+ E TaH, TaI, TcV, TcY;
+ TaH = T6B - T6C;
+ TaI = T6E + T6H;
+ TaJ = FMA(KP923879532, TaH, KP382683432 * TaI);
+ Tc1 = FNMS(KP382683432, TaH, KP923879532 * TaI);
+ TcV = T1f - T1q;
+ TcY = TcW - TcX;
+ TcZ = TcV + TcY;
+ TeF = TcV - TcY;
+ }
+ }
+ {
+ E T1y, T6M, T1D, T6N, T1E, Td2, T1J, T74, T1O, T75, T1P, Td3, T21, Td8, T6W;
+ E T6Z, T2c, Td9, T6R, T6U;
+ {
+ E T1v, T1x, T1u, T1w;
+ T1v = rio[WS(ios, 2)];
+ T1x = iio[-WS(ios, 61)];
+ T1u = W[2];
+ T1w = W[3];
+ T1y = FMA(T1u, T1v, T1w * T1x);
+ T6M = FNMS(T1w, T1v, T1u * T1x);
+ }
+ {
+ E T1A, T1C, T1z, T1B;
+ T1A = rio[WS(ios, 34)];
+ T1C = iio[-WS(ios, 29)];
+ T1z = W[66];
+ T1B = W[67];
+ T1D = FMA(T1z, T1A, T1B * T1C);
+ T6N = FNMS(T1B, T1A, T1z * T1C);
+ }
+ T1E = T1y + T1D;
+ Td2 = T6M + T6N;
+ {
+ E T1G, T1I, T1F, T1H;
+ T1G = rio[WS(ios, 18)];
+ T1I = iio[-WS(ios, 45)];
+ T1F = W[34];
+ T1H = W[35];
+ T1J = FMA(T1F, T1G, T1H * T1I);
+ T74 = FNMS(T1H, T1G, T1F * T1I);
+ }
+ {
+ E T1L, T1N, T1K, T1M;
+ T1L = rio[WS(ios, 50)];
+ T1N = iio[-WS(ios, 13)];
+ T1K = W[98];
+ T1M = W[99];
+ T1O = FMA(T1K, T1L, T1M * T1N);
+ T75 = FNMS(T1M, T1L, T1K * T1N);
+ }
+ T1P = T1J + T1O;
+ Td3 = T74 + T75;
+ {
+ E T1V, T6X, T20, T6Y;
+ {
+ E T1S, T1U, T1R, T1T;
+ T1S = rio[WS(ios, 10)];
+ T1U = iio[-WS(ios, 53)];
+ T1R = W[18];
+ T1T = W[19];
+ T1V = FMA(T1R, T1S, T1T * T1U);
+ T6X = FNMS(T1T, T1S, T1R * T1U);
+ }
+ {
+ E T1X, T1Z, T1W, T1Y;
+ T1X = rio[WS(ios, 42)];
+ T1Z = iio[-WS(ios, 21)];
+ T1W = W[82];
+ T1Y = W[83];
+ T20 = FMA(T1W, T1X, T1Y * T1Z);
+ T6Y = FNMS(T1Y, T1X, T1W * T1Z);
+ }
+ T21 = T1V + T20;
+ Td8 = T6X + T6Y;
+ T6W = T1V - T20;
+ T6Z = T6X - T6Y;
+ }
+ {
+ E T26, T6S, T2b, T6T;
+ {
+ E T23, T25, T22, T24;
+ T23 = rio[WS(ios, 58)];
+ T25 = iio[-WS(ios, 5)];
+ T22 = W[114];
+ T24 = W[115];
+ T26 = FMA(T22, T23, T24 * T25);
+ T6S = FNMS(T24, T23, T22 * T25);
+ }
+ {
+ E T28, T2a, T27, T29;
+ T28 = rio[WS(ios, 26)];
+ T2a = iio[-WS(ios, 37)];
+ T27 = W[50];
+ T29 = W[51];
+ T2b = FMA(T27, T28, T29 * T2a);
+ T6T = FNMS(T29, T28, T27 * T2a);
+ }
+ T2c = T26 + T2b;
+ Td9 = T6S + T6T;
+ T6R = T26 - T2b;
+ T6U = T6S - T6T;
+ }
+ T1Q = T1E + T1P;
+ T2d = T21 + T2c;
+ Tfx = T1Q - T2d;
+ Tfu = Td2 + Td3;
+ Tfv = Td8 + Td9;
+ Tfw = Tfu - Tfv;
+ {
+ E T6O, T6P, Td7, Tda;
+ T6O = T6M - T6N;
+ T6P = T1J - T1O;
+ T6Q = T6O + T6P;
+ TaM = T6O - T6P;
+ Td7 = T1E - T1P;
+ Tda = Td8 - Td9;
+ Tdb = Td7 - Tda;
+ TeJ = Td7 + Tda;
+ }
+ {
+ E T6V, T70, T78, T79;
+ T6V = T6R - T6U;
+ T70 = T6W + T6Z;
+ T71 = KP707106781 * (T6V - T70);
+ TaQ = KP707106781 * (T70 + T6V);
+ T78 = T6Z - T6W;
+ T79 = T6R + T6U;
+ T7a = KP707106781 * (T78 - T79);
+ TaN = KP707106781 * (T78 + T79);
+ }
+ {
+ E Td4, Td5, T73, T76;
+ Td4 = Td2 - Td3;
+ Td5 = T2c - T21;
+ Td6 = Td4 - Td5;
+ TeI = Td4 + Td5;
+ T73 = T1y - T1D;
+ T76 = T74 - T75;
+ T77 = T73 - T76;
+ TaP = T73 + T76;
+ }
+ }
+ {
+ E T2j, T7d, T2o, T7e, T2p, Tdd, T2u, T7v, T2z, T7w, T2A, Tde, T2M, Tdj, T7n;
+ E T7q, T2X, Tdk, T7i, T7l;
+ {
+ E T2g, T2i, T2f, T2h;
+ T2g = rio[WS(ios, 62)];
+ T2i = iio[-WS(ios, 1)];
+ T2f = W[122];
+ T2h = W[123];
+ T2j = FMA(T2f, T2g, T2h * T2i);
+ T7d = FNMS(T2h, T2g, T2f * T2i);
+ }
+ {
+ E T2l, T2n, T2k, T2m;
+ T2l = rio[WS(ios, 30)];
+ T2n = iio[-WS(ios, 33)];
+ T2k = W[58];
+ T2m = W[59];
+ T2o = FMA(T2k, T2l, T2m * T2n);
+ T7e = FNMS(T2m, T2l, T2k * T2n);
+ }
+ T2p = T2j + T2o;
+ Tdd = T7d + T7e;
+ {
+ E T2r, T2t, T2q, T2s;
+ T2r = rio[WS(ios, 14)];
+ T2t = iio[-WS(ios, 49)];
+ T2q = W[26];
+ T2s = W[27];
+ T2u = FMA(T2q, T2r, T2s * T2t);
+ T7v = FNMS(T2s, T2r, T2q * T2t);
+ }
+ {
+ E T2w, T2y, T2v, T2x;
+ T2w = rio[WS(ios, 46)];
+ T2y = iio[-WS(ios, 17)];
+ T2v = W[90];
+ T2x = W[91];
+ T2z = FMA(T2v, T2w, T2x * T2y);
+ T7w = FNMS(T2x, T2w, T2v * T2y);
+ }
+ T2A = T2u + T2z;
+ Tde = T7v + T7w;
+ {
+ E T2G, T7o, T2L, T7p;
+ {
+ E T2D, T2F, T2C, T2E;
+ T2D = rio[WS(ios, 6)];
+ T2F = iio[-WS(ios, 57)];
+ T2C = W[10];
+ T2E = W[11];
+ T2G = FMA(T2C, T2D, T2E * T2F);
+ T7o = FNMS(T2E, T2D, T2C * T2F);
+ }
+ {
+ E T2I, T2K, T2H, T2J;
+ T2I = rio[WS(ios, 38)];
+ T2K = iio[-WS(ios, 25)];
+ T2H = W[74];
+ T2J = W[75];
+ T2L = FMA(T2H, T2I, T2J * T2K);
+ T7p = FNMS(T2J, T2I, T2H * T2K);
+ }
+ T2M = T2G + T2L;
+ Tdj = T7o + T7p;
+ T7n = T2G - T2L;
+ T7q = T7o - T7p;
+ }
+ {
+ E T2R, T7j, T2W, T7k;
+ {
+ E T2O, T2Q, T2N, T2P;
+ T2O = rio[WS(ios, 54)];
+ T2Q = iio[-WS(ios, 9)];
+ T2N = W[106];
+ T2P = W[107];
+ T2R = FMA(T2N, T2O, T2P * T2Q);
+ T7j = FNMS(T2P, T2O, T2N * T2Q);
+ }
+ {
+ E T2T, T2V, T2S, T2U;
+ T2T = rio[WS(ios, 22)];
+ T2V = iio[-WS(ios, 41)];
+ T2S = W[42];
+ T2U = W[43];
+ T2W = FMA(T2S, T2T, T2U * T2V);
+ T7k = FNMS(T2U, T2T, T2S * T2V);
+ }
+ T2X = T2R + T2W;
+ Tdk = T7j + T7k;
+ T7i = T2R - T2W;
+ T7l = T7j - T7k;
+ }
+ T2B = T2p + T2A;
+ T2Y = T2M + T2X;
+ Tfz = T2B - T2Y;
+ TfA = Tdd + Tde;
+ TfB = Tdj + Tdk;
+ TfC = TfA - TfB;
+ {
+ E T7f, T7g, Tdi, Tdl;
+ T7f = T7d - T7e;
+ T7g = T2u - T2z;
+ T7h = T7f + T7g;
+ TaW = T7f - T7g;
+ Tdi = T2p - T2A;
+ Tdl = Tdj - Tdk;
+ Tdm = Tdi - Tdl;
+ TeM = Tdi + Tdl;
+ }
+ {
+ E T7m, T7r, T7z, T7A;
+ T7m = T7i - T7l;
+ T7r = T7n + T7q;
+ T7s = KP707106781 * (T7m - T7r);
+ TaU = KP707106781 * (T7r + T7m);
+ T7z = T7q - T7n;
+ T7A = T7i + T7l;
+ T7B = KP707106781 * (T7z - T7A);
+ TaX = KP707106781 * (T7z + T7A);
+ }
+ {
+ E Tdf, Tdg, T7u, T7x;
+ Tdf = Tdd - Tde;
+ Tdg = T2X - T2M;
+ Tdh = Tdf - Tdg;
+ TeL = Tdf + Tdg;
+ T7u = T2j - T2o;
+ T7x = T7v - T7w;
+ T7y = T7u - T7x;
+ TaT = T7u + T7x;
+ }
+ }
+ {
+ E T36, T7G, T3b, T7H, T3c, Tdq, T3h, T8m, T3m, T8n, T3n, Tdr, T3z, TdI, T7Q;
+ E T7T, T3K, TdJ, T7L, T7O;
+ {
+ E T33, T35, T32, T34;
+ T33 = rio[WS(ios, 1)];
+ T35 = iio[-WS(ios, 62)];
+ T32 = W[0];
+ T34 = W[1];
+ T36 = FMA(T32, T33, T34 * T35);
+ T7G = FNMS(T34, T33, T32 * T35);
+ }
+ {
+ E T38, T3a, T37, T39;
+ T38 = rio[WS(ios, 33)];
+ T3a = iio[-WS(ios, 30)];
+ T37 = W[64];
+ T39 = W[65];
+ T3b = FMA(T37, T38, T39 * T3a);
+ T7H = FNMS(T39, T38, T37 * T3a);
+ }
+ T3c = T36 + T3b;
+ Tdq = T7G + T7H;
+ {
+ E T3e, T3g, T3d, T3f;
+ T3e = rio[WS(ios, 17)];
+ T3g = iio[-WS(ios, 46)];
+ T3d = W[32];
+ T3f = W[33];
+ T3h = FMA(T3d, T3e, T3f * T3g);
+ T8m = FNMS(T3f, T3e, T3d * T3g);
+ }
+ {
+ E T3j, T3l, T3i, T3k;
+ T3j = rio[WS(ios, 49)];
+ T3l = iio[-WS(ios, 14)];
+ T3i = W[96];
+ T3k = W[97];
+ T3m = FMA(T3i, T3j, T3k * T3l);
+ T8n = FNMS(T3k, T3j, T3i * T3l);
+ }
+ T3n = T3h + T3m;
+ Tdr = T8m + T8n;
+ {
+ E T3t, T7R, T3y, T7S;
+ {
+ E T3q, T3s, T3p, T3r;
+ T3q = rio[WS(ios, 9)];
+ T3s = iio[-WS(ios, 54)];
+ T3p = W[16];
+ T3r = W[17];
+ T3t = FMA(T3p, T3q, T3r * T3s);
+ T7R = FNMS(T3r, T3q, T3p * T3s);
+ }
+ {
+ E T3v, T3x, T3u, T3w;
+ T3v = rio[WS(ios, 41)];
+ T3x = iio[-WS(ios, 22)];
+ T3u = W[80];
+ T3w = W[81];
+ T3y = FMA(T3u, T3v, T3w * T3x);
+ T7S = FNMS(T3w, T3v, T3u * T3x);
+ }
+ T3z = T3t + T3y;
+ TdI = T7R + T7S;
+ T7Q = T3t - T3y;
+ T7T = T7R - T7S;
+ }
+ {
+ E T3E, T7M, T3J, T7N;
+ {
+ E T3B, T3D, T3A, T3C;
+ T3B = rio[WS(ios, 57)];
+ T3D = iio[-WS(ios, 6)];
+ T3A = W[112];
+ T3C = W[113];
+ T3E = FMA(T3A, T3B, T3C * T3D);
+ T7M = FNMS(T3C, T3B, T3A * T3D);
+ }
+ {
+ E T3G, T3I, T3F, T3H;
+ T3G = rio[WS(ios, 25)];
+ T3I = iio[-WS(ios, 38)];
+ T3F = W[48];
+ T3H = W[49];
+ T3J = FMA(T3F, T3G, T3H * T3I);
+ T7N = FNMS(T3H, T3G, T3F * T3I);
+ }
+ T3K = T3E + T3J;
+ TdJ = T7M + T7N;
+ T7L = T3E - T3J;
+ T7O = T7M - T7N;
+ }
+ {
+ E T3o, T3L, TdH, TdK;
+ T3o = T3c + T3n;
+ T3L = T3z + T3K;
+ T3M = T3o + T3L;
+ TfL = T3o - T3L;
+ TdH = T3c - T3n;
+ TdK = TdI - TdJ;
+ TdL = TdH - TdK;
+ TeQ = TdH + TdK;
+ }
+ {
+ E TfG, TfH, T7I, T7J;
+ TfG = Tdq + Tdr;
+ TfH = TdI + TdJ;
+ TfI = TfG - TfH;
+ Tgt = TfG + TfH;
+ T7I = T7G - T7H;
+ T7J = T3h - T3m;
+ T7K = T7I + T7J;
+ Tb2 = T7I - T7J;
+ }
+ {
+ E T7P, T7U, T8q, T8r;
+ T7P = T7L - T7O;
+ T7U = T7Q + T7T;
+ T7V = KP707106781 * (T7P - T7U);
+ Tbe = KP707106781 * (T7U + T7P);
+ T8q = T7T - T7Q;
+ T8r = T7L + T7O;
+ T8s = KP707106781 * (T8q - T8r);
+ Tb3 = KP707106781 * (T8q + T8r);
+ }
+ {
+ E Tds, Tdt, T8l, T8o;
+ Tds = Tdq - Tdr;
+ Tdt = T3K - T3z;
+ Tdu = Tds - Tdt;
+ TeT = Tds + Tdt;
+ T8l = T36 - T3b;
+ T8o = T8m - T8n;
+ T8p = T8l - T8o;
+ Tbd = T8l + T8o;
+ }
+ }
+ {
+ E T4D, T9e, T4I, T9f, T4J, Te8, T4O, T8A, T4T, T8B, T4U, Te9, T56, TdS, T8G;
+ E T8H, T5h, TdT, T8J, T8M;
+ {
+ E T4A, T4C, T4z, T4B;
+ T4A = rio[WS(ios, 63)];
+ T4C = iio[0];
+ T4z = W[124];
+ T4B = W[125];
+ T4D = FMA(T4z, T4A, T4B * T4C);
+ T9e = FNMS(T4B, T4A, T4z * T4C);
+ }
+ {
+ E T4F, T4H, T4E, T4G;
+ T4F = rio[WS(ios, 31)];
+ T4H = iio[-WS(ios, 32)];
+ T4E = W[60];
+ T4G = W[61];
+ T4I = FMA(T4E, T4F, T4G * T4H);
+ T9f = FNMS(T4G, T4F, T4E * T4H);
+ }
+ T4J = T4D + T4I;
+ Te8 = T9e + T9f;
+ {
+ E T4L, T4N, T4K, T4M;
+ T4L = rio[WS(ios, 15)];
+ T4N = iio[-WS(ios, 48)];
+ T4K = W[28];
+ T4M = W[29];
+ T4O = FMA(T4K, T4L, T4M * T4N);
+ T8A = FNMS(T4M, T4L, T4K * T4N);
+ }
+ {
+ E T4Q, T4S, T4P, T4R;
+ T4Q = rio[WS(ios, 47)];
+ T4S = iio[-WS(ios, 16)];
+ T4P = W[92];
+ T4R = W[93];
+ T4T = FMA(T4P, T4Q, T4R * T4S);
+ T8B = FNMS(T4R, T4Q, T4P * T4S);
+ }
+ T4U = T4O + T4T;
+ Te9 = T8A + T8B;
+ {
+ E T50, T8E, T55, T8F;
+ {
+ E T4X, T4Z, T4W, T4Y;
+ T4X = rio[WS(ios, 7)];
+ T4Z = iio[-WS(ios, 56)];
+ T4W = W[12];
+ T4Y = W[13];
+ T50 = FMA(T4W, T4X, T4Y * T4Z);
+ T8E = FNMS(T4Y, T4X, T4W * T4Z);
+ }
+ {
+ E T52, T54, T51, T53;
+ T52 = rio[WS(ios, 39)];
+ T54 = iio[-WS(ios, 24)];
+ T51 = W[76];
+ T53 = W[77];
+ T55 = FMA(T51, T52, T53 * T54);
+ T8F = FNMS(T53, T52, T51 * T54);
+ }
+ T56 = T50 + T55;
+ TdS = T8E + T8F;
+ T8G = T8E - T8F;
+ T8H = T50 - T55;
+ }
+ {
+ E T5b, T8K, T5g, T8L;
+ {
+ E T58, T5a, T57, T59;
+ T58 = rio[WS(ios, 55)];
+ T5a = iio[-WS(ios, 8)];
+ T57 = W[108];
+ T59 = W[109];
+ T5b = FMA(T57, T58, T59 * T5a);
+ T8K = FNMS(T59, T58, T57 * T5a);
+ }
+ {
+ E T5d, T5f, T5c, T5e;
+ T5d = rio[WS(ios, 23)];
+ T5f = iio[-WS(ios, 40)];
+ T5c = W[44];
+ T5e = W[45];
+ T5g = FMA(T5c, T5d, T5e * T5f);
+ T8L = FNMS(T5e, T5d, T5c * T5f);
+ }
+ T5h = T5b + T5g;
+ TdT = T8K + T8L;
+ T8J = T5b - T5g;
+ T8M = T8K - T8L;
+ }
+ {
+ E T4V, T5i, Tea, Teb;
+ T4V = T4J + T4U;
+ T5i = T56 + T5h;
+ T5j = T4V + T5i;
+ TfR = T4V - T5i;
+ Tea = Te8 - Te9;
+ Teb = T5h - T56;
+ Tec = Tea - Teb;
+ Tf0 = Tea + Teb;
+ }
+ {
+ E TfW, TfX, T8z, T8C;
+ TfW = Te8 + Te9;
+ TfX = TdS + TdT;
+ TfY = TfW - TfX;
+ Tgy = TfW + TfX;
+ T8z = T4D - T4I;
+ T8C = T8A - T8B;
+ T8D = T8z - T8C;
+ Tbl = T8z + T8C;
+ }
+ {
+ E T8I, T8N, T9j, T9k;
+ T8I = T8G - T8H;
+ T8N = T8J + T8M;
+ T8O = KP707106781 * (T8I - T8N);
+ Tbx = KP707106781 * (T8I + T8N);
+ T9j = T8J - T8M;
+ T9k = T8H + T8G;
+ T9l = KP707106781 * (T9j - T9k);
+ Tbm = KP707106781 * (T9k + T9j);
+ }
+ {
+ E TdR, TdU, T9g, T9h;
+ TdR = T4J - T4U;
+ TdU = TdS - TdT;
+ TdV = TdR - TdU;
+ TeX = TdR + TdU;
+ T9g = T9e - T9f;
+ T9h = T4O - T4T;
+ T9i = T9g + T9h;
+ Tbw = T9g - T9h;
+ }
+ }
+ {
+ E T5u, TdW, T8S, T8V, T62, Te3, T94, T99, T5F, TdX, T8T, T8Y, T5R, Te2, T93;
+ E T96;
+ {
+ E T5o, T8Q, T5t, T8R;
+ {
+ E T5l, T5n, T5k, T5m;
+ T5l = rio[WS(ios, 3)];
+ T5n = iio[-WS(ios, 60)];
+ T5k = W[4];
+ T5m = W[5];
+ T5o = FMA(T5k, T5l, T5m * T5n);
+ T8Q = FNMS(T5m, T5l, T5k * T5n);
+ }
+ {
+ E T5q, T5s, T5p, T5r;
+ T5q = rio[WS(ios, 35)];
+ T5s = iio[-WS(ios, 28)];
+ T5p = W[68];
+ T5r = W[69];
+ T5t = FMA(T5p, T5q, T5r * T5s);
+ T8R = FNMS(T5r, T5q, T5p * T5s);
+ }
+ T5u = T5o + T5t;
+ TdW = T8Q + T8R;
+ T8S = T8Q - T8R;
+ T8V = T5o - T5t;
+ }
+ {
+ E T5W, T97, T61, T98;
+ {
+ E T5T, T5V, T5S, T5U;
+ T5T = rio[WS(ios, 11)];
+ T5V = iio[-WS(ios, 52)];
+ T5S = W[20];
+ T5U = W[21];
+ T5W = FMA(T5S, T5T, T5U * T5V);
+ T97 = FNMS(T5U, T5T, T5S * T5V);
+ }
+ {
+ E T5Y, T60, T5X, T5Z;
+ T5Y = rio[WS(ios, 43)];
+ T60 = iio[-WS(ios, 20)];
+ T5X = W[84];
+ T5Z = W[85];
+ T61 = FMA(T5X, T5Y, T5Z * T60);
+ T98 = FNMS(T5Z, T5Y, T5X * T60);
+ }
+ T62 = T5W + T61;
+ Te3 = T97 + T98;
+ T94 = T5W - T61;
+ T99 = T97 - T98;
+ }
+ {
+ E T5z, T8W, T5E, T8X;
+ {
+ E T5w, T5y, T5v, T5x;
+ T5w = rio[WS(ios, 19)];
+ T5y = iio[-WS(ios, 44)];
+ T5v = W[36];
+ T5x = W[37];
+ T5z = FMA(T5v, T5w, T5x * T5y);
+ T8W = FNMS(T5x, T5w, T5v * T5y);
+ }
+ {
+ E T5B, T5D, T5A, T5C;
+ T5B = rio[WS(ios, 51)];
+ T5D = iio[-WS(ios, 12)];
+ T5A = W[100];
+ T5C = W[101];
+ T5E = FMA(T5A, T5B, T5C * T5D);
+ T8X = FNMS(T5C, T5B, T5A * T5D);
+ }
+ T5F = T5z + T5E;
+ TdX = T8W + T8X;
+ T8T = T5z - T5E;
+ T8Y = T8W - T8X;
+ }
+ {
+ E T5L, T91, T5Q, T92;
+ {
+ E T5I, T5K, T5H, T5J;
+ T5I = rio[WS(ios, 59)];
+ T5K = iio[-WS(ios, 4)];
+ T5H = W[116];
+ T5J = W[117];
+ T5L = FMA(T5H, T5I, T5J * T5K);
+ T91 = FNMS(T5J, T5I, T5H * T5K);
+ }
+ {
+ E T5N, T5P, T5M, T5O;
+ T5N = rio[WS(ios, 27)];
+ T5P = iio[-WS(ios, 36)];
+ T5M = W[52];
+ T5O = W[53];
+ T5Q = FMA(T5M, T5N, T5O * T5P);
+ T92 = FNMS(T5O, T5N, T5M * T5P);
+ }
+ T5R = T5L + T5Q;
+ Te2 = T91 + T92;
+ T93 = T91 - T92;
+ T96 = T5L - T5Q;
+ }
+ {
+ E T5G, T63, Te1, Te4;
+ T5G = T5u + T5F;
+ T63 = T5R + T62;
+ T64 = T5G + T63;
+ TfZ = T63 - T5G;
+ Te1 = T5R - T62;
+ Te4 = Te2 - Te3;
+ Te5 = Te1 + Te4;
+ Ted = Te1 - Te4;
+ }
+ {
+ E TfS, TfT, T8U, T8Z;
+ TfS = TdW + TdX;
+ TfT = Te2 + Te3;
+ TfU = TfS - TfT;
+ Tgz = TfS + TfT;
+ T8U = T8S + T8T;
+ T8Z = T8V - T8Y;
+ T90 = FNMS(KP923879532, T8Z, KP382683432 * T8U);
+ T9o = FMA(KP923879532, T8U, KP382683432 * T8Z);
+ }
+ {
+ E T95, T9a, Tbr, Tbs;
+ T95 = T93 + T94;
+ T9a = T96 - T99;
+ T9b = FMA(KP382683432, T95, KP923879532 * T9a);
+ T9n = FNMS(KP923879532, T95, KP382683432 * T9a);
+ Tbr = T93 - T94;
+ Tbs = T96 + T99;
+ Tbt = FMA(KP923879532, Tbr, KP382683432 * Tbs);
+ Tbz = FNMS(KP382683432, Tbr, KP923879532 * Tbs);
+ }
+ {
+ E TdY, TdZ, Tbo, Tbp;
+ TdY = TdW - TdX;
+ TdZ = T5u - T5F;
+ Te0 = TdY - TdZ;
+ Tee = TdZ + TdY;
+ Tbo = T8S - T8T;
+ Tbp = T8V + T8Y;
+ Tbq = FNMS(KP382683432, Tbp, KP923879532 * Tbo);
+ TbA = FMA(KP382683432, Tbo, KP923879532 * Tbp);
+ }
+ }
+ {
+ E T3X, TdB, T8a, T8d, T4v, Tdx, T80, T85, T48, TdC, T8b, T8g, T4k, Tdw, T7X;
+ E T84;
+ {
+ E T3R, T88, T3W, T89;
+ {
+ E T3O, T3Q, T3N, T3P;
+ T3O = rio[WS(ios, 5)];
+ T3Q = iio[-WS(ios, 58)];
+ T3N = W[8];
+ T3P = W[9];
+ T3R = FMA(T3N, T3O, T3P * T3Q);
+ T88 = FNMS(T3P, T3O, T3N * T3Q);
+ }
+ {
+ E T3T, T3V, T3S, T3U;
+ T3T = rio[WS(ios, 37)];
+ T3V = iio[-WS(ios, 26)];
+ T3S = W[72];
+ T3U = W[73];
+ T3W = FMA(T3S, T3T, T3U * T3V);
+ T89 = FNMS(T3U, T3T, T3S * T3V);
+ }
+ T3X = T3R + T3W;
+ TdB = T88 + T89;
+ T8a = T88 - T89;
+ T8d = T3R - T3W;
+ }
+ {
+ E T4p, T7Y, T4u, T7Z;
+ {
+ E T4m, T4o, T4l, T4n;
+ T4m = rio[WS(ios, 13)];
+ T4o = iio[-WS(ios, 50)];
+ T4l = W[24];
+ T4n = W[25];
+ T4p = FMA(T4l, T4m, T4n * T4o);
+ T7Y = FNMS(T4n, T4m, T4l * T4o);
+ }
+ {
+ E T4r, T4t, T4q, T4s;
+ T4r = rio[WS(ios, 45)];
+ T4t = iio[-WS(ios, 18)];
+ T4q = W[88];
+ T4s = W[89];
+ T4u = FMA(T4q, T4r, T4s * T4t);
+ T7Z = FNMS(T4s, T4r, T4q * T4t);
+ }
+ T4v = T4p + T4u;
+ Tdx = T7Y + T7Z;
+ T80 = T7Y - T7Z;
+ T85 = T4p - T4u;
+ }
+ {
+ E T42, T8e, T47, T8f;
+ {
+ E T3Z, T41, T3Y, T40;
+ T3Z = rio[WS(ios, 21)];
+ T41 = iio[-WS(ios, 42)];
+ T3Y = W[40];
+ T40 = W[41];
+ T42 = FMA(T3Y, T3Z, T40 * T41);
+ T8e = FNMS(T40, T3Z, T3Y * T41);
+ }
+ {
+ E T44, T46, T43, T45;
+ T44 = rio[WS(ios, 53)];
+ T46 = iio[-WS(ios, 10)];
+ T43 = W[104];
+ T45 = W[105];
+ T47 = FMA(T43, T44, T45 * T46);
+ T8f = FNMS(T45, T44, T43 * T46);
+ }
+ T48 = T42 + T47;
+ TdC = T8e + T8f;
+ T8b = T42 - T47;
+ T8g = T8e - T8f;
+ }
+ {
+ E T4e, T82, T4j, T83;
+ {
+ E T4b, T4d, T4a, T4c;
+ T4b = rio[WS(ios, 61)];
+ T4d = iio[-WS(ios, 2)];
+ T4a = W[120];
+ T4c = W[121];
+ T4e = FMA(T4a, T4b, T4c * T4d);
+ T82 = FNMS(T4c, T4b, T4a * T4d);
+ }
+ {
+ E T4g, T4i, T4f, T4h;
+ T4g = rio[WS(ios, 29)];
+ T4i = iio[-WS(ios, 34)];
+ T4f = W[56];
+ T4h = W[57];
+ T4j = FMA(T4f, T4g, T4h * T4i);
+ T83 = FNMS(T4h, T4g, T4f * T4i);
+ }
+ T4k = T4e + T4j;
+ Tdw = T82 + T83;
+ T7X = T4e - T4j;
+ T84 = T82 - T83;
+ }
+ {
+ E T49, T4w, TdA, TdD;
+ T49 = T3X + T48;
+ T4w = T4k + T4v;
+ T4x = T49 + T4w;
+ TfJ = T4w - T49;
+ TdA = T3X - T48;
+ TdD = TdB - TdC;
+ TdE = TdA + TdD;
+ TdM = TdD - TdA;
+ }
+ {
+ E TfM, TfN, T81, T86;
+ TfM = TdB + TdC;
+ TfN = Tdw + Tdx;
+ TfO = TfM - TfN;
+ Tgu = TfM + TfN;
+ T81 = T7X - T80;
+ T86 = T84 + T85;
+ T87 = FNMS(KP923879532, T86, KP382683432 * T81);
+ T8v = FMA(KP382683432, T86, KP923879532 * T81);
+ }
+ {
+ E T8c, T8h, Tb8, Tb9;
+ T8c = T8a + T8b;
+ T8h = T8d - T8g;
+ T8i = FMA(KP923879532, T8c, KP382683432 * T8h);
+ T8u = FNMS(KP923879532, T8h, KP382683432 * T8c);
+ Tb8 = T8a - T8b;
+ Tb9 = T8d + T8g;
+ Tba = FMA(KP382683432, Tb8, KP923879532 * Tb9);
+ Tbg = FNMS(KP382683432, Tb9, KP923879532 * Tb8);
+ }
+ {
+ E Tdv, Tdy, Tb5, Tb6;
+ Tdv = T4k - T4v;
+ Tdy = Tdw - Tdx;
+ Tdz = Tdv - Tdy;
+ TdN = Tdv + Tdy;
+ Tb5 = T7X + T80;
+ Tb6 = T84 - T85;
+ Tb7 = FNMS(KP382683432, Tb6, KP923879532 * Tb5);
+ Tbh = FMA(KP923879532, Tb6, KP382683432 * Tb5);
+ }
+ }
+ {
+ E T1t, Tgn, TgK, TgL, TgV, Th1, T30, Th0, T66, TgX, Tgw, TgE, TgB, TgF, Tgq;
+ E TgM;
+ {
+ E TH, T1s, TgI, TgJ;
+ TH = Tj + TG;
+ T1s = T14 + T1r;
+ T1t = TH + T1s;
+ Tgn = TH - T1s;
+ TgI = Tgt + Tgu;
+ TgJ = Tgy + Tgz;
+ TgK = TgI - TgJ;
+ TgL = TgI + TgJ;
+ }
+ {
+ E TgN, TgU, T2e, T2Z;
+ TgN = Tfq + Tfr;
+ TgU = TgO + TgT;
+ TgV = TgN + TgU;
+ Th1 = TgU - TgN;
+ T2e = T1Q + T2d;
+ T2Z = T2B + T2Y;
+ T30 = T2e + T2Z;
+ Th0 = T2Z - T2e;
+ }
+ {
+ E T4y, T65, Tgs, Tgv;
+ T4y = T3M + T4x;
+ T65 = T5j + T64;
+ T66 = T4y + T65;
+ TgX = T65 - T4y;
+ Tgs = T3M - T4x;
+ Tgv = Tgt - Tgu;
+ Tgw = Tgs + Tgv;
+ TgE = Tgv - Tgs;
+ }
+ {
+ E Tgx, TgA, Tgo, Tgp;
+ Tgx = T5j - T64;
+ TgA = Tgy - Tgz;
+ TgB = Tgx - TgA;
+ TgF = Tgx + TgA;
+ Tgo = Tfu + Tfv;
+ Tgp = TfA + TfB;
+ Tgq = Tgo - Tgp;
+ TgM = Tgo + Tgp;
+ }
+ {
+ E T31, TgW, TgH, TgY;
+ T31 = T1t + T30;
+ iio[-WS(ios, 32)] = T31 - T66;
+ rio[0] = T31 + T66;
+ TgW = TgM + TgV;
+ rio[WS(ios, 32)] = TgL - TgW;
+ iio[0] = TgL + TgW;
+ TgH = T1t - T30;
+ iio[-WS(ios, 48)] = TgH - TgK;
+ rio[WS(ios, 16)] = TgH + TgK;
+ TgY = TgV - TgM;
+ rio[WS(ios, 48)] = TgX - TgY;
+ iio[-WS(ios, 16)] = TgX + TgY;
+ }
+ {
+ E Tgr, TgC, TgZ, Th2;
+ Tgr = Tgn + Tgq;
+ TgC = KP707106781 * (Tgw + TgB);
+ iio[-WS(ios, 40)] = Tgr - TgC;
+ rio[WS(ios, 8)] = Tgr + TgC;
+ TgZ = KP707106781 * (TgE + TgF);
+ Th2 = Th0 + Th1;
+ rio[WS(ios, 40)] = TgZ - Th2;
+ iio[-WS(ios, 8)] = TgZ + Th2;
+ }
+ {
+ E TgD, TgG, Th3, Th4;
+ TgD = Tgn - Tgq;
+ TgG = KP707106781 * (TgE - TgF);
+ iio[-WS(ios, 56)] = TgD - TgG;
+ rio[WS(ios, 24)] = TgD + TgG;
+ Th3 = KP707106781 * (TgB - Tgw);
+ Th4 = Th1 - Th0;
+ rio[WS(ios, 56)] = Th3 - Th4;
+ iio[-WS(ios, 24)] = Th3 + Th4;
+ }
+ }
+ {
+ E Tft, Tg7, Tgh, Tgl, Th9, Thf, TfE, Th6, TfQ, Tg4, Tga, The, Tge, Tgk, Tg1;
+ E Tg5;
+ {
+ E Tfp, Tfs, Tgf, Tgg;
+ Tfp = Tj - TG;
+ Tfs = Tfq - Tfr;
+ Tft = Tfp - Tfs;
+ Tg7 = Tfp + Tfs;
+ Tgf = TfR + TfU;
+ Tgg = TfY + TfZ;
+ Tgh = FNMS(KP382683432, Tgg, KP923879532 * Tgf);
+ Tgl = FMA(KP923879532, Tgg, KP382683432 * Tgf);
+ }
+ {
+ E Th7, Th8, Tfy, TfD;
+ Th7 = T1r - T14;
+ Th8 = TgT - TgO;
+ Th9 = Th7 + Th8;
+ Thf = Th8 - Th7;
+ Tfy = Tfw - Tfx;
+ TfD = Tfz + TfC;
+ TfE = KP707106781 * (Tfy - TfD);
+ Th6 = KP707106781 * (Tfy + TfD);
+ }
+ {
+ E TfK, TfP, Tg8, Tg9;
+ TfK = TfI - TfJ;
+ TfP = TfL - TfO;
+ TfQ = FMA(KP923879532, TfK, KP382683432 * TfP);
+ Tg4 = FNMS(KP923879532, TfP, KP382683432 * TfK);
+ Tg8 = Tfx + Tfw;
+ Tg9 = Tfz - TfC;
+ Tga = KP707106781 * (Tg8 + Tg9);
+ The = KP707106781 * (Tg9 - Tg8);
+ }
+ {
+ E Tgc, Tgd, TfV, Tg0;
+ Tgc = TfI + TfJ;
+ Tgd = TfL + TfO;
+ Tge = FMA(KP382683432, Tgc, KP923879532 * Tgd);
+ Tgk = FNMS(KP382683432, Tgd, KP923879532 * Tgc);
+ TfV = TfR - TfU;
+ Tg0 = TfY - TfZ;
+ Tg1 = FNMS(KP923879532, Tg0, KP382683432 * TfV);
+ Tg5 = FMA(KP382683432, Tg0, KP923879532 * TfV);
+ }
+ {
+ E TfF, Tg2, Thd, Thg;
+ TfF = Tft + TfE;
+ Tg2 = TfQ + Tg1;
+ iio[-WS(ios, 44)] = TfF - Tg2;
+ rio[WS(ios, 12)] = TfF + Tg2;
+ Thd = Tg4 + Tg5;
+ Thg = The + Thf;
+ rio[WS(ios, 44)] = Thd - Thg;
+ iio[-WS(ios, 12)] = Thd + Thg;
+ }
+ {
+ E Tg3, Tg6, Thh, Thi;
+ Tg3 = Tft - TfE;
+ Tg6 = Tg4 - Tg5;
+ iio[-WS(ios, 60)] = Tg3 - Tg6;
+ rio[WS(ios, 28)] = Tg3 + Tg6;
+ Thh = Tg1 - TfQ;
+ Thi = Thf - The;
+ rio[WS(ios, 60)] = Thh - Thi;
+ iio[-WS(ios, 28)] = Thh + Thi;
+ }
+ {
+ E Tgb, Tgi, Th5, Tha;
+ Tgb = Tg7 + Tga;
+ Tgi = Tge + Tgh;
+ iio[-WS(ios, 36)] = Tgb - Tgi;
+ rio[WS(ios, 4)] = Tgb + Tgi;
+ Th5 = Tgk + Tgl;
+ Tha = Th6 + Th9;
+ rio[WS(ios, 36)] = Th5 - Tha;
+ iio[-WS(ios, 4)] = Th5 + Tha;
+ }
+ {
+ E Tgj, Tgm, Thb, Thc;
+ Tgj = Tg7 - Tga;
+ Tgm = Tgk - Tgl;
+ iio[-WS(ios, 52)] = Tgj - Tgm;
+ rio[WS(ios, 20)] = Tgj + Tgm;
+ Thb = Tgh - Tge;
+ Thc = Th9 - Th6;
+ rio[WS(ios, 52)] = Thb - Thc;
+ iio[-WS(ios, 20)] = Thb + Thc;
+ }
+ }
+ {
+ E Td1, Ten, Tdo, ThA, ThD, ThJ, Teq, ThI, Teh, TeB, Tel, Tex, TdQ, TeA, Tek;
+ E Teu;
+ {
+ E TcP, Td0, Teo, Tep;
+ TcP = TcL - TcO;
+ Td0 = KP707106781 * (TcU - TcZ);
+ Td1 = TcP - Td0;
+ Ten = TcP + Td0;
+ {
+ E Tdc, Tdn, ThB, ThC;
+ Tdc = FNMS(KP923879532, Tdb, KP382683432 * Td6);
+ Tdn = FMA(KP382683432, Tdh, KP923879532 * Tdm);
+ Tdo = Tdc - Tdn;
+ ThA = Tdc + Tdn;
+ ThB = KP707106781 * (TeF - TeE);
+ ThC = Thn - Thm;
+ ThD = ThB + ThC;
+ ThJ = ThC - ThB;
+ }
+ Teo = FMA(KP923879532, Td6, KP382683432 * Tdb);
+ Tep = FNMS(KP923879532, Tdh, KP382683432 * Tdm);
+ Teq = Teo + Tep;
+ ThI = Tep - Teo;
+ {
+ E Te7, Tev, Teg, Tew, Te6, Tef;
+ Te6 = KP707106781 * (Te0 - Te5);
+ Te7 = TdV - Te6;
+ Tev = TdV + Te6;
+ Tef = KP707106781 * (Ted - Tee);
+ Teg = Tec - Tef;
+ Tew = Tec + Tef;
+ Teh = FNMS(KP980785280, Teg, KP195090322 * Te7);
+ TeB = FMA(KP831469612, Tew, KP555570233 * Tev);
+ Tel = FMA(KP195090322, Teg, KP980785280 * Te7);
+ Tex = FNMS(KP555570233, Tew, KP831469612 * Tev);
+ }
+ {
+ E TdG, Tes, TdP, Tet, TdF, TdO;
+ TdF = KP707106781 * (Tdz - TdE);
+ TdG = Tdu - TdF;
+ Tes = Tdu + TdF;
+ TdO = KP707106781 * (TdM - TdN);
+ TdP = TdL - TdO;
+ Tet = TdL + TdO;
+ TdQ = FMA(KP980785280, TdG, KP195090322 * TdP);
+ TeA = FNMS(KP555570233, Tet, KP831469612 * Tes);
+ Tek = FNMS(KP980785280, TdP, KP195090322 * TdG);
+ Teu = FMA(KP555570233, Tes, KP831469612 * Tet);
+ }
+ }
+ {
+ E Tdp, Tei, ThH, ThK;
+ Tdp = Td1 + Tdo;
+ Tei = TdQ + Teh;
+ iio[-WS(ios, 46)] = Tdp - Tei;
+ rio[WS(ios, 14)] = Tdp + Tei;
+ ThH = Tek + Tel;
+ ThK = ThI + ThJ;
+ rio[WS(ios, 46)] = ThH - ThK;
+ iio[-WS(ios, 14)] = ThH + ThK;
+ }
+ {
+ E Tej, Tem, ThL, ThM;
+ Tej = Td1 - Tdo;
+ Tem = Tek - Tel;
+ iio[-WS(ios, 62)] = Tej - Tem;
+ rio[WS(ios, 30)] = Tej + Tem;
+ ThL = Teh - TdQ;
+ ThM = ThJ - ThI;
+ rio[WS(ios, 62)] = ThL - ThM;
+ iio[-WS(ios, 30)] = ThL + ThM;
+ }
+ {
+ E Ter, Tey, Thz, ThE;
+ Ter = Ten + Teq;
+ Tey = Teu + Tex;
+ iio[-WS(ios, 38)] = Ter - Tey;
+ rio[WS(ios, 6)] = Ter + Tey;
+ Thz = TeA + TeB;
+ ThE = ThA + ThD;
+ rio[WS(ios, 38)] = Thz - ThE;
+ iio[-WS(ios, 6)] = Thz + ThE;
+ }
+ {
+ E Tez, TeC, ThF, ThG;
+ Tez = Ten - Teq;
+ TeC = TeA - TeB;
+ iio[-WS(ios, 54)] = Tez - TeC;
+ rio[WS(ios, 22)] = Tez + TeC;
+ ThF = Tex - Teu;
+ ThG = ThD - ThA;
+ rio[WS(ios, 54)] = ThF - ThG;
+ iio[-WS(ios, 22)] = ThF + ThG;
+ }
+ }
+ {
+ E TeH, Tf9, TeO, Thk, Thp, Thv, Tfc, Thu, Tf3, Tfn, Tf7, Tfj, TeW, Tfm, Tf6;
+ E Tfg;
+ {
+ E TeD, TeG, Tfa, Tfb;
+ TeD = TcL + TcO;
+ TeG = KP707106781 * (TeE + TeF);
+ TeH = TeD - TeG;
+ Tf9 = TeD + TeG;
+ {
+ E TeK, TeN, Thl, Tho;
+ TeK = FNMS(KP382683432, TeJ, KP923879532 * TeI);
+ TeN = FMA(KP923879532, TeL, KP382683432 * TeM);
+ TeO = TeK - TeN;
+ Thk = TeK + TeN;
+ Thl = KP707106781 * (TcU + TcZ);
+ Tho = Thm + Thn;
+ Thp = Thl + Tho;
+ Thv = Tho - Thl;
+ }
+ Tfa = FMA(KP382683432, TeI, KP923879532 * TeJ);
+ Tfb = FNMS(KP382683432, TeL, KP923879532 * TeM);
+ Tfc = Tfa + Tfb;
+ Thu = Tfb - Tfa;
+ {
+ E TeZ, Tfh, Tf2, Tfi, TeY, Tf1;
+ TeY = KP707106781 * (Tee + Ted);
+ TeZ = TeX - TeY;
+ Tfh = TeX + TeY;
+ Tf1 = KP707106781 * (Te0 + Te5);
+ Tf2 = Tf0 - Tf1;
+ Tfi = Tf0 + Tf1;
+ Tf3 = FNMS(KP831469612, Tf2, KP555570233 * TeZ);
+ Tfn = FMA(KP195090322, Tfh, KP980785280 * Tfi);
+ Tf7 = FMA(KP831469612, TeZ, KP555570233 * Tf2);
+ Tfj = FNMS(KP195090322, Tfi, KP980785280 * Tfh);
+ }
+ {
+ E TeS, Tfe, TeV, Tff, TeR, TeU;
+ TeR = KP707106781 * (TdE + Tdz);
+ TeS = TeQ - TeR;
+ Tfe = TeQ + TeR;
+ TeU = KP707106781 * (TdM + TdN);
+ TeV = TeT - TeU;
+ Tff = TeT + TeU;
+ TeW = FMA(KP555570233, TeS, KP831469612 * TeV);
+ Tfm = FNMS(KP195090322, Tfe, KP980785280 * Tff);
+ Tf6 = FNMS(KP831469612, TeS, KP555570233 * TeV);
+ Tfg = FMA(KP980785280, Tfe, KP195090322 * Tff);
+ }
+ }
+ {
+ E TeP, Tf4, Tht, Thw;
+ TeP = TeH + TeO;
+ Tf4 = TeW + Tf3;
+ iio[-WS(ios, 42)] = TeP - Tf4;
+ rio[WS(ios, 10)] = TeP + Tf4;
+ Tht = Tf6 + Tf7;
+ Thw = Thu + Thv;
+ rio[WS(ios, 42)] = Tht - Thw;
+ iio[-WS(ios, 10)] = Tht + Thw;
+ }
+ {
+ E Tf5, Tf8, Thx, Thy;
+ Tf5 = TeH - TeO;
+ Tf8 = Tf6 - Tf7;
+ iio[-WS(ios, 58)] = Tf5 - Tf8;
+ rio[WS(ios, 26)] = Tf5 + Tf8;
+ Thx = Tf3 - TeW;
+ Thy = Thv - Thu;
+ rio[WS(ios, 58)] = Thx - Thy;
+ iio[-WS(ios, 26)] = Thx + Thy;
+ }
+ {
+ E Tfd, Tfk, Thj, Thq;
+ Tfd = Tf9 + Tfc;
+ Tfk = Tfg + Tfj;
+ iio[-WS(ios, 34)] = Tfd - Tfk;
+ rio[WS(ios, 2)] = Tfd + Tfk;
+ Thj = Tfm + Tfn;
+ Thq = Thk + Thp;
+ rio[WS(ios, 34)] = Thj - Thq;
+ iio[-WS(ios, 2)] = Thj + Thq;
+ }
+ {
+ E Tfl, Tfo, Thr, Ths;
+ Tfl = Tf9 - Tfc;
+ Tfo = Tfm - Tfn;
+ iio[-WS(ios, 50)] = Tfl - Tfo;
+ rio[WS(ios, 18)] = Tfl + Tfo;
+ Thr = Tfj - Tfg;
+ Ths = Thp - Thk;
+ rio[WS(ios, 50)] = Thr - Ths;
+ iio[-WS(ios, 18)] = Thr + Ths;
+ }
+ }
+ {
+ E T6L, T9x, TiD, TiJ, T7E, TiI, T9A, TiA, T8y, T9K, T9u, T9E, T9r, T9L, T9v;
+ E T9H;
+ {
+ E T6n, T6K, TiB, TiC;
+ T6n = T6b - T6m;
+ T6K = T6y - T6J;
+ T6L = T6n - T6K;
+ T9x = T6n + T6K;
+ TiB = T9P - T9O;
+ TiC = Tin - Tim;
+ TiD = TiB + TiC;
+ TiJ = TiC - TiB;
+ }
+ {
+ E T7c, T9y, T7D, T9z;
+ {
+ E T72, T7b, T7t, T7C;
+ T72 = T6Q - T71;
+ T7b = T77 - T7a;
+ T7c = FNMS(KP980785280, T7b, KP195090322 * T72);
+ T9y = FMA(KP980785280, T72, KP195090322 * T7b);
+ T7t = T7h - T7s;
+ T7C = T7y - T7B;
+ T7D = FMA(KP195090322, T7t, KP980785280 * T7C);
+ T9z = FNMS(KP980785280, T7t, KP195090322 * T7C);
+ }
+ T7E = T7c - T7D;
+ TiI = T9z - T9y;
+ T9A = T9y + T9z;
+ TiA = T7c + T7D;
+ }
+ {
+ E T8k, T9C, T8x, T9D;
+ {
+ E T7W, T8j, T8t, T8w;
+ T7W = T7K - T7V;
+ T8j = T87 - T8i;
+ T8k = T7W - T8j;
+ T9C = T7W + T8j;
+ T8t = T8p - T8s;
+ T8w = T8u - T8v;
+ T8x = T8t - T8w;
+ T9D = T8t + T8w;
+ }
+ T8y = FMA(KP995184726, T8k, KP098017140 * T8x);
+ T9K = FNMS(KP634393284, T9D, KP773010453 * T9C);
+ T9u = FNMS(KP995184726, T8x, KP098017140 * T8k);
+ T9E = FMA(KP634393284, T9C, KP773010453 * T9D);
+ }
+ {
+ E T9d, T9F, T9q, T9G;
+ {
+ E T8P, T9c, T9m, T9p;
+ T8P = T8D - T8O;
+ T9c = T90 - T9b;
+ T9d = T8P - T9c;
+ T9F = T8P + T9c;
+ T9m = T9i - T9l;
+ T9p = T9n - T9o;
+ T9q = T9m - T9p;
+ T9G = T9m + T9p;
+ }
+ T9r = FNMS(KP995184726, T9q, KP098017140 * T9d);
+ T9L = FMA(KP773010453, T9G, KP634393284 * T9F);
+ T9v = FMA(KP098017140, T9q, KP995184726 * T9d);
+ T9H = FNMS(KP634393284, T9G, KP773010453 * T9F);
+ }
+ {
+ E T7F, T9s, TiH, TiK;
+ T7F = T6L + T7E;
+ T9s = T8y + T9r;
+ iio[-WS(ios, 47)] = T7F - T9s;
+ rio[WS(ios, 15)] = T7F + T9s;
+ TiH = T9u + T9v;
+ TiK = TiI + TiJ;
+ rio[WS(ios, 47)] = TiH - TiK;
+ iio[-WS(ios, 15)] = TiH + TiK;
+ }
+ {
+ E T9t, T9w, TiL, TiM;
+ T9t = T6L - T7E;
+ T9w = T9u - T9v;
+ iio[-WS(ios, 63)] = T9t - T9w;
+ rio[WS(ios, 31)] = T9t + T9w;
+ TiL = T9r - T8y;
+ TiM = TiJ - TiI;
+ rio[WS(ios, 63)] = TiL - TiM;
+ iio[-WS(ios, 31)] = TiL + TiM;
+ }
+ {
+ E T9B, T9I, Tiz, TiE;
+ T9B = T9x + T9A;
+ T9I = T9E + T9H;
+ iio[-WS(ios, 39)] = T9B - T9I;
+ rio[WS(ios, 7)] = T9B + T9I;
+ Tiz = T9K + T9L;
+ TiE = TiA + TiD;
+ rio[WS(ios, 39)] = Tiz - TiE;
+ iio[-WS(ios, 7)] = Tiz + TiE;
+ }
+ {
+ E T9J, T9M, TiF, TiG;
+ T9J = T9x - T9A;
+ T9M = T9K - T9L;
+ iio[-WS(ios, 55)] = T9J - T9M;
+ rio[WS(ios, 23)] = T9J + T9M;
+ TiF = T9H - T9E;
+ TiG = TiD - TiA;
+ rio[WS(ios, 55)] = TiF - TiG;
+ iio[-WS(ios, 23)] = TiF + TiG;
+ }
+ }
+ {
+ E TaL, TbJ, Ti9, Tif, Tb0, Tie, TbM, Ti6, Tbk, TbW, TbG, TbQ, TbD, TbX, TbH;
+ E TbT;
+ {
+ E TaD, TaK, Ti7, Ti8;
+ TaD = Taz - TaC;
+ TaK = TaG - TaJ;
+ TaL = TaD - TaK;
+ TbJ = TaD + TaK;
+ Ti7 = Tc1 - Tc0;
+ Ti8 = ThT - ThQ;
+ Ti9 = Ti7 + Ti8;
+ Tif = Ti8 - Ti7;
+ }
+ {
+ E TaS, TbK, TaZ, TbL;
+ {
+ E TaO, TaR, TaV, TaY;
+ TaO = TaM - TaN;
+ TaR = TaP - TaQ;
+ TaS = FNMS(KP831469612, TaR, KP555570233 * TaO);
+ TbK = FMA(KP555570233, TaR, KP831469612 * TaO);
+ TaV = TaT - TaU;
+ TaY = TaW - TaX;
+ TaZ = FMA(KP831469612, TaV, KP555570233 * TaY);
+ TbL = FNMS(KP831469612, TaY, KP555570233 * TaV);
+ }
+ Tb0 = TaS - TaZ;
+ Tie = TbL - TbK;
+ TbM = TbK + TbL;
+ Ti6 = TaS + TaZ;
+ }
+ {
+ E Tbc, TbO, Tbj, TbP;
+ {
+ E Tb4, Tbb, Tbf, Tbi;
+ Tb4 = Tb2 - Tb3;
+ Tbb = Tb7 - Tba;
+ Tbc = Tb4 - Tbb;
+ TbO = Tb4 + Tbb;
+ Tbf = Tbd - Tbe;
+ Tbi = Tbg - Tbh;
+ Tbj = Tbf - Tbi;
+ TbP = Tbf + Tbi;
+ }
+ Tbk = FMA(KP956940335, Tbc, KP290284677 * Tbj);
+ TbW = FNMS(KP471396736, TbP, KP881921264 * TbO);
+ TbG = FNMS(KP956940335, Tbj, KP290284677 * Tbc);
+ TbQ = FMA(KP471396736, TbO, KP881921264 * TbP);
+ }
+ {
+ E Tbv, TbR, TbC, TbS;
+ {
+ E Tbn, Tbu, Tby, TbB;
+ Tbn = Tbl - Tbm;
+ Tbu = Tbq - Tbt;
+ Tbv = Tbn - Tbu;
+ TbR = Tbn + Tbu;
+ Tby = Tbw - Tbx;
+ TbB = Tbz - TbA;
+ TbC = Tby - TbB;
+ TbS = Tby + TbB;
+ }
+ TbD = FNMS(KP956940335, TbC, KP290284677 * Tbv);
+ TbX = FMA(KP881921264, TbS, KP471396736 * TbR);
+ TbH = FMA(KP290284677, TbC, KP956940335 * Tbv);
+ TbT = FNMS(KP471396736, TbS, KP881921264 * TbR);
+ }
+ {
+ E Tb1, TbE, Tid, Tig;
+ Tb1 = TaL + Tb0;
+ TbE = Tbk + TbD;
+ iio[-WS(ios, 45)] = Tb1 - TbE;
+ rio[WS(ios, 13)] = Tb1 + TbE;
+ Tid = TbG + TbH;
+ Tig = Tie + Tif;
+ rio[WS(ios, 45)] = Tid - Tig;
+ iio[-WS(ios, 13)] = Tid + Tig;
+ }
+ {
+ E TbF, TbI, Tih, Tii;
+ TbF = TaL - Tb0;
+ TbI = TbG - TbH;
+ iio[-WS(ios, 61)] = TbF - TbI;
+ rio[WS(ios, 29)] = TbF + TbI;
+ Tih = TbD - Tbk;
+ Tii = Tif - Tie;
+ rio[WS(ios, 61)] = Tih - Tii;
+ iio[-WS(ios, 29)] = Tih + Tii;
+ }
+ {
+ E TbN, TbU, Ti5, Tia;
+ TbN = TbJ + TbM;
+ TbU = TbQ + TbT;
+ iio[-WS(ios, 37)] = TbN - TbU;
+ rio[WS(ios, 5)] = TbN + TbU;
+ Ti5 = TbW + TbX;
+ Tia = Ti6 + Ti9;
+ rio[WS(ios, 37)] = Ti5 - Tia;
+ iio[-WS(ios, 5)] = Ti5 + Tia;
+ }
+ {
+ E TbV, TbY, Tib, Tic;
+ TbV = TbJ - TbM;
+ TbY = TbW - TbX;
+ iio[-WS(ios, 53)] = TbV - TbY;
+ rio[WS(ios, 21)] = TbV + TbY;
+ Tib = TbT - TbQ;
+ Tic = Ti9 - Ti6;
+ rio[WS(ios, 53)] = Tib - Tic;
+ iio[-WS(ios, 21)] = Tib + Tic;
+ }
+ }
+ {
+ E Tc3, Tcv, ThV, Ti1, Tca, Ti0, Tcy, ThO, Tci, TcI, Tcs, TcC, Tcp, TcJ, Tct;
+ E TcF;
+ {
+ E TbZ, Tc2, ThP, ThU;
+ TbZ = Taz + TaC;
+ Tc2 = Tc0 + Tc1;
+ Tc3 = TbZ - Tc2;
+ Tcv = TbZ + Tc2;
+ ThP = TaG + TaJ;
+ ThU = ThQ + ThT;
+ ThV = ThP + ThU;
+ Ti1 = ThU - ThP;
+ }
+ {
+ E Tc6, Tcw, Tc9, Tcx;
+ {
+ E Tc4, Tc5, Tc7, Tc8;
+ Tc4 = TaM + TaN;
+ Tc5 = TaP + TaQ;
+ Tc6 = FNMS(KP195090322, Tc5, KP980785280 * Tc4);
+ Tcw = FMA(KP980785280, Tc5, KP195090322 * Tc4);
+ Tc7 = TaT + TaU;
+ Tc8 = TaW + TaX;
+ Tc9 = FMA(KP195090322, Tc7, KP980785280 * Tc8);
+ Tcx = FNMS(KP195090322, Tc8, KP980785280 * Tc7);
+ }
+ Tca = Tc6 - Tc9;
+ Ti0 = Tcx - Tcw;
+ Tcy = Tcw + Tcx;
+ ThO = Tc6 + Tc9;
+ }
+ {
+ E Tce, TcA, Tch, TcB;
+ {
+ E Tcc, Tcd, Tcf, Tcg;
+ Tcc = Tbd + Tbe;
+ Tcd = Tba + Tb7;
+ Tce = Tcc - Tcd;
+ TcA = Tcc + Tcd;
+ Tcf = Tb2 + Tb3;
+ Tcg = Tbg + Tbh;
+ Tch = Tcf - Tcg;
+ TcB = Tcf + Tcg;
+ }
+ Tci = FMA(KP634393284, Tce, KP773010453 * Tch);
+ TcI = FNMS(KP098017140, TcA, KP995184726 * TcB);
+ Tcs = FNMS(KP773010453, Tce, KP634393284 * Tch);
+ TcC = FMA(KP995184726, TcA, KP098017140 * TcB);
+ }
+ {
+ E Tcl, TcD, Tco, TcE;
+ {
+ E Tcj, Tck, Tcm, Tcn;
+ Tcj = Tbl + Tbm;
+ Tck = TbA + Tbz;
+ Tcl = Tcj - Tck;
+ TcD = Tcj + Tck;
+ Tcm = Tbw + Tbx;
+ Tcn = Tbq + Tbt;
+ Tco = Tcm - Tcn;
+ TcE = Tcm + Tcn;
+ }
+ Tcp = FNMS(KP773010453, Tco, KP634393284 * Tcl);
+ TcJ = FMA(KP098017140, TcD, KP995184726 * TcE);
+ Tct = FMA(KP773010453, Tcl, KP634393284 * Tco);
+ TcF = FNMS(KP098017140, TcE, KP995184726 * TcD);
+ }
+ {
+ E Tcb, Tcq, ThZ, Ti2;
+ Tcb = Tc3 + Tca;
+ Tcq = Tci + Tcp;
+ iio[-WS(ios, 41)] = Tcb - Tcq;
+ rio[WS(ios, 9)] = Tcb + Tcq;
+ ThZ = Tcs + Tct;
+ Ti2 = Ti0 + Ti1;
+ rio[WS(ios, 41)] = ThZ - Ti2;
+ iio[-WS(ios, 9)] = ThZ + Ti2;
+ }
+ {
+ E Tcr, Tcu, Ti3, Ti4;
+ Tcr = Tc3 - Tca;
+ Tcu = Tcs - Tct;
+ iio[-WS(ios, 57)] = Tcr - Tcu;
+ rio[WS(ios, 25)] = Tcr + Tcu;
+ Ti3 = Tcp - Tci;
+ Ti4 = Ti1 - Ti0;
+ rio[WS(ios, 57)] = Ti3 - Ti4;
+ iio[-WS(ios, 25)] = Ti3 + Ti4;
+ }
+ {
+ E Tcz, TcG, ThN, ThW;
+ Tcz = Tcv + Tcy;
+ TcG = TcC + TcF;
+ iio[-WS(ios, 33)] = Tcz - TcG;
+ rio[WS(ios, 1)] = Tcz + TcG;
+ ThN = TcI + TcJ;
+ ThW = ThO + ThV;
+ rio[WS(ios, 33)] = ThN - ThW;
+ iio[-WS(ios, 1)] = ThN + ThW;
+ }
+ {
+ E TcH, TcK, ThX, ThY;
+ TcH = Tcv - Tcy;
+ TcK = TcI - TcJ;
+ iio[-WS(ios, 49)] = TcH - TcK;
+ rio[WS(ios, 17)] = TcH + TcK;
+ ThX = TcF - TcC;
+ ThY = ThV - ThO;
+ rio[WS(ios, 49)] = ThX - ThY;
+ iio[-WS(ios, 17)] = ThX + ThY;
+ }
+ }
+ {
+ E T9R, Taj, Tip, Tiv, T9Y, Tiu, Tam, Tik, Ta6, Taw, Tag, Taq, Tad, Tax, Tah;
+ E Tat;
+ {
+ E T9N, T9Q, Til, Tio;
+ T9N = T6b + T6m;
+ T9Q = T9O + T9P;
+ T9R = T9N - T9Q;
+ Taj = T9N + T9Q;
+ Til = T6y + T6J;
+ Tio = Tim + Tin;
+ Tip = Til + Tio;
+ Tiv = Tio - Til;
+ }
+ {
+ E T9U, Tak, T9X, Tal;
+ {
+ E T9S, T9T, T9V, T9W;
+ T9S = T6Q + T71;
+ T9T = T77 + T7a;
+ T9U = FNMS(KP555570233, T9T, KP831469612 * T9S);
+ Tak = FMA(KP555570233, T9S, KP831469612 * T9T);
+ T9V = T7h + T7s;
+ T9W = T7y + T7B;
+ T9X = FMA(KP831469612, T9V, KP555570233 * T9W);
+ Tal = FNMS(KP555570233, T9V, KP831469612 * T9W);
+ }
+ T9Y = T9U - T9X;
+ Tiu = Tal - Tak;
+ Tam = Tak + Tal;
+ Tik = T9U + T9X;
+ }
+ {
+ E Ta2, Tao, Ta5, Tap;
+ {
+ E Ta0, Ta1, Ta3, Ta4;
+ Ta0 = T8p + T8s;
+ Ta1 = T8i + T87;
+ Ta2 = Ta0 - Ta1;
+ Tao = Ta0 + Ta1;
+ Ta3 = T7K + T7V;
+ Ta4 = T8u + T8v;
+ Ta5 = Ta3 - Ta4;
+ Tap = Ta3 + Ta4;
+ }
+ Ta6 = FMA(KP471396736, Ta2, KP881921264 * Ta5);
+ Taw = FNMS(KP290284677, Tao, KP956940335 * Tap);
+ Tag = FNMS(KP881921264, Ta2, KP471396736 * Ta5);
+ Taq = FMA(KP956940335, Tao, KP290284677 * Tap);
+ }
+ {
+ E Ta9, Tar, Tac, Tas;
+ {
+ E Ta7, Ta8, Taa, Tab;
+ Ta7 = T8D + T8O;
+ Ta8 = T9o + T9n;
+ Ta9 = Ta7 - Ta8;
+ Tar = Ta7 + Ta8;
+ Taa = T9i + T9l;
+ Tab = T90 + T9b;
+ Tac = Taa - Tab;
+ Tas = Taa + Tab;
+ }
+ Tad = FNMS(KP881921264, Tac, KP471396736 * Ta9);
+ Tax = FMA(KP290284677, Tar, KP956940335 * Tas);
+ Tah = FMA(KP881921264, Ta9, KP471396736 * Tac);
+ Tat = FNMS(KP290284677, Tas, KP956940335 * Tar);
+ }
+ {
+ E T9Z, Tae, Tit, Tiw;
+ T9Z = T9R + T9Y;
+ Tae = Ta6 + Tad;
+ iio[-WS(ios, 43)] = T9Z - Tae;
+ rio[WS(ios, 11)] = T9Z + Tae;
+ Tit = Tag + Tah;
+ Tiw = Tiu + Tiv;
+ rio[WS(ios, 43)] = Tit - Tiw;
+ iio[-WS(ios, 11)] = Tit + Tiw;
+ }
+ {
+ E Taf, Tai, Tix, Tiy;
+ Taf = T9R - T9Y;
+ Tai = Tag - Tah;
+ iio[-WS(ios, 59)] = Taf - Tai;
+ rio[WS(ios, 27)] = Taf + Tai;
+ Tix = Tad - Ta6;
+ Tiy = Tiv - Tiu;
+ rio[WS(ios, 59)] = Tix - Tiy;
+ iio[-WS(ios, 27)] = Tix + Tiy;
+ }
+ {
+ E Tan, Tau, Tij, Tiq;
+ Tan = Taj + Tam;
+ Tau = Taq + Tat;
+ iio[-WS(ios, 35)] = Tan - Tau;
+ rio[WS(ios, 3)] = Tan + Tau;
+ Tij = Taw + Tax;
+ Tiq = Tik + Tip;
+ rio[WS(ios, 35)] = Tij - Tiq;
+ iio[-WS(ios, 3)] = Tij + Tiq;
+ }
+ {
+ E Tav, Tay, Tir, Tis;
+ Tav = Taj - Tam;
+ Tay = Taw - Tax;
+ iio[-WS(ios, 51)] = Tav - Tay;
+ rio[WS(ios, 19)] = Tav + Tay;
+ Tir = Tat - Taq;
+ Tis = Tip - Tik;
+ rio[WS(ios, 51)] = Tir - Tis;
+ iio[-WS(ios, 19)] = Tir + Tis;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 64},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 64, "hf_64", twinstr, {808, 270, 230, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_64) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_64, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_7.c b/src/fftw3/rdft/codelets/r2hc/hf_7.c
new file mode 100644
index 0000000..df7b4ac
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_7.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:56 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 7 -dit -name hf_7 -include hf.h */
+
+/*
+ * This function contains 72 FP additions, 60 FP multiplications,
+ * (or, 36 additions, 24 multiplications, 36 fused multiply/add),
+ * 29 stack variables, and 28 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_7(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP222520933, +0.222520933956314404288902564496794759466355569);
+ DK(KP900968867, +0.900968867902419126236102319507445051165919162);
+ DK(KP623489801, +0.623489801858733530525004884004239810632274731);
+ DK(KP433883739, +0.433883739117558120475768332848358754609990728);
+ DK(KP781831482, +0.781831482468029808708444526674057750232334519);
+ DK(KP974927912, +0.974927912181823607018131682993931217232785801);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 12) {
+ E T1, Tc, TS, TC, TO, TR, Tn, TT, TI, TP, Ty, TU, TF, TQ;
+ T1 = rio[0];
+ {
+ E T6, TA, Tb, TB;
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 1)];
+ T5 = iio[-WS(ios, 5)];
+ T2 = W[0];
+ T4 = W[1];
+ T6 = FMA(T2, T3, T4 * T5);
+ TA = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 6)];
+ Ta = iio[0];
+ T7 = W[10];
+ T9 = W[11];
+ Tb = FMA(T7, T8, T9 * Ta);
+ TB = FNMS(T9, T8, T7 * Ta);
+ }
+ Tc = T6 + Tb;
+ TS = Tb - T6;
+ TC = TA - TB;
+ TO = TA + TB;
+ }
+ TR = iio[-WS(ios, 6)];
+ {
+ E Th, TG, Tm, TH;
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 2)];
+ Tg = iio[-WS(ios, 4)];
+ Td = W[2];
+ Tf = W[3];
+ Th = FMA(Td, Te, Tf * Tg);
+ TG = FNMS(Tf, Te, Td * Tg);
+ }
+ {
+ E Tj, Tl, Ti, Tk;
+ Tj = rio[WS(ios, 5)];
+ Tl = iio[-WS(ios, 1)];
+ Ti = W[8];
+ Tk = W[9];
+ Tm = FMA(Ti, Tj, Tk * Tl);
+ TH = FNMS(Tk, Tj, Ti * Tl);
+ }
+ Tn = Th + Tm;
+ TT = Tm - Th;
+ TI = TG - TH;
+ TP = TG + TH;
+ }
+ {
+ E Ts, TD, Tx, TE;
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 3)];
+ Tr = iio[-WS(ios, 3)];
+ To = W[4];
+ Tq = W[5];
+ Ts = FMA(To, Tp, Tq * Tr);
+ TD = FNMS(Tq, Tp, To * Tr);
+ }
+ {
+ E Tu, Tw, Tt, Tv;
+ Tu = rio[WS(ios, 4)];
+ Tw = iio[-WS(ios, 2)];
+ Tt = W[6];
+ Tv = W[7];
+ Tx = FMA(Tt, Tu, Tv * Tw);
+ TE = FNMS(Tv, Tu, Tt * Tw);
+ }
+ Ty = Ts + Tx;
+ TU = Tx - Ts;
+ TF = TD - TE;
+ TQ = TD + TE;
+ }
+ rio[0] = T1 + Tc + Tn + Ty;
+ iio[0] = TO + TP + TQ + TR;
+ {
+ E TJ, Tz, TX, TY;
+ TJ = FNMS(KP781831482, TF, KP974927912 * TC) - (KP433883739 * TI);
+ Tz = FMA(KP623489801, Ty, T1) + FNMA(KP900968867, Tn, KP222520933 * Tc);
+ iio[-WS(ios, 5)] = Tz - TJ;
+ rio[WS(ios, 2)] = Tz + TJ;
+ TX = FNMS(KP781831482, TU, KP974927912 * TS) - (KP433883739 * TT);
+ TY = FMA(KP623489801, TQ, TR) + FNMA(KP900968867, TP, KP222520933 * TO);
+ rio[WS(ios, 5)] = TX - TY;
+ iio[-WS(ios, 2)] = TX + TY;
+ }
+ {
+ E TL, TK, TV, TW;
+ TL = FMA(KP781831482, TC, KP974927912 * TI) + (KP433883739 * TF);
+ TK = FMA(KP623489801, Tc, T1) + FNMA(KP900968867, Ty, KP222520933 * Tn);
+ iio[-WS(ios, 6)] = TK - TL;
+ rio[WS(ios, 1)] = TK + TL;
+ TV = FMA(KP781831482, TS, KP974927912 * TT) + (KP433883739 * TU);
+ TW = FMA(KP623489801, TO, TR) + FNMA(KP900968867, TQ, KP222520933 * TP);
+ rio[WS(ios, 6)] = TV - TW;
+ iio[-WS(ios, 1)] = TV + TW;
+ }
+ {
+ E TN, TM, TZ, T10;
+ TN = FMA(KP433883739, TC, KP974927912 * TF) - (KP781831482 * TI);
+ TM = FMA(KP623489801, Tn, T1) + FNMA(KP222520933, Ty, KP900968867 * Tc);
+ iio[-WS(ios, 4)] = TM - TN;
+ rio[WS(ios, 3)] = TM + TN;
+ TZ = FMA(KP433883739, TS, KP974927912 * TU) - (KP781831482 * TT);
+ T10 = FMA(KP623489801, TP, TR) + FNMA(KP222520933, TQ, KP900968867 * TO);
+ rio[WS(ios, 4)] = TZ - T10;
+ iio[-WS(ios, 3)] = TZ + T10;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 7},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 7, "hf_7", twinstr, {36, 24, 36, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_7) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_7, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_8.c b/src/fftw3/rdft/codelets/r2hc/hf_8.c
new file mode 100644
index 0000000..21dedce
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_8.c
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:58 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 8 -dit -name hf_8 -include hf.h */
+
+/*
+ * This function contains 66 FP additions, 32 FP multiplications,
+ * (or, 52 additions, 18 multiplications, 14 fused multiply/add),
+ * 28 stack variables, and 32 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_8(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 14) {
+ E T7, T1e, TH, T19, TF, T13, TR, TU, Ti, T1f, TK, T16, Tu, T12, TM;
+ E TP;
+ {
+ E T1, T18, T6, T17;
+ T1 = rio[0];
+ T18 = iio[-WS(ios, 7)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 4)];
+ T5 = iio[-WS(ios, 3)];
+ T2 = W[6];
+ T4 = W[7];
+ T6 = FMA(T2, T3, T4 * T5);
+ T17 = FNMS(T4, T3, T2 * T5);
+ }
+ T7 = T1 + T6;
+ T1e = T18 - T17;
+ TH = T1 - T6;
+ T19 = T17 + T18;
+ }
+ {
+ E Tz, TS, TE, TT;
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 7)];
+ Ty = iio[0];
+ Tv = W[12];
+ Tx = W[13];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ TS = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 3)];
+ TD = iio[-WS(ios, 4)];
+ TA = W[4];
+ TC = W[5];
+ TE = FMA(TA, TB, TC * TD);
+ TT = FNMS(TC, TB, TA * TD);
+ }
+ TF = Tz + TE;
+ T13 = TS + TT;
+ TR = Tz - TE;
+ TU = TS - TT;
+ }
+ {
+ E Tc, TI, Th, TJ;
+ {
+ E T9, Tb, T8, Ta;
+ T9 = rio[WS(ios, 2)];
+ Tb = iio[-WS(ios, 5)];
+ T8 = W[2];
+ Ta = W[3];
+ Tc = FMA(T8, T9, Ta * Tb);
+ TI = FNMS(Ta, T9, T8 * Tb);
+ }
+ {
+ E Te, Tg, Td, Tf;
+ Te = rio[WS(ios, 6)];
+ Tg = iio[-WS(ios, 1)];
+ Td = W[10];
+ Tf = W[11];
+ Th = FMA(Td, Te, Tf * Tg);
+ TJ = FNMS(Tf, Te, Td * Tg);
+ }
+ Ti = Tc + Th;
+ T1f = Tc - Th;
+ TK = TI - TJ;
+ T16 = TI + TJ;
+ }
+ {
+ E To, TN, Tt, TO;
+ {
+ E Tl, Tn, Tk, Tm;
+ Tl = rio[WS(ios, 1)];
+ Tn = iio[-WS(ios, 6)];
+ Tk = W[0];
+ Tm = W[1];
+ To = FMA(Tk, Tl, Tm * Tn);
+ TN = FNMS(Tm, Tl, Tk * Tn);
+ }
+ {
+ E Tq, Ts, Tp, Tr;
+ Tq = rio[WS(ios, 5)];
+ Ts = iio[-WS(ios, 2)];
+ Tp = W[8];
+ Tr = W[9];
+ Tt = FMA(Tp, Tq, Tr * Ts);
+ TO = FNMS(Tr, Tq, Tp * Ts);
+ }
+ Tu = To + Tt;
+ T12 = TN + TO;
+ TM = To - Tt;
+ TP = TN - TO;
+ }
+ {
+ E Tj, TG, T1b, T1c;
+ Tj = T7 + Ti;
+ TG = Tu + TF;
+ iio[-WS(ios, 4)] = Tj - TG;
+ rio[0] = Tj + TG;
+ {
+ E T15, T1a, T11, T14;
+ T15 = T12 + T13;
+ T1a = T16 + T19;
+ rio[WS(ios, 4)] = T15 - T1a;
+ iio[0] = T15 + T1a;
+ T11 = T7 - Ti;
+ T14 = T12 - T13;
+ iio[-WS(ios, 6)] = T11 - T14;
+ rio[WS(ios, 2)] = T11 + T14;
+ }
+ T1b = TF - Tu;
+ T1c = T19 - T16;
+ rio[WS(ios, 6)] = T1b - T1c;
+ iio[-WS(ios, 2)] = T1b + T1c;
+ {
+ E TX, T1g, T10, T1d, TY, TZ;
+ TX = TH - TK;
+ T1g = T1e - T1f;
+ TY = TP - TM;
+ TZ = TR + TU;
+ T10 = KP707106781 * (TY - TZ);
+ T1d = KP707106781 * (TY + TZ);
+ iio[-WS(ios, 7)] = TX - T10;
+ iio[-WS(ios, 1)] = T1d + T1g;
+ rio[WS(ios, 3)] = TX + T10;
+ rio[WS(ios, 5)] = T1d - T1g;
+ }
+ {
+ E TL, T1i, TW, T1h, TQ, TV;
+ TL = TH + TK;
+ T1i = T1f + T1e;
+ TQ = TM + TP;
+ TV = TR - TU;
+ TW = KP707106781 * (TQ + TV);
+ T1h = KP707106781 * (TV - TQ);
+ iio[-WS(ios, 5)] = TL - TW;
+ iio[-WS(ios, 3)] = T1h + T1i;
+ rio[WS(ios, 1)] = TL + TW;
+ rio[WS(ios, 7)] = T1h - T1i;
+ }
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 8},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 8, "hf_8", twinstr, {52, 18, 14, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_8) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_8, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/hf_9.c b/src/fftw3/rdft/codelets/r2hc/hf_9.c
new file mode 100644
index 0000000..167bd52
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/hf_9.c
@@ -0,0 +1,256 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:57:01 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_hc2hc -compact -variables 4 -n 9 -dit -name hf_9 -include hf.h */
+
+/*
+ * This function contains 96 FP additions, 72 FP multiplications,
+ * (or, 60 additions, 36 multiplications, 36 fused multiply/add),
+ * 41 stack variables, and 36 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: hf_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "hf.h"
+
+static const R *hf_9(R *rio, R *iio, const R *W, stride ios, int m, int dist)
+{
+ DK(KP939692620, +0.939692620785908384054109277324731469936208134);
+ DK(KP342020143, +0.342020143325668733044099614682259580763083368);
+ DK(KP984807753, +0.984807753012208059366743024589523013670643252);
+ DK(KP173648177, +0.173648177666930348851716626769314796000375677);
+ DK(KP642787609, +0.642787609686539326322643409907263432907559884);
+ DK(KP766044443, +0.766044443118978035202392650555416673935832457);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = m - 2; i > 0; i = i - 2, rio = rio + dist, iio = iio - dist, W = W + 16) {
+ E T1, T1B, TQ, T1G, Tc, TN, T1A, T1H, TL, T1x, T17, T1o, T1c, T1n, Tu;
+ E T1w, TW, T1k, T11, T1l;
+ {
+ E T6, TO, Tb, TP;
+ T1 = rio[0];
+ T1B = iio[-WS(ios, 8)];
+ {
+ E T3, T5, T2, T4;
+ T3 = rio[WS(ios, 3)];
+ T5 = iio[-WS(ios, 5)];
+ T2 = W[4];
+ T4 = W[5];
+ T6 = FMA(T2, T3, T4 * T5);
+ TO = FNMS(T4, T3, T2 * T5);
+ }
+ {
+ E T8, Ta, T7, T9;
+ T8 = rio[WS(ios, 6)];
+ Ta = iio[-WS(ios, 2)];
+ T7 = W[10];
+ T9 = W[11];
+ Tb = FMA(T7, T8, T9 * Ta);
+ TP = FNMS(T9, T8, T7 * Ta);
+ }
+ TQ = KP866025403 * (TO - TP);
+ T1G = KP866025403 * (Tb - T6);
+ Tc = T6 + Tb;
+ TN = FNMS(KP500000000, Tc, T1);
+ T1A = TO + TP;
+ T1H = FNMS(KP500000000, T1A, T1B);
+ }
+ {
+ E Tz, T19, TE, T14, TJ, T15, TK, T1a;
+ {
+ E Tw, Ty, Tv, Tx;
+ Tw = rio[WS(ios, 2)];
+ Ty = iio[-WS(ios, 6)];
+ Tv = W[2];
+ Tx = W[3];
+ Tz = FMA(Tv, Tw, Tx * Ty);
+ T19 = FNMS(Tx, Tw, Tv * Ty);
+ }
+ {
+ E TB, TD, TA, TC;
+ TB = rio[WS(ios, 5)];
+ TD = iio[-WS(ios, 3)];
+ TA = W[8];
+ TC = W[9];
+ TE = FMA(TA, TB, TC * TD);
+ T14 = FNMS(TC, TB, TA * TD);
+ }
+ {
+ E TG, TI, TF, TH;
+ TG = rio[WS(ios, 8)];
+ TI = iio[0];
+ TF = W[14];
+ TH = W[15];
+ TJ = FMA(TF, TG, TH * TI);
+ T15 = FNMS(TH, TG, TF * TI);
+ }
+ TK = TE + TJ;
+ T1a = T14 + T15;
+ TL = Tz + TK;
+ T1x = T19 + T1a;
+ {
+ E T13, T16, T18, T1b;
+ T13 = FNMS(KP500000000, TK, Tz);
+ T16 = KP866025403 * (T14 - T15);
+ T17 = T13 + T16;
+ T1o = T13 - T16;
+ T18 = KP866025403 * (TJ - TE);
+ T1b = FNMS(KP500000000, T1a, T19);
+ T1c = T18 + T1b;
+ T1n = T1b - T18;
+ }
+ }
+ {
+ E Ti, TY, Tn, TT, Ts, TU, Tt, TZ;
+ {
+ E Tf, Th, Te, Tg;
+ Tf = rio[WS(ios, 1)];
+ Th = iio[-WS(ios, 7)];
+ Te = W[0];
+ Tg = W[1];
+ Ti = FMA(Te, Tf, Tg * Th);
+ TY = FNMS(Tg, Tf, Te * Th);
+ }
+ {
+ E Tk, Tm, Tj, Tl;
+ Tk = rio[WS(ios, 4)];
+ Tm = iio[-WS(ios, 4)];
+ Tj = W[6];
+ Tl = W[7];
+ Tn = FMA(Tj, Tk, Tl * Tm);
+ TT = FNMS(Tl, Tk, Tj * Tm);
+ }
+ {
+ E Tp, Tr, To, Tq;
+ Tp = rio[WS(ios, 7)];
+ Tr = iio[-WS(ios, 1)];
+ To = W[12];
+ Tq = W[13];
+ Ts = FMA(To, Tp, Tq * Tr);
+ TU = FNMS(Tq, Tp, To * Tr);
+ }
+ Tt = Tn + Ts;
+ TZ = TT + TU;
+ Tu = Ti + Tt;
+ T1w = TY + TZ;
+ {
+ E TS, TV, TX, T10;
+ TS = FNMS(KP500000000, Tt, Ti);
+ TV = KP866025403 * (TT - TU);
+ TW = TS + TV;
+ T1k = TS - TV;
+ TX = KP866025403 * (Ts - Tn);
+ T10 = FNMS(KP500000000, TZ, TY);
+ T11 = TX + T10;
+ T1l = T10 - TX;
+ }
+ }
+ {
+ E T1y, Td, TM, T1v;
+ T1y = KP866025403 * (T1w - T1x);
+ Td = T1 + Tc;
+ TM = Tu + TL;
+ T1v = FNMS(KP500000000, TM, Td);
+ rio[0] = Td + TM;
+ rio[WS(ios, 3)] = T1v + T1y;
+ iio[-WS(ios, 6)] = T1v - T1y;
+ }
+ {
+ E T1D, T1z, T1C, T1E;
+ T1D = KP866025403 * (TL - Tu);
+ T1z = T1w + T1x;
+ T1C = T1A + T1B;
+ T1E = FNMS(KP500000000, T1z, T1C);
+ iio[0] = T1z + T1C;
+ iio[-WS(ios, 3)] = T1D + T1E;
+ rio[WS(ios, 6)] = T1D - T1E;
+ }
+ {
+ E TR, T1I, T1e, T1J, T1i, T1F, T1f, T1K;
+ TR = TN + TQ;
+ T1I = T1G + T1H;
+ {
+ E T12, T1d, T1g, T1h;
+ T12 = FMA(KP766044443, TW, KP642787609 * T11);
+ T1d = FMA(KP173648177, T17, KP984807753 * T1c);
+ T1e = T12 + T1d;
+ T1J = KP866025403 * (T1d - T12);
+ T1g = FNMS(KP642787609, TW, KP766044443 * T11);
+ T1h = FNMS(KP984807753, T17, KP173648177 * T1c);
+ T1i = KP866025403 * (T1g - T1h);
+ T1F = T1g + T1h;
+ }
+ rio[WS(ios, 1)] = TR + T1e;
+ iio[-WS(ios, 1)] = T1F + T1I;
+ T1f = FNMS(KP500000000, T1e, TR);
+ iio[-WS(ios, 7)] = T1f - T1i;
+ rio[WS(ios, 4)] = T1f + T1i;
+ T1K = FNMS(KP500000000, T1F, T1I);
+ rio[WS(ios, 7)] = T1J - T1K;
+ iio[-WS(ios, 4)] = T1J + T1K;
+ }
+ {
+ E T1j, T1M, T1q, T1O, T1u, T1L, T1r, T1N;
+ T1j = TN - TQ;
+ T1M = T1H - T1G;
+ {
+ E T1m, T1p, T1s, T1t;
+ T1m = FMA(KP173648177, T1k, KP984807753 * T1l);
+ T1p = FNMS(KP939692620, T1o, KP342020143 * T1n);
+ T1q = T1m + T1p;
+ T1O = KP866025403 * (T1p - T1m);
+ T1s = FNMS(KP984807753, T1k, KP173648177 * T1l);
+ T1t = FMA(KP342020143, T1o, KP939692620 * T1n);
+ T1u = KP866025403 * (T1s + T1t);
+ T1L = T1s - T1t;
+ }
+ rio[WS(ios, 2)] = T1j + T1q;
+ iio[-WS(ios, 2)] = T1L + T1M;
+ T1r = FNMS(KP500000000, T1q, T1j);
+ iio[-WS(ios, 8)] = T1r - T1u;
+ iio[-WS(ios, 5)] = T1r + T1u;
+ T1N = FMS(KP500000000, T1L, T1M);
+ rio[WS(ios, 5)] = T1N - T1O;
+ rio[WS(ios, 8)] = T1O + T1N;
+ }
+ }
+ return W;
+}
+
+static const tw_instr twinstr[] = {
+ {TW_FULL, 0, 9},
+ {TW_NEXT, 1, 0}
+};
+
+static const hc2hc_desc desc = { 9, "hf_9", twinstr, {60, 36, 36, 0}, &GENUS, 0, 0, 0 };
+
+void X(codelet_hf_9) (planner *p) {
+ X(khc2hc_dit_register) (p, hf_9, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c b/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c
new file mode 100644
index 0000000..38c2613
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/mr2hcII_32.c
@@ -0,0 +1,368 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:43 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 32 -name mr2hcII_32 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 174 FP additions, 82 FP multiplications,
+ * (or, 138 additions, 46 multiplications, 36 fused multiply/add),
+ * 61 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void mr2hcII_32_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios)
+{
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ {
+ E T5, T2D, T1z, T2q, Tc, T2C, T1C, T2n, Tm, T1k, T1J, T26, Tv, T1l, T1G;
+ E T27, T15, T1r, T1Y, T2e, T1c, T1s, T1V, T2d, TK, T1o, T1R, T2b, TR, T1p;
+ E T1O, T2a;
+ {
+ E T1, T2p, T4, T2o, T2, T3;
+ T1 = I[0];
+ T2p = I[WS(is, 16)];
+ T2 = I[WS(is, 8)];
+ T3 = I[WS(is, 24)];
+ T4 = KP707106781 * (T2 - T3);
+ T2o = KP707106781 * (T2 + T3);
+ T5 = T1 + T4;
+ T2D = T2p - T2o;
+ T1z = T1 - T4;
+ T2q = T2o + T2p;
+ }
+ {
+ E T8, T1A, Tb, T1B;
+ {
+ E T6, T7, T9, Ta;
+ T6 = I[WS(is, 4)];
+ T7 = I[WS(is, 20)];
+ T8 = FNMS(KP382683432, T7, KP923879532 * T6);
+ T1A = FMA(KP382683432, T6, KP923879532 * T7);
+ T9 = I[WS(is, 12)];
+ Ta = I[WS(is, 28)];
+ Tb = FNMS(KP923879532, Ta, KP382683432 * T9);
+ T1B = FMA(KP923879532, T9, KP382683432 * Ta);
+ }
+ Tc = T8 + Tb;
+ T2C = Tb - T8;
+ T1C = T1A - T1B;
+ T2n = T1A + T1B;
+ }
+ {
+ E Te, Tk, Th, Tj, Tf, Tg;
+ Te = I[WS(is, 2)];
+ Tk = I[WS(is, 18)];
+ Tf = I[WS(is, 10)];
+ Tg = I[WS(is, 26)];
+ Th = KP707106781 * (Tf - Tg);
+ Tj = KP707106781 * (Tf + Tg);
+ {
+ E Ti, Tl, T1H, T1I;
+ Ti = Te + Th;
+ Tl = Tj + Tk;
+ Tm = FNMS(KP195090322, Tl, KP980785280 * Ti);
+ T1k = FMA(KP195090322, Ti, KP980785280 * Tl);
+ T1H = Tk - Tj;
+ T1I = Te - Th;
+ T1J = FNMS(KP555570233, T1I, KP831469612 * T1H);
+ T26 = FMA(KP831469612, T1I, KP555570233 * T1H);
+ }
+ }
+ {
+ E Tq, Tt, Tp, Ts, Tn, To;
+ Tq = I[WS(is, 30)];
+ Tt = I[WS(is, 14)];
+ Tn = I[WS(is, 6)];
+ To = I[WS(is, 22)];
+ Tp = KP707106781 * (Tn - To);
+ Ts = KP707106781 * (Tn + To);
+ {
+ E Tr, Tu, T1E, T1F;
+ Tr = Tp - Tq;
+ Tu = Ts + Tt;
+ Tv = FMA(KP980785280, Tr, KP195090322 * Tu);
+ T1l = FNMS(KP980785280, Tu, KP195090322 * Tr);
+ T1E = Tt - Ts;
+ T1F = Tp + Tq;
+ T1G = FNMS(KP555570233, T1F, KP831469612 * T1E);
+ T27 = FMA(KP831469612, T1F, KP555570233 * T1E);
+ }
+ }
+ {
+ E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU;
+ TW = I[WS(is, 31)];
+ T1a = I[WS(is, 15)];
+ TT = I[WS(is, 7)];
+ TU = I[WS(is, 23)];
+ TV = KP707106781 * (TT - TU);
+ T19 = KP707106781 * (TT + TU);
+ {
+ E TY, TZ, T11, T12;
+ TY = I[WS(is, 3)];
+ TZ = I[WS(is, 19)];
+ T10 = FNMS(KP382683432, TZ, KP923879532 * TY);
+ T16 = FMA(KP382683432, TY, KP923879532 * TZ);
+ T11 = I[WS(is, 11)];
+ T12 = I[WS(is, 27)];
+ T13 = FNMS(KP923879532, T12, KP382683432 * T11);
+ T17 = FMA(KP923879532, T11, KP382683432 * T12);
+ }
+ {
+ E TX, T14, T1W, T1X;
+ TX = TV - TW;
+ T14 = T10 + T13;
+ T15 = TX + T14;
+ T1r = TX - T14;
+ T1W = T13 - T10;
+ T1X = T1a - T19;
+ T1Y = T1W - T1X;
+ T2e = T1W + T1X;
+ }
+ {
+ E T18, T1b, T1T, T1U;
+ T18 = T16 + T17;
+ T1b = T19 + T1a;
+ T1c = T18 + T1b;
+ T1s = T1b - T18;
+ T1T = TV + TW;
+ T1U = T16 - T17;
+ T1V = T1T + T1U;
+ T2d = T1U - T1T;
+ }
+ }
+ {
+ E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA;
+ Ty = I[WS(is, 1)];
+ TP = I[WS(is, 17)];
+ Tz = I[WS(is, 9)];
+ TA = I[WS(is, 25)];
+ TB = KP707106781 * (Tz - TA);
+ TO = KP707106781 * (Tz + TA);
+ {
+ E TD, TE, TG, TH;
+ TD = I[WS(is, 5)];
+ TE = I[WS(is, 21)];
+ TF = FNMS(KP382683432, TE, KP923879532 * TD);
+ TL = FMA(KP382683432, TD, KP923879532 * TE);
+ TG = I[WS(is, 13)];
+ TH = I[WS(is, 29)];
+ TI = FNMS(KP923879532, TH, KP382683432 * TG);
+ TM = FMA(KP923879532, TG, KP382683432 * TH);
+ }
+ {
+ E TC, TJ, T1P, T1Q;
+ TC = Ty + TB;
+ TJ = TF + TI;
+ TK = TC + TJ;
+ T1o = TC - TJ;
+ T1P = TI - TF;
+ T1Q = TP - TO;
+ T1R = T1P - T1Q;
+ T2b = T1P + T1Q;
+ }
+ {
+ E TN, TQ, T1M, T1N;
+ TN = TL + TM;
+ TQ = TO + TP;
+ TR = TN + TQ;
+ T1p = TQ - TN;
+ T1M = Ty - TB;
+ T1N = TL - TM;
+ T1O = T1M - T1N;
+ T2a = T1M + T1N;
+ }
+ }
+ {
+ E Tx, T1f, T2s, T2u, T1e, T2l, T1i, T2t;
+ {
+ E Td, Tw, T2m, T2r;
+ Td = T5 + Tc;
+ Tw = Tm + Tv;
+ Tx = Td - Tw;
+ T1f = Td + Tw;
+ T2m = T1l - T1k;
+ T2r = T2n + T2q;
+ T2s = T2m - T2r;
+ T2u = T2m + T2r;
+ }
+ {
+ E TS, T1d, T1g, T1h;
+ TS = FMA(KP098017140, TK, KP995184726 * TR);
+ T1d = FNMS(KP995184726, T1c, KP098017140 * T15);
+ T1e = TS + T1d;
+ T2l = T1d - TS;
+ T1g = FNMS(KP098017140, TR, KP995184726 * TK);
+ T1h = FMA(KP995184726, T15, KP098017140 * T1c);
+ T1i = T1g + T1h;
+ T2t = T1h - T1g;
+ }
+ ro[WS(ros, 8)] = Tx - T1e;
+ io[WS(ios, 8)] = T2t - T2u;
+ ro[WS(ros, 7)] = Tx + T1e;
+ io[WS(ios, 7)] = T2t + T2u;
+ ro[WS(ros, 15)] = T1f - T1i;
+ io[WS(ios, 15)] = T2l - T2s;
+ ro[0] = T1f + T1i;
+ io[0] = T2l + T2s;
+ }
+ {
+ E T29, T2h, T2M, T2O, T2g, T2J, T2k, T2N;
+ {
+ E T25, T28, T2K, T2L;
+ T25 = T1z + T1C;
+ T28 = T26 - T27;
+ T29 = T25 + T28;
+ T2h = T25 - T28;
+ T2K = T1J + T1G;
+ T2L = T2C + T2D;
+ T2M = T2K - T2L;
+ T2O = T2K + T2L;
+ }
+ {
+ E T2c, T2f, T2i, T2j;
+ T2c = FMA(KP956940335, T2a, KP290284677 * T2b);
+ T2f = FNMS(KP290284677, T2e, KP956940335 * T2d);
+ T2g = T2c + T2f;
+ T2J = T2f - T2c;
+ T2i = FMA(KP290284677, T2d, KP956940335 * T2e);
+ T2j = FNMS(KP290284677, T2a, KP956940335 * T2b);
+ T2k = T2i - T2j;
+ T2N = T2j + T2i;
+ }
+ ro[WS(ros, 14)] = T29 - T2g;
+ io[WS(ios, 14)] = T2N - T2O;
+ ro[WS(ros, 1)] = T29 + T2g;
+ io[WS(ios, 1)] = T2N + T2O;
+ ro[WS(ros, 9)] = T2h - T2k;
+ io[WS(ios, 9)] = T2J - T2M;
+ ro[WS(ros, 6)] = T2h + T2k;
+ io[WS(ios, 6)] = T2J + T2M;
+ }
+ {
+ E T1n, T1v, T2y, T2A, T1u, T2v, T1y, T2z;
+ {
+ E T1j, T1m, T2w, T2x;
+ T1j = T5 - Tc;
+ T1m = T1k + T1l;
+ T1n = T1j + T1m;
+ T1v = T1j - T1m;
+ T2w = Tv - Tm;
+ T2x = T2q - T2n;
+ T2y = T2w - T2x;
+ T2A = T2w + T2x;
+ }
+ {
+ E T1q, T1t, T1w, T1x;
+ T1q = FMA(KP773010453, T1o, KP634393284 * T1p);
+ T1t = FNMS(KP634393284, T1s, KP773010453 * T1r);
+ T1u = T1q + T1t;
+ T2v = T1t - T1q;
+ T1w = FMA(KP634393284, T1r, KP773010453 * T1s);
+ T1x = FNMS(KP634393284, T1o, KP773010453 * T1p);
+ T1y = T1w - T1x;
+ T2z = T1x + T1w;
+ }
+ ro[WS(ros, 12)] = T1n - T1u;
+ io[WS(ios, 12)] = T2z - T2A;
+ ro[WS(ros, 3)] = T1n + T1u;
+ io[WS(ios, 3)] = T2z + T2A;
+ ro[WS(ros, 11)] = T1v - T1y;
+ io[WS(ios, 11)] = T2v - T2y;
+ ro[WS(ros, 4)] = T1v + T1y;
+ io[WS(ios, 4)] = T2v + T2y;
+ }
+ {
+ E T1L, T21, T2G, T2I, T20, T2H, T24, T2B;
+ {
+ E T1D, T1K, T2E, T2F;
+ T1D = T1z - T1C;
+ T1K = T1G - T1J;
+ T1L = T1D + T1K;
+ T21 = T1D - T1K;
+ T2E = T2C - T2D;
+ T2F = T26 + T27;
+ T2G = T2E - T2F;
+ T2I = T2F + T2E;
+ }
+ {
+ E T1S, T1Z, T22, T23;
+ T1S = FMA(KP881921264, T1O, KP471396736 * T1R);
+ T1Z = FMA(KP881921264, T1V, KP471396736 * T1Y);
+ T20 = T1S - T1Z;
+ T2H = T1S + T1Z;
+ T22 = FNMS(KP471396736, T1V, KP881921264 * T1Y);
+ T23 = FNMS(KP471396736, T1O, KP881921264 * T1R);
+ T24 = T22 - T23;
+ T2B = T23 + T22;
+ }
+ ro[WS(ros, 13)] = T1L - T20;
+ io[WS(ios, 13)] = T2B - T2G;
+ ro[WS(ros, 2)] = T1L + T20;
+ io[WS(ios, 2)] = T2B + T2G;
+ ro[WS(ros, 10)] = T21 - T24;
+ io[WS(ios, 10)] = T2I - T2H;
+ ro[WS(ros, 5)] = T21 + T24;
+ io[WS(ios, 5)] = -(T2H + T2I);
+ }
+ }
+}
+
+static void mr2hcII_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; --i) {
+ mr2hcII_32_0(I, ro, io, is, ros, ios);
+ I += ivs;
+ ro += ovs;
+ io += ovs;
+ }
+}
+
+static const kr2hc_desc desc = { 32, "mr2hcII_32", {138, 46, 36, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_mr2hcII_32) (planner *p) {
+ X(kr2hcII_register) (p, mr2hcII_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c b/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c
new file mode 100644
index 0000000..4752322
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/mr2hcII_64.c
@@ -0,0 +1,799 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:59:51 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 64 -name mr2hcII_64 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 434 FP additions, 206 FP multiplications,
+ * (or, 342 additions, 114 multiplications, 92 fused multiply/add),
+ * 117 stack variables, and 128 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hcII_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void mr2hcII_64_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios)
+{
+ DK(KP242980179, +0.242980179903263889948274162077471118320990783);
+ DK(KP970031253, +0.970031253194543992603984207286100251456865962);
+ DK(KP857728610, +0.857728610000272069902269984284770137042490799);
+ DK(KP514102744, +0.514102744193221726593693838968815772608049120);
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP427555093, +0.427555093430282094320966856888798534304578629);
+ DK(KP903989293, +0.903989293123443331586200297230537048710132025);
+ DK(KP336889853, +0.336889853392220050689253212619147570477766780);
+ DK(KP941544065, +0.941544065183020778412509402599502357185589796);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP595699304, +0.595699304492433343467036528829969889511926338);
+ DK(KP803207531, +0.803207531480644909806676512963141923879569427);
+ DK(KP146730474, +0.146730474455361751658850129646717819706215317);
+ DK(KP989176509, +0.989176509964780973451673738016243063983689533);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP049067674, +0.049067674327418014254954976942682658314745363);
+ DK(KP998795456, +0.998795456205172392714771604759100694443203615);
+ DK(KP671558954, +0.671558954847018400625376850427421803228750632);
+ DK(KP740951125, +0.740951125354959091175616897495162729728955309);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ {
+ E Tm, T34, T3Z, T5g, Tv, T35, T3W, T5h, Td, T33, T6B, T6Q, T3T, T5f, T68;
+ E T6m, T2b, T3n, T4O, T5D, T2F, T3r, T4K, T5z, TK, T3c, T47, T5n, TR, T3b;
+ E T44, T5o, T15, T38, T4e, T5l, T1c, T39, T4b, T5k, T1s, T3g, T4v, T5w, T1W;
+ E T3k, T4k, T5s, T2u, T3q, T4R, T5A, T2y, T3o, T4H, T5C, T1L, T3j, T4y, T5t;
+ E T1P, T3h, T4r, T5v;
+ {
+ E Te, Tk, Th, Tj, Tf, Tg;
+ Te = I[WS(is, 4)];
+ Tk = I[WS(is, 36)];
+ Tf = I[WS(is, 20)];
+ Tg = I[WS(is, 52)];
+ Th = KP707106781 * (Tf - Tg);
+ Tj = KP707106781 * (Tf + Tg);
+ {
+ E Ti, Tl, T3X, T3Y;
+ Ti = Te + Th;
+ Tl = Tj + Tk;
+ Tm = FNMS(KP195090322, Tl, KP980785280 * Ti);
+ T34 = FMA(KP195090322, Ti, KP980785280 * Tl);
+ T3X = Tk - Tj;
+ T3Y = Te - Th;
+ T3Z = FNMS(KP555570233, T3Y, KP831469612 * T3X);
+ T5g = FMA(KP831469612, T3Y, KP555570233 * T3X);
+ }
+ }
+ {
+ E Tq, Tt, Tp, Ts, Tn, To;
+ Tq = I[WS(is, 60)];
+ Tt = I[WS(is, 28)];
+ Tn = I[WS(is, 12)];
+ To = I[WS(is, 44)];
+ Tp = KP707106781 * (Tn - To);
+ Ts = KP707106781 * (Tn + To);
+ {
+ E Tr, Tu, T3U, T3V;
+ Tr = Tp - Tq;
+ Tu = Ts + Tt;
+ Tv = FMA(KP980785280, Tr, KP195090322 * Tu);
+ T35 = FNMS(KP980785280, Tu, KP195090322 * Tr);
+ T3U = Tt - Ts;
+ T3V = Tp + Tq;
+ T3W = FNMS(KP555570233, T3V, KP831469612 * T3U);
+ T5h = FMA(KP831469612, T3V, KP555570233 * T3U);
+ }
+ }
+ {
+ E T1, T66, T4, T65, T8, T3Q, Tb, T3R, T2, T3;
+ T1 = I[0];
+ T66 = I[WS(is, 32)];
+ T2 = I[WS(is, 16)];
+ T3 = I[WS(is, 48)];
+ T4 = KP707106781 * (T2 - T3);
+ T65 = KP707106781 * (T2 + T3);
+ {
+ E T6, T7, T9, Ta;
+ T6 = I[WS(is, 8)];
+ T7 = I[WS(is, 40)];
+ T8 = FNMS(KP382683432, T7, KP923879532 * T6);
+ T3Q = FMA(KP382683432, T6, KP923879532 * T7);
+ T9 = I[WS(is, 24)];
+ Ta = I[WS(is, 56)];
+ Tb = FNMS(KP923879532, Ta, KP382683432 * T9);
+ T3R = FMA(KP923879532, T9, KP382683432 * Ta);
+ }
+ {
+ E T5, Tc, T6z, T6A;
+ T5 = T1 + T4;
+ Tc = T8 + Tb;
+ Td = T5 + Tc;
+ T33 = T5 - Tc;
+ T6z = Tb - T8;
+ T6A = T66 - T65;
+ T6B = T6z - T6A;
+ T6Q = T6z + T6A;
+ }
+ {
+ E T3P, T3S, T64, T67;
+ T3P = T1 - T4;
+ T3S = T3Q - T3R;
+ T3T = T3P - T3S;
+ T5f = T3P + T3S;
+ T64 = T3Q + T3R;
+ T67 = T65 + T66;
+ T68 = T64 + T67;
+ T6m = T67 - T64;
+ }
+ }
+ {
+ E T22, T2D, T21, T2C, T26, T2z, T29, T2A, T1Z, T20;
+ T22 = I[WS(is, 63)];
+ T2D = I[WS(is, 31)];
+ T1Z = I[WS(is, 15)];
+ T20 = I[WS(is, 47)];
+ T21 = KP707106781 * (T1Z - T20);
+ T2C = KP707106781 * (T1Z + T20);
+ {
+ E T24, T25, T27, T28;
+ T24 = I[WS(is, 7)];
+ T25 = I[WS(is, 39)];
+ T26 = FNMS(KP382683432, T25, KP923879532 * T24);
+ T2z = FMA(KP382683432, T24, KP923879532 * T25);
+ T27 = I[WS(is, 23)];
+ T28 = I[WS(is, 55)];
+ T29 = FNMS(KP923879532, T28, KP382683432 * T27);
+ T2A = FMA(KP923879532, T27, KP382683432 * T28);
+ }
+ {
+ E T23, T2a, T4M, T4N;
+ T23 = T21 - T22;
+ T2a = T26 + T29;
+ T2b = T23 + T2a;
+ T3n = T23 - T2a;
+ T4M = T29 - T26;
+ T4N = T2D - T2C;
+ T4O = T4M - T4N;
+ T5D = T4M + T4N;
+ }
+ {
+ E T2B, T2E, T4I, T4J;
+ T2B = T2z + T2A;
+ T2E = T2C + T2D;
+ T2F = T2B + T2E;
+ T3r = T2E - T2B;
+ T4I = T21 + T22;
+ T4J = T2z - T2A;
+ T4K = T4I + T4J;
+ T5z = T4J - T4I;
+ }
+ }
+ {
+ E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA;
+ Ty = I[WS(is, 2)];
+ TP = I[WS(is, 34)];
+ Tz = I[WS(is, 18)];
+ TA = I[WS(is, 50)];
+ TB = KP707106781 * (Tz - TA);
+ TO = KP707106781 * (Tz + TA);
+ {
+ E TD, TE, TG, TH;
+ TD = I[WS(is, 10)];
+ TE = I[WS(is, 42)];
+ TF = FNMS(KP382683432, TE, KP923879532 * TD);
+ TL = FMA(KP382683432, TD, KP923879532 * TE);
+ TG = I[WS(is, 26)];
+ TH = I[WS(is, 58)];
+ TI = FNMS(KP923879532, TH, KP382683432 * TG);
+ TM = FMA(KP923879532, TG, KP382683432 * TH);
+ }
+ {
+ E TC, TJ, T45, T46;
+ TC = Ty + TB;
+ TJ = TF + TI;
+ TK = TC + TJ;
+ T3c = TC - TJ;
+ T45 = TI - TF;
+ T46 = TP - TO;
+ T47 = T45 - T46;
+ T5n = T45 + T46;
+ }
+ {
+ E TN, TQ, T42, T43;
+ TN = TL + TM;
+ TQ = TO + TP;
+ TR = TN + TQ;
+ T3b = TQ - TN;
+ T42 = Ty - TB;
+ T43 = TL - TM;
+ T44 = T42 - T43;
+ T5o = T42 + T43;
+ }
+ }
+ {
+ E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU;
+ TW = I[WS(is, 62)];
+ T1a = I[WS(is, 30)];
+ TT = I[WS(is, 14)];
+ TU = I[WS(is, 46)];
+ TV = KP707106781 * (TT - TU);
+ T19 = KP707106781 * (TT + TU);
+ {
+ E TY, TZ, T11, T12;
+ TY = I[WS(is, 6)];
+ TZ = I[WS(is, 38)];
+ T10 = FNMS(KP382683432, TZ, KP923879532 * TY);
+ T16 = FMA(KP382683432, TY, KP923879532 * TZ);
+ T11 = I[WS(is, 22)];
+ T12 = I[WS(is, 54)];
+ T13 = FNMS(KP923879532, T12, KP382683432 * T11);
+ T17 = FMA(KP923879532, T11, KP382683432 * T12);
+ }
+ {
+ E TX, T14, T4c, T4d;
+ TX = TV - TW;
+ T14 = T10 + T13;
+ T15 = TX + T14;
+ T38 = TX - T14;
+ T4c = T13 - T10;
+ T4d = T1a - T19;
+ T4e = T4c - T4d;
+ T5l = T4c + T4d;
+ }
+ {
+ E T18, T1b, T49, T4a;
+ T18 = T16 + T17;
+ T1b = T19 + T1a;
+ T1c = T18 + T1b;
+ T39 = T1b - T18;
+ T49 = TV + TW;
+ T4a = T16 - T17;
+ T4b = T49 + T4a;
+ T5k = T4a - T49;
+ }
+ }
+ {
+ E T1g, T1U, T1j, T1T, T1n, T1Q, T1q, T1R, T1h, T1i;
+ T1g = I[WS(is, 1)];
+ T1U = I[WS(is, 33)];
+ T1h = I[WS(is, 17)];
+ T1i = I[WS(is, 49)];
+ T1j = KP707106781 * (T1h - T1i);
+ T1T = KP707106781 * (T1h + T1i);
+ {
+ E T1l, T1m, T1o, T1p;
+ T1l = I[WS(is, 9)];
+ T1m = I[WS(is, 41)];
+ T1n = FNMS(KP382683432, T1m, KP923879532 * T1l);
+ T1Q = FMA(KP382683432, T1l, KP923879532 * T1m);
+ T1o = I[WS(is, 25)];
+ T1p = I[WS(is, 57)];
+ T1q = FNMS(KP923879532, T1p, KP382683432 * T1o);
+ T1R = FMA(KP923879532, T1o, KP382683432 * T1p);
+ }
+ {
+ E T1k, T1r, T4t, T4u;
+ T1k = T1g + T1j;
+ T1r = T1n + T1q;
+ T1s = T1k + T1r;
+ T3g = T1k - T1r;
+ T4t = T1q - T1n;
+ T4u = T1U - T1T;
+ T4v = T4t - T4u;
+ T5w = T4t + T4u;
+ }
+ {
+ E T1S, T1V, T4i, T4j;
+ T1S = T1Q + T1R;
+ T1V = T1T + T1U;
+ T1W = T1S + T1V;
+ T3k = T1V - T1S;
+ T4i = T1g - T1j;
+ T4j = T1Q - T1R;
+ T4k = T4i - T4j;
+ T5s = T4i + T4j;
+ }
+ }
+ {
+ E T2g, T4F, T2j, T4E, T2p, T4C, T2s, T4B;
+ {
+ E T2c, T2i, T2f, T2h, T2d, T2e;
+ T2c = I[WS(is, 3)];
+ T2i = I[WS(is, 35)];
+ T2d = I[WS(is, 19)];
+ T2e = I[WS(is, 51)];
+ T2f = KP707106781 * (T2d - T2e);
+ T2h = KP707106781 * (T2d + T2e);
+ T2g = T2c + T2f;
+ T4F = T2c - T2f;
+ T2j = T2h + T2i;
+ T4E = T2i - T2h;
+ }
+ {
+ E T2o, T2r, T2n, T2q, T2l, T2m;
+ T2o = I[WS(is, 59)];
+ T2r = I[WS(is, 27)];
+ T2l = I[WS(is, 11)];
+ T2m = I[WS(is, 43)];
+ T2n = KP707106781 * (T2l - T2m);
+ T2q = KP707106781 * (T2l + T2m);
+ T2p = T2n - T2o;
+ T4C = T2n + T2o;
+ T2s = T2q + T2r;
+ T4B = T2r - T2q;
+ }
+ {
+ E T2k, T2t, T4P, T4Q;
+ T2k = FNMS(KP195090322, T2j, KP980785280 * T2g);
+ T2t = FMA(KP980785280, T2p, KP195090322 * T2s);
+ T2u = T2k + T2t;
+ T3q = T2t - T2k;
+ T4P = FMA(KP831469612, T4F, KP555570233 * T4E);
+ T4Q = FMA(KP831469612, T4C, KP555570233 * T4B);
+ T4R = T4P + T4Q;
+ T5A = T4P - T4Q;
+ }
+ {
+ E T2w, T2x, T4D, T4G;
+ T2w = FNMS(KP980785280, T2s, KP195090322 * T2p);
+ T2x = FMA(KP195090322, T2g, KP980785280 * T2j);
+ T2y = T2w - T2x;
+ T3o = T2x + T2w;
+ T4D = FNMS(KP555570233, T4C, KP831469612 * T4B);
+ T4G = FNMS(KP555570233, T4F, KP831469612 * T4E);
+ T4H = T4D - T4G;
+ T5C = T4G + T4D;
+ }
+ }
+ {
+ E T1x, T4p, T1A, T4o, T1G, T4m, T1J, T4l;
+ {
+ E T1t, T1z, T1w, T1y, T1u, T1v;
+ T1t = I[WS(is, 5)];
+ T1z = I[WS(is, 37)];
+ T1u = I[WS(is, 21)];
+ T1v = I[WS(is, 53)];
+ T1w = KP707106781 * (T1u - T1v);
+ T1y = KP707106781 * (T1u + T1v);
+ T1x = T1t + T1w;
+ T4p = T1t - T1w;
+ T1A = T1y + T1z;
+ T4o = T1z - T1y;
+ }
+ {
+ E T1F, T1I, T1E, T1H, T1C, T1D;
+ T1F = I[WS(is, 61)];
+ T1I = I[WS(is, 29)];
+ T1C = I[WS(is, 13)];
+ T1D = I[WS(is, 45)];
+ T1E = KP707106781 * (T1C - T1D);
+ T1H = KP707106781 * (T1C + T1D);
+ T1G = T1E - T1F;
+ T4m = T1E + T1F;
+ T1J = T1H + T1I;
+ T4l = T1I - T1H;
+ }
+ {
+ E T1B, T1K, T4w, T4x;
+ T1B = FNMS(KP195090322, T1A, KP980785280 * T1x);
+ T1K = FMA(KP980785280, T1G, KP195090322 * T1J);
+ T1L = T1B + T1K;
+ T3j = T1K - T1B;
+ T4w = FMA(KP831469612, T4p, KP555570233 * T4o);
+ T4x = FMA(KP831469612, T4m, KP555570233 * T4l);
+ T4y = T4w + T4x;
+ T5t = T4w - T4x;
+ }
+ {
+ E T1N, T1O, T4n, T4q;
+ T1N = FNMS(KP980785280, T1J, KP195090322 * T1G);
+ T1O = FMA(KP195090322, T1x, KP980785280 * T1A);
+ T1P = T1N - T1O;
+ T3h = T1O + T1N;
+ T4n = FNMS(KP555570233, T4m, KP831469612 * T4l);
+ T4q = FNMS(KP555570233, T4p, KP831469612 * T4o);
+ T4r = T4n - T4q;
+ T5v = T4q + T4n;
+ }
+ }
+ {
+ E Tx, T2N, T69, T6f, T1e, T6e, T2X, T30, T1Y, T2L, T2Q, T62, T2U, T31, T2H;
+ E T2K, Tw, T63;
+ Tw = Tm + Tv;
+ Tx = Td + Tw;
+ T2N = Td - Tw;
+ T63 = T35 - T34;
+ T69 = T63 - T68;
+ T6f = T63 + T68;
+ {
+ E TS, T1d, T2V, T2W;
+ TS = FNMS(KP098017140, TR, KP995184726 * TK);
+ T1d = FMA(KP995184726, T15, KP098017140 * T1c);
+ T1e = TS + T1d;
+ T6e = T1d - TS;
+ T2V = T2b - T2u;
+ T2W = T2y + T2F;
+ T2X = FNMS(KP671558954, T2W, KP740951125 * T2V);
+ T30 = FMA(KP671558954, T2V, KP740951125 * T2W);
+ }
+ {
+ E T1M, T1X, T2O, T2P;
+ T1M = T1s + T1L;
+ T1X = T1P - T1W;
+ T1Y = FMA(KP998795456, T1M, KP049067674 * T1X);
+ T2L = FNMS(KP049067674, T1M, KP998795456 * T1X);
+ T2O = FMA(KP098017140, TK, KP995184726 * TR);
+ T2P = FNMS(KP995184726, T1c, KP098017140 * T15);
+ T2Q = T2O + T2P;
+ T62 = T2P - T2O;
+ }
+ {
+ E T2S, T2T, T2v, T2G;
+ T2S = T1s - T1L;
+ T2T = T1P + T1W;
+ T2U = FMA(KP740951125, T2S, KP671558954 * T2T);
+ T31 = FNMS(KP671558954, T2S, KP740951125 * T2T);
+ T2v = T2b + T2u;
+ T2G = T2y - T2F;
+ T2H = FNMS(KP049067674, T2G, KP998795456 * T2v);
+ T2K = FMA(KP049067674, T2v, KP998795456 * T2G);
+ }
+ {
+ E T1f, T2I, T6b, T6c;
+ T1f = Tx + T1e;
+ T2I = T1Y + T2H;
+ ro[WS(ros, 31)] = T1f - T2I;
+ ro[0] = T1f + T2I;
+ T6b = T2L + T2K;
+ T6c = T62 + T69;
+ io[WS(ios, 31)] = T6b - T6c;
+ io[0] = T6b + T6c;
+ }
+ {
+ E T2J, T2M, T61, T6a;
+ T2J = Tx - T1e;
+ T2M = T2K - T2L;
+ ro[WS(ros, 16)] = T2J - T2M;
+ ro[WS(ros, 15)] = T2J + T2M;
+ T61 = T2H - T1Y;
+ T6a = T62 - T69;
+ io[WS(ios, 16)] = T61 - T6a;
+ io[WS(ios, 15)] = T61 + T6a;
+ }
+ {
+ E T2R, T2Y, T6h, T6i;
+ T2R = T2N + T2Q;
+ T2Y = T2U + T2X;
+ ro[WS(ros, 24)] = T2R - T2Y;
+ ro[WS(ros, 7)] = T2R + T2Y;
+ T6h = T31 + T30;
+ T6i = T6e + T6f;
+ io[WS(ios, 24)] = T6h - T6i;
+ io[WS(ios, 7)] = T6h + T6i;
+ }
+ {
+ E T2Z, T32, T6d, T6g;
+ T2Z = T2N - T2Q;
+ T32 = T30 - T31;
+ ro[WS(ros, 23)] = T2Z - T32;
+ ro[WS(ros, 8)] = T2Z + T32;
+ T6d = T2X - T2U;
+ T6g = T6e - T6f;
+ io[WS(ios, 23)] = T6d - T6g;
+ io[WS(ios, 8)] = T6d + T6g;
+ }
+ }
+ {
+ E T5j, T5L, T6R, T6X, T5q, T6W, T5V, T5Y, T5y, T5J, T5O, T6O, T5S, T5Z, T5F;
+ E T5I, T5i, T6P;
+ T5i = T5g - T5h;
+ T5j = T5f - T5i;
+ T5L = T5f + T5i;
+ T6P = T3Z + T3W;
+ T6R = T6P - T6Q;
+ T6X = T6P + T6Q;
+ {
+ E T5m, T5p, T5T, T5U;
+ T5m = FMA(KP290284677, T5k, KP956940335 * T5l);
+ T5p = FNMS(KP290284677, T5o, KP956940335 * T5n);
+ T5q = T5m - T5p;
+ T6W = T5p + T5m;
+ T5T = T5z + T5A;
+ T5U = T5C + T5D;
+ T5V = FNMS(KP146730474, T5U, KP989176509 * T5T);
+ T5Y = FMA(KP146730474, T5T, KP989176509 * T5U);
+ }
+ {
+ E T5u, T5x, T5M, T5N;
+ T5u = T5s - T5t;
+ T5x = T5v - T5w;
+ T5y = FMA(KP803207531, T5u, KP595699304 * T5x);
+ T5J = FNMS(KP595699304, T5u, KP803207531 * T5x);
+ T5M = FMA(KP956940335, T5o, KP290284677 * T5n);
+ T5N = FNMS(KP290284677, T5l, KP956940335 * T5k);
+ T5O = T5M + T5N;
+ T6O = T5N - T5M;
+ }
+ {
+ E T5Q, T5R, T5B, T5E;
+ T5Q = T5s + T5t;
+ T5R = T5v + T5w;
+ T5S = FMA(KP989176509, T5Q, KP146730474 * T5R);
+ T5Z = FNMS(KP146730474, T5Q, KP989176509 * T5R);
+ T5B = T5z - T5A;
+ T5E = T5C - T5D;
+ T5F = FNMS(KP595699304, T5E, KP803207531 * T5B);
+ T5I = FMA(KP595699304, T5B, KP803207531 * T5E);
+ }
+ {
+ E T5r, T5G, T6T, T6U;
+ T5r = T5j + T5q;
+ T5G = T5y + T5F;
+ ro[WS(ros, 25)] = T5r - T5G;
+ ro[WS(ros, 6)] = T5r + T5G;
+ T6T = T5J + T5I;
+ T6U = T6O + T6R;
+ io[WS(ios, 25)] = T6T - T6U;
+ io[WS(ios, 6)] = T6T + T6U;
+ }
+ {
+ E T5H, T5K, T6N, T6S;
+ T5H = T5j - T5q;
+ T5K = T5I - T5J;
+ ro[WS(ros, 22)] = T5H - T5K;
+ ro[WS(ros, 9)] = T5H + T5K;
+ T6N = T5F - T5y;
+ T6S = T6O - T6R;
+ io[WS(ios, 22)] = T6N - T6S;
+ io[WS(ios, 9)] = T6N + T6S;
+ }
+ {
+ E T5P, T5W, T6Z, T70;
+ T5P = T5L + T5O;
+ T5W = T5S + T5V;
+ ro[WS(ros, 30)] = T5P - T5W;
+ ro[WS(ros, 1)] = T5P + T5W;
+ T6Z = T5Z + T5Y;
+ T70 = T6W + T6X;
+ io[WS(ios, 30)] = T6Z - T70;
+ io[WS(ios, 1)] = T6Z + T70;
+ }
+ {
+ E T5X, T60, T6V, T6Y;
+ T5X = T5L - T5O;
+ T60 = T5Y - T5Z;
+ ro[WS(ros, 17)] = T5X - T60;
+ ro[WS(ros, 14)] = T5X + T60;
+ T6V = T5V - T5S;
+ T6Y = T6W - T6X;
+ io[WS(ios, 17)] = T6V - T6Y;
+ io[WS(ios, 14)] = T6V + T6Y;
+ }
+ }
+ {
+ E T37, T3z, T6n, T6t, T3e, T6s, T3J, T3M, T3m, T3x, T3C, T6k, T3G, T3N, T3t;
+ E T3w, T36, T6l;
+ T36 = T34 + T35;
+ T37 = T33 - T36;
+ T3z = T33 + T36;
+ T6l = Tv - Tm;
+ T6n = T6l - T6m;
+ T6t = T6l + T6m;
+ {
+ E T3a, T3d, T3H, T3I;
+ T3a = FMA(KP634393284, T38, KP773010453 * T39);
+ T3d = FNMS(KP634393284, T3c, KP773010453 * T3b);
+ T3e = T3a - T3d;
+ T6s = T3d + T3a;
+ T3H = T3n + T3o;
+ T3I = T3q + T3r;
+ T3J = FNMS(KP336889853, T3I, KP941544065 * T3H);
+ T3M = FMA(KP336889853, T3H, KP941544065 * T3I);
+ }
+ {
+ E T3i, T3l, T3A, T3B;
+ T3i = T3g - T3h;
+ T3l = T3j - T3k;
+ T3m = FMA(KP903989293, T3i, KP427555093 * T3l);
+ T3x = FNMS(KP427555093, T3i, KP903989293 * T3l);
+ T3A = FMA(KP773010453, T3c, KP634393284 * T3b);
+ T3B = FNMS(KP634393284, T39, KP773010453 * T38);
+ T3C = T3A + T3B;
+ T6k = T3B - T3A;
+ }
+ {
+ E T3E, T3F, T3p, T3s;
+ T3E = T3g + T3h;
+ T3F = T3j + T3k;
+ T3G = FMA(KP941544065, T3E, KP336889853 * T3F);
+ T3N = FNMS(KP336889853, T3E, KP941544065 * T3F);
+ T3p = T3n - T3o;
+ T3s = T3q - T3r;
+ T3t = FNMS(KP427555093, T3s, KP903989293 * T3p);
+ T3w = FMA(KP427555093, T3p, KP903989293 * T3s);
+ }
+ {
+ E T3f, T3u, T6p, T6q;
+ T3f = T37 + T3e;
+ T3u = T3m + T3t;
+ ro[WS(ros, 27)] = T3f - T3u;
+ ro[WS(ros, 4)] = T3f + T3u;
+ T6p = T3x + T3w;
+ T6q = T6k + T6n;
+ io[WS(ios, 27)] = T6p - T6q;
+ io[WS(ios, 4)] = T6p + T6q;
+ }
+ {
+ E T3v, T3y, T6j, T6o;
+ T3v = T37 - T3e;
+ T3y = T3w - T3x;
+ ro[WS(ros, 20)] = T3v - T3y;
+ ro[WS(ros, 11)] = T3v + T3y;
+ T6j = T3t - T3m;
+ T6o = T6k - T6n;
+ io[WS(ios, 20)] = T6j - T6o;
+ io[WS(ios, 11)] = T6j + T6o;
+ }
+ {
+ E T3D, T3K, T6v, T6w;
+ T3D = T3z + T3C;
+ T3K = T3G + T3J;
+ ro[WS(ros, 28)] = T3D - T3K;
+ ro[WS(ros, 3)] = T3D + T3K;
+ T6v = T3N + T3M;
+ T6w = T6s + T6t;
+ io[WS(ios, 28)] = T6v - T6w;
+ io[WS(ios, 3)] = T6v + T6w;
+ }
+ {
+ E T3L, T3O, T6r, T6u;
+ T3L = T3z - T3C;
+ T3O = T3M - T3N;
+ ro[WS(ros, 19)] = T3L - T3O;
+ ro[WS(ros, 12)] = T3L + T3O;
+ T6r = T3J - T3G;
+ T6u = T6s - T6t;
+ io[WS(ios, 19)] = T6r - T6u;
+ io[WS(ios, 12)] = T6r + T6u;
+ }
+ }
+ {
+ E T41, T4Z, T6D, T6J, T4g, T6I, T59, T5d, T4A, T4X, T52, T6y, T56, T5c, T4T;
+ E T4W, T40, T6C;
+ T40 = T3W - T3Z;
+ T41 = T3T + T40;
+ T4Z = T3T - T40;
+ T6C = T5g + T5h;
+ T6D = T6B - T6C;
+ T6J = T6C + T6B;
+ {
+ E T48, T4f, T57, T58;
+ T48 = FMA(KP881921264, T44, KP471396736 * T47);
+ T4f = FMA(KP881921264, T4b, KP471396736 * T4e);
+ T4g = T48 - T4f;
+ T6I = T48 + T4f;
+ T57 = T4K + T4H;
+ T58 = T4R + T4O;
+ T59 = FMA(KP514102744, T57, KP857728610 * T58);
+ T5d = FNMS(KP857728610, T57, KP514102744 * T58);
+ }
+ {
+ E T4s, T4z, T50, T51;
+ T4s = T4k + T4r;
+ T4z = T4v - T4y;
+ T4A = FMA(KP970031253, T4s, KP242980179 * T4z);
+ T4X = FNMS(KP242980179, T4s, KP970031253 * T4z);
+ T50 = FNMS(KP471396736, T4b, KP881921264 * T4e);
+ T51 = FNMS(KP471396736, T44, KP881921264 * T47);
+ T52 = T50 - T51;
+ T6y = T51 + T50;
+ }
+ {
+ E T54, T55, T4L, T4S;
+ T54 = T4k - T4r;
+ T55 = T4y + T4v;
+ T56 = FMA(KP514102744, T54, KP857728610 * T55);
+ T5c = FNMS(KP514102744, T55, KP857728610 * T54);
+ T4L = T4H - T4K;
+ T4S = T4O - T4R;
+ T4T = FNMS(KP242980179, T4S, KP970031253 * T4L);
+ T4W = FMA(KP242980179, T4L, KP970031253 * T4S);
+ }
+ {
+ E T4h, T4U, T6F, T6G;
+ T4h = T41 + T4g;
+ T4U = T4A + T4T;
+ ro[WS(ros, 29)] = T4h - T4U;
+ ro[WS(ros, 2)] = T4h + T4U;
+ T6F = T4X + T4W;
+ T6G = T6y + T6D;
+ io[WS(ios, 29)] = T6F - T6G;
+ io[WS(ios, 2)] = T6F + T6G;
+ }
+ {
+ E T4V, T4Y, T6x, T6E;
+ T4V = T41 - T4g;
+ T4Y = T4W - T4X;
+ ro[WS(ros, 18)] = T4V - T4Y;
+ ro[WS(ros, 13)] = T4V + T4Y;
+ T6x = T4T - T4A;
+ T6E = T6y - T6D;
+ io[WS(ios, 18)] = T6x - T6E;
+ io[WS(ios, 13)] = T6x + T6E;
+ }
+ {
+ E T53, T5a, T6L, T6M;
+ T53 = T4Z - T52;
+ T5a = T56 - T59;
+ ro[WS(ros, 21)] = T53 - T5a;
+ ro[WS(ros, 10)] = T53 + T5a;
+ T6L = T5d - T5c;
+ T6M = T6J - T6I;
+ io[WS(ios, 21)] = T6L - T6M;
+ io[WS(ios, 10)] = T6L + T6M;
+ }
+ {
+ E T5b, T5e, T6H, T6K;
+ T5b = T4Z + T52;
+ T5e = T5c + T5d;
+ ro[WS(ros, 26)] = T5b - T5e;
+ ro[WS(ros, 5)] = T5b + T5e;
+ T6H = T56 + T59;
+ T6K = T6I + T6J;
+ io[WS(ios, 5)] = -(T6H + T6K);
+ io[WS(ios, 26)] = T6K - T6H;
+ }
+ }
+ }
+}
+
+static void mr2hcII_64(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; --i) {
+ mr2hcII_64_0(I, ro, io, is, ros, ios);
+ I += ivs;
+ ro += ovs;
+ io += ovs;
+ }
+}
+
+static const kr2hc_desc desc = { 64, "mr2hcII_64", {342, 114, 92, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_mr2hcII_64) (planner *p) {
+ X(kr2hcII_register) (p, mr2hcII_64, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c
new file mode 100644
index 0000000..0409559
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_128.c
@@ -0,0 +1,1647 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:49 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 128 -name mr2hc_128 -include r2hc.h */
+
+/*
+ * This function contains 956 FP additions, 330 FP multiplications,
+ * (or, 812 additions, 186 multiplications, 144 fused multiply/add),
+ * 185 stack variables, and 256 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_128.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void mr2hc_128_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios)
+{
+ DK(KP803207531, +0.803207531480644909806676512963141923879569427);
+ DK(KP595699304, +0.595699304492433343467036528829969889511926338);
+ DK(KP146730474, +0.146730474455361751658850129646717819706215317);
+ DK(KP989176509, +0.989176509964780973451673738016243063983689533);
+ DK(KP740951125, +0.740951125354959091175616897495162729728955309);
+ DK(KP671558954, +0.671558954847018400625376850427421803228750632);
+ DK(KP049067674, +0.049067674327418014254954976942682658314745363);
+ DK(KP998795456, +0.998795456205172392714771604759100694443203615);
+ DK(KP242980179, +0.242980179903263889948274162077471118320990783);
+ DK(KP970031253, +0.970031253194543992603984207286100251456865962);
+ DK(KP514102744, +0.514102744193221726593693838968815772608049120);
+ DK(KP857728610, +0.857728610000272069902269984284770137042490799);
+ DK(KP336889853, +0.336889853392220050689253212619147570477766780);
+ DK(KP941544065, +0.941544065183020778412509402599502357185589796);
+ DK(KP427555093, +0.427555093430282094320966856888798534304578629);
+ DK(KP903989293, +0.903989293123443331586200297230537048710132025);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ {
+ E TcD, TdU, T27, T7r, T5S, T8y, Tf, Ta5, Tu, Tbq, TcG, TdV, T2e, T8z, T5V;
+ E T7s, TK, Ta6, TcK, TdX, T2o, T5X, T7w, T8B, TZ, Ta7, TcN, TdY, T2x, T5Y;
+ E T7z, T8C, T1g, Taa, TcU, TeA, TcX, Tez, T1v, Tab, T2M, T6z, T7E, T9e, T7H;
+ E T9d, T2T, T6A, T4X, T6L, Tdz, TeL, TdK, TeP, T5G, T6P, T8d, T9p, TaV, Tc3;
+ E Tbi, Tc4, T8o, T9t, T3I, T6H, Tde, TeH, Tdp, TeF, T4r, T6F, T7U, T9l, Tao;
+ E TbW, TaL, TbX, T85, T9j, T1L, Tad, Td3, Tew, Td6, Tex, T20, Tae, T37, T6x;
+ E T7L, T9a, T7O, T9b, T3e, T6w, TbZ, Tc0, T3Z, T4s, Tds, TeI, T4g, T4t, T80;
+ E T87, Tdl, TeE, T7X, T86, TaD, TaM, Tc6, Tc7, T5e, T5H, TdN, TeM, T5v, T5I;
+ E T8j, T8q, TdG, TeO, T8g, T8p, Tba, Tbj;
+ {
+ E T3, T23, Td, T25, T6, T5R, Ta, T24;
+ {
+ E T1, T2, Tb, Tc;
+ T1 = I[0];
+ T2 = I[WS(is, 64)];
+ T3 = T1 + T2;
+ T23 = T1 - T2;
+ Tb = I[WS(is, 112)];
+ Tc = I[WS(is, 48)];
+ Td = Tb + Tc;
+ T25 = Tb - Tc;
+ }
+ {
+ E T4, T5, T8, T9;
+ T4 = I[WS(is, 32)];
+ T5 = I[WS(is, 96)];
+ T6 = T4 + T5;
+ T5R = T4 - T5;
+ T8 = I[WS(is, 16)];
+ T9 = I[WS(is, 80)];
+ Ta = T8 + T9;
+ T24 = T8 - T9;
+ }
+ TcD = T3 - T6;
+ TdU = Td - Ta;
+ {
+ E T26, T5Q, T7, Te;
+ T26 = KP707106781 * (T24 + T25);
+ T27 = T23 + T26;
+ T7r = T23 - T26;
+ T5Q = KP707106781 * (T25 - T24);
+ T5S = T5Q - T5R;
+ T8y = T5R + T5Q;
+ T7 = T3 + T6;
+ Te = Ta + Td;
+ Tf = T7 + Te;
+ Ta5 = T7 - Te;
+ }
+ }
+ {
+ E Ti, T28, Ts, T2c, Tl, T29, Tp, T2b;
+ {
+ E Tg, Th, Tq, Tr;
+ Tg = I[WS(is, 8)];
+ Th = I[WS(is, 72)];
+ Ti = Tg + Th;
+ T28 = Tg - Th;
+ Tq = I[WS(is, 24)];
+ Tr = I[WS(is, 88)];
+ Ts = Tq + Tr;
+ T2c = Tq - Tr;
+ }
+ {
+ E Tj, Tk, Tn, To;
+ Tj = I[WS(is, 40)];
+ Tk = I[WS(is, 104)];
+ Tl = Tj + Tk;
+ T29 = Tj - Tk;
+ Tn = I[WS(is, 120)];
+ To = I[WS(is, 56)];
+ Tp = Tn + To;
+ T2b = Tn - To;
+ }
+ {
+ E Tm, Tt, TcE, TcF;
+ Tm = Ti + Tl;
+ Tt = Tp + Ts;
+ Tu = Tm + Tt;
+ Tbq = Tt - Tm;
+ TcE = Ti - Tl;
+ TcF = Tp - Ts;
+ TcG = KP707106781 * (TcE + TcF);
+ TdV = KP707106781 * (TcF - TcE);
+ }
+ {
+ E T2a, T2d, T5T, T5U;
+ T2a = FNMS(KP382683432, T29, KP923879532 * T28);
+ T2d = FMA(KP923879532, T2b, KP382683432 * T2c);
+ T2e = T2a + T2d;
+ T8z = T2d - T2a;
+ T5T = FNMS(KP923879532, T2c, KP382683432 * T2b);
+ T5U = FMA(KP382683432, T28, KP923879532 * T29);
+ T5V = T5T - T5U;
+ T7s = T5U + T5T;
+ }
+ }
+ {
+ E Ty, T2g, TB, T2m, TF, T2l, TI, T2j;
+ {
+ E Tw, Tx, Tz, TA;
+ Tw = I[WS(is, 4)];
+ Tx = I[WS(is, 68)];
+ Ty = Tw + Tx;
+ T2g = Tw - Tx;
+ Tz = I[WS(is, 36)];
+ TA = I[WS(is, 100)];
+ TB = Tz + TA;
+ T2m = Tz - TA;
+ {
+ E TD, TE, T2h, TG, TH, T2i;
+ TD = I[WS(is, 20)];
+ TE = I[WS(is, 84)];
+ T2h = TD - TE;
+ TG = I[WS(is, 116)];
+ TH = I[WS(is, 52)];
+ T2i = TG - TH;
+ TF = TD + TE;
+ T2l = KP707106781 * (T2i - T2h);
+ TI = TG + TH;
+ T2j = KP707106781 * (T2h + T2i);
+ }
+ }
+ {
+ E TC, TJ, TcI, TcJ;
+ TC = Ty + TB;
+ TJ = TF + TI;
+ TK = TC + TJ;
+ Ta6 = TC - TJ;
+ TcI = Ty - TB;
+ TcJ = TI - TF;
+ TcK = FMA(KP923879532, TcI, KP382683432 * TcJ);
+ TdX = FNMS(KP382683432, TcI, KP923879532 * TcJ);
+ }
+ {
+ E T2k, T2n, T7u, T7v;
+ T2k = T2g + T2j;
+ T2n = T2l - T2m;
+ T2o = FMA(KP980785280, T2k, KP195090322 * T2n);
+ T5X = FNMS(KP195090322, T2k, KP980785280 * T2n);
+ T7u = T2g - T2j;
+ T7v = T2m + T2l;
+ T7w = FMA(KP831469612, T7u, KP555570233 * T7v);
+ T8B = FNMS(KP555570233, T7u, KP831469612 * T7v);
+ }
+ }
+ {
+ E TN, T2p, TQ, T2v, TU, T2u, TX, T2s;
+ {
+ E TL, TM, TO, TP;
+ TL = I[WS(is, 124)];
+ TM = I[WS(is, 60)];
+ TN = TL + TM;
+ T2p = TL - TM;
+ TO = I[WS(is, 28)];
+ TP = I[WS(is, 92)];
+ TQ = TO + TP;
+ T2v = TO - TP;
+ {
+ E TS, TT, T2q, TV, TW, T2r;
+ TS = I[WS(is, 12)];
+ TT = I[WS(is, 76)];
+ T2q = TS - TT;
+ TV = I[WS(is, 108)];
+ TW = I[WS(is, 44)];
+ T2r = TV - TW;
+ TU = TS + TT;
+ T2u = KP707106781 * (T2r - T2q);
+ TX = TV + TW;
+ T2s = KP707106781 * (T2q + T2r);
+ }
+ }
+ {
+ E TR, TY, TcL, TcM;
+ TR = TN + TQ;
+ TY = TU + TX;
+ TZ = TR + TY;
+ Ta7 = TR - TY;
+ TcL = TN - TQ;
+ TcM = TX - TU;
+ TcN = FNMS(KP382683432, TcM, KP923879532 * TcL);
+ TdY = FMA(KP382683432, TcL, KP923879532 * TcM);
+ }
+ {
+ E T2t, T2w, T7x, T7y;
+ T2t = T2p + T2s;
+ T2w = T2u - T2v;
+ T2x = FNMS(KP195090322, T2w, KP980785280 * T2t);
+ T5Y = FMA(KP195090322, T2t, KP980785280 * T2w);
+ T7x = T2p - T2s;
+ T7y = T2v + T2u;
+ T7z = FNMS(KP555570233, T7y, KP831469612 * T7x);
+ T8C = FMA(KP555570233, T7x, KP831469612 * T7y);
+ }
+ }
+ {
+ E T14, T2N, T17, T2D, T1b, T2O, T1e, T2C, T1j, T1m, T2K, TcR, T2Q, T1q, T1t;
+ E T2H, TcS, T2R;
+ {
+ E T12, T13, T15, T16;
+ T12 = I[WS(is, 2)];
+ T13 = I[WS(is, 66)];
+ T14 = T12 + T13;
+ T2N = T12 - T13;
+ T15 = I[WS(is, 34)];
+ T16 = I[WS(is, 98)];
+ T17 = T15 + T16;
+ T2D = T15 - T16;
+ }
+ {
+ E T19, T1a, T2B, T1c, T1d, T2A;
+ T19 = I[WS(is, 18)];
+ T1a = I[WS(is, 82)];
+ T2B = T19 - T1a;
+ T1c = I[WS(is, 114)];
+ T1d = I[WS(is, 50)];
+ T2A = T1c - T1d;
+ T1b = T19 + T1a;
+ T2O = KP707106781 * (T2B + T2A);
+ T1e = T1c + T1d;
+ T2C = KP707106781 * (T2A - T2B);
+ }
+ {
+ E T2I, T2J, T2F, T2G;
+ {
+ E T1h, T1i, T1k, T1l;
+ T1h = I[WS(is, 10)];
+ T1i = I[WS(is, 74)];
+ T1j = T1h + T1i;
+ T2I = T1h - T1i;
+ T1k = I[WS(is, 42)];
+ T1l = I[WS(is, 106)];
+ T1m = T1k + T1l;
+ T2J = T1k - T1l;
+ }
+ T2K = FMA(KP382683432, T2I, KP923879532 * T2J);
+ TcR = T1j - T1m;
+ T2Q = FNMS(KP382683432, T2J, KP923879532 * T2I);
+ {
+ E T1o, T1p, T1r, T1s;
+ T1o = I[WS(is, 122)];
+ T1p = I[WS(is, 58)];
+ T1q = T1o + T1p;
+ T2F = T1o - T1p;
+ T1r = I[WS(is, 26)];
+ T1s = I[WS(is, 90)];
+ T1t = T1r + T1s;
+ T2G = T1r - T1s;
+ }
+ T2H = FNMS(KP923879532, T2G, KP382683432 * T2F);
+ TcS = T1q - T1t;
+ T2R = FMA(KP923879532, T2F, KP382683432 * T2G);
+ }
+ {
+ E T18, T1f, TcQ, TcT;
+ T18 = T14 + T17;
+ T1f = T1b + T1e;
+ T1g = T18 + T1f;
+ Taa = T18 - T1f;
+ TcQ = T14 - T17;
+ TcT = KP707106781 * (TcR + TcS);
+ TcU = TcQ + TcT;
+ TeA = TcQ - TcT;
+ }
+ {
+ E TcV, TcW, T1n, T1u;
+ TcV = T1e - T1b;
+ TcW = KP707106781 * (TcS - TcR);
+ TcX = TcV + TcW;
+ Tez = TcW - TcV;
+ T1n = T1j + T1m;
+ T1u = T1q + T1t;
+ T1v = T1n + T1u;
+ Tab = T1u - T1n;
+ }
+ {
+ E T2E, T2L, T7C, T7D;
+ T2E = T2C - T2D;
+ T2L = T2H - T2K;
+ T2M = T2E + T2L;
+ T6z = T2L - T2E;
+ T7C = T2N - T2O;
+ T7D = T2K + T2H;
+ T7E = T7C + T7D;
+ T9e = T7C - T7D;
+ }
+ {
+ E T7F, T7G, T2P, T2S;
+ T7F = T2D + T2C;
+ T7G = T2R - T2Q;
+ T7H = T7F + T7G;
+ T9d = T7G - T7F;
+ T2P = T2N + T2O;
+ T2S = T2Q + T2R;
+ T2T = T2P + T2S;
+ T6A = T2P - T2S;
+ }
+ }
+ {
+ E T4z, TaP, T5B, TaQ, T4G, TaT, T5y, TaS, Tbf, Tbg, T4O, Tdw, T5E, Tbc, Tbd;
+ E T4V, Tdx, T5D;
+ {
+ E T4x, T4y, T5z, T5A;
+ T4x = I[WS(is, 127)];
+ T4y = I[WS(is, 63)];
+ T4z = T4x - T4y;
+ TaP = T4x + T4y;
+ T5z = I[WS(is, 31)];
+ T5A = I[WS(is, 95)];
+ T5B = T5z - T5A;
+ TaQ = T5z + T5A;
+ }
+ {
+ E T4A, T4B, T4C, T4D, T4E, T4F;
+ T4A = I[WS(is, 15)];
+ T4B = I[WS(is, 79)];
+ T4C = T4A - T4B;
+ T4D = I[WS(is, 111)];
+ T4E = I[WS(is, 47)];
+ T4F = T4D - T4E;
+ T4G = KP707106781 * (T4C + T4F);
+ TaT = T4D + T4E;
+ T5y = KP707106781 * (T4F - T4C);
+ TaS = T4A + T4B;
+ }
+ {
+ E T4K, T4N, T4R, T4U;
+ {
+ E T4I, T4J, T4L, T4M;
+ T4I = I[WS(is, 7)];
+ T4J = I[WS(is, 71)];
+ T4K = T4I - T4J;
+ Tbf = T4I + T4J;
+ T4L = I[WS(is, 39)];
+ T4M = I[WS(is, 103)];
+ T4N = T4L - T4M;
+ Tbg = T4L + T4M;
+ }
+ T4O = FNMS(KP382683432, T4N, KP923879532 * T4K);
+ Tdw = Tbf - Tbg;
+ T5E = FMA(KP382683432, T4K, KP923879532 * T4N);
+ {
+ E T4P, T4Q, T4S, T4T;
+ T4P = I[WS(is, 119)];
+ T4Q = I[WS(is, 55)];
+ T4R = T4P - T4Q;
+ Tbc = T4P + T4Q;
+ T4S = I[WS(is, 23)];
+ T4T = I[WS(is, 87)];
+ T4U = T4S - T4T;
+ Tbd = T4S + T4T;
+ }
+ T4V = FMA(KP923879532, T4R, KP382683432 * T4U);
+ Tdx = Tbc - Tbd;
+ T5D = FNMS(KP923879532, T4U, KP382683432 * T4R);
+ }
+ {
+ E T4H, T4W, Tdv, Tdy;
+ T4H = T4z + T4G;
+ T4W = T4O + T4V;
+ T4X = T4H + T4W;
+ T6L = T4H - T4W;
+ Tdv = TaP - TaQ;
+ Tdy = KP707106781 * (Tdw + Tdx);
+ Tdz = Tdv + Tdy;
+ TeL = Tdv - Tdy;
+ }
+ {
+ E TdI, TdJ, T5C, T5F;
+ TdI = TaT - TaS;
+ TdJ = KP707106781 * (Tdx - Tdw);
+ TdK = TdI + TdJ;
+ TeP = TdJ - TdI;
+ T5C = T5y - T5B;
+ T5F = T5D - T5E;
+ T5G = T5C + T5F;
+ T6P = T5F - T5C;
+ }
+ {
+ E T8b, T8c, TaR, TaU;
+ T8b = T4z - T4G;
+ T8c = T5E + T5D;
+ T8d = T8b + T8c;
+ T9p = T8b - T8c;
+ TaR = TaP + TaQ;
+ TaU = TaS + TaT;
+ TaV = TaR - TaU;
+ Tc3 = TaR + TaU;
+ }
+ {
+ E Tbe, Tbh, T8m, T8n;
+ Tbe = Tbc + Tbd;
+ Tbh = Tbf + Tbg;
+ Tbi = Tbe - Tbh;
+ Tc4 = Tbh + Tbe;
+ T8m = T5B + T5y;
+ T8n = T4V - T4O;
+ T8o = T8m + T8n;
+ T9t = T8n - T8m;
+ }
+ }
+ {
+ E T3k, Tai, T4m, Taj, T3r, Tam, T4j, Tal, TaI, TaJ, T3z, Tdb, T4p, TaF, TaG;
+ E T3G, Tdc, T4o;
+ {
+ E T3i, T3j, T4k, T4l;
+ T3i = I[WS(is, 1)];
+ T3j = I[WS(is, 65)];
+ T3k = T3i - T3j;
+ Tai = T3i + T3j;
+ T4k = I[WS(is, 33)];
+ T4l = I[WS(is, 97)];
+ T4m = T4k - T4l;
+ Taj = T4k + T4l;
+ }
+ {
+ E T3l, T3m, T3n, T3o, T3p, T3q;
+ T3l = I[WS(is, 17)];
+ T3m = I[WS(is, 81)];
+ T3n = T3l - T3m;
+ T3o = I[WS(is, 113)];
+ T3p = I[WS(is, 49)];
+ T3q = T3o - T3p;
+ T3r = KP707106781 * (T3n + T3q);
+ Tam = T3o + T3p;
+ T4j = KP707106781 * (T3q - T3n);
+ Tal = T3l + T3m;
+ }
+ {
+ E T3v, T3y, T3C, T3F;
+ {
+ E T3t, T3u, T3w, T3x;
+ T3t = I[WS(is, 9)];
+ T3u = I[WS(is, 73)];
+ T3v = T3t - T3u;
+ TaI = T3t + T3u;
+ T3w = I[WS(is, 41)];
+ T3x = I[WS(is, 105)];
+ T3y = T3w - T3x;
+ TaJ = T3w + T3x;
+ }
+ T3z = FNMS(KP382683432, T3y, KP923879532 * T3v);
+ Tdb = TaI - TaJ;
+ T4p = FMA(KP382683432, T3v, KP923879532 * T3y);
+ {
+ E T3A, T3B, T3D, T3E;
+ T3A = I[WS(is, 121)];
+ T3B = I[WS(is, 57)];
+ T3C = T3A - T3B;
+ TaF = T3A + T3B;
+ T3D = I[WS(is, 25)];
+ T3E = I[WS(is, 89)];
+ T3F = T3D - T3E;
+ TaG = T3D + T3E;
+ }
+ T3G = FMA(KP923879532, T3C, KP382683432 * T3F);
+ Tdc = TaF - TaG;
+ T4o = FNMS(KP923879532, T3F, KP382683432 * T3C);
+ }
+ {
+ E T3s, T3H, Tda, Tdd;
+ T3s = T3k + T3r;
+ T3H = T3z + T3G;
+ T3I = T3s + T3H;
+ T6H = T3s - T3H;
+ Tda = Tai - Taj;
+ Tdd = KP707106781 * (Tdb + Tdc);
+ Tde = Tda + Tdd;
+ TeH = Tda - Tdd;
+ }
+ {
+ E Tdn, Tdo, T4n, T4q;
+ Tdn = Tam - Tal;
+ Tdo = KP707106781 * (Tdc - Tdb);
+ Tdp = Tdn + Tdo;
+ TeF = Tdo - Tdn;
+ T4n = T4j - T4m;
+ T4q = T4o - T4p;
+ T4r = T4n + T4q;
+ T6F = T4q - T4n;
+ }
+ {
+ E T7S, T7T, Tak, Tan;
+ T7S = T3k - T3r;
+ T7T = T4p + T4o;
+ T7U = T7S + T7T;
+ T9l = T7S - T7T;
+ Tak = Tai + Taj;
+ Tan = Tal + Tam;
+ Tao = Tak - Tan;
+ TbW = Tak + Tan;
+ }
+ {
+ E TaH, TaK, T83, T84;
+ TaH = TaF + TaG;
+ TaK = TaI + TaJ;
+ TaL = TaH - TaK;
+ TbX = TaK + TaH;
+ T83 = T4m + T4j;
+ T84 = T3G - T3z;
+ T85 = T83 + T84;
+ T9j = T84 - T83;
+ }
+ }
+ {
+ E T1z, T2V, T1C, T39, T1G, T38, T1J, T2Y, T1O, T1R, T32, Td0, T3c, T1V, T1Y;
+ E T35, Td1, T3b;
+ {
+ E T1x, T1y, T1A, T1B;
+ T1x = I[WS(is, 126)];
+ T1y = I[WS(is, 62)];
+ T1z = T1x + T1y;
+ T2V = T1x - T1y;
+ T1A = I[WS(is, 30)];
+ T1B = I[WS(is, 94)];
+ T1C = T1A + T1B;
+ T39 = T1A - T1B;
+ }
+ {
+ E T1E, T1F, T2W, T1H, T1I, T2X;
+ T1E = I[WS(is, 14)];
+ T1F = I[WS(is, 78)];
+ T2W = T1E - T1F;
+ T1H = I[WS(is, 110)];
+ T1I = I[WS(is, 46)];
+ T2X = T1H - T1I;
+ T1G = T1E + T1F;
+ T38 = KP707106781 * (T2X - T2W);
+ T1J = T1H + T1I;
+ T2Y = KP707106781 * (T2W + T2X);
+ }
+ {
+ E T30, T31, T33, T34;
+ {
+ E T1M, T1N, T1P, T1Q;
+ T1M = I[WS(is, 6)];
+ T1N = I[WS(is, 70)];
+ T1O = T1M + T1N;
+ T30 = T1M - T1N;
+ T1P = I[WS(is, 38)];
+ T1Q = I[WS(is, 102)];
+ T1R = T1P + T1Q;
+ T31 = T1P - T1Q;
+ }
+ T32 = FNMS(KP382683432, T31, KP923879532 * T30);
+ Td0 = T1O - T1R;
+ T3c = FMA(KP382683432, T30, KP923879532 * T31);
+ {
+ E T1T, T1U, T1W, T1X;
+ T1T = I[WS(is, 118)];
+ T1U = I[WS(is, 54)];
+ T1V = T1T + T1U;
+ T33 = T1T - T1U;
+ T1W = I[WS(is, 22)];
+ T1X = I[WS(is, 86)];
+ T1Y = T1W + T1X;
+ T34 = T1W - T1X;
+ }
+ T35 = FMA(KP923879532, T33, KP382683432 * T34);
+ Td1 = T1V - T1Y;
+ T3b = FNMS(KP923879532, T34, KP382683432 * T33);
+ }
+ {
+ E T1D, T1K, TcZ, Td2;
+ T1D = T1z + T1C;
+ T1K = T1G + T1J;
+ T1L = T1D + T1K;
+ Tad = T1D - T1K;
+ TcZ = T1z - T1C;
+ Td2 = KP707106781 * (Td0 + Td1);
+ Td3 = TcZ + Td2;
+ Tew = TcZ - Td2;
+ }
+ {
+ E Td4, Td5, T1S, T1Z;
+ Td4 = T1J - T1G;
+ Td5 = KP707106781 * (Td1 - Td0);
+ Td6 = Td4 + Td5;
+ Tex = Td5 - Td4;
+ T1S = T1O + T1R;
+ T1Z = T1V + T1Y;
+ T20 = T1S + T1Z;
+ Tae = T1Z - T1S;
+ }
+ {
+ E T2Z, T36, T7J, T7K;
+ T2Z = T2V + T2Y;
+ T36 = T32 + T35;
+ T37 = T2Z + T36;
+ T6x = T2Z - T36;
+ T7J = T2V - T2Y;
+ T7K = T3c + T3b;
+ T7L = T7J + T7K;
+ T9a = T7J - T7K;
+ }
+ {
+ E T7M, T7N, T3a, T3d;
+ T7M = T39 + T38;
+ T7N = T35 - T32;
+ T7O = T7M + T7N;
+ T9b = T7N - T7M;
+ T3a = T38 - T39;
+ T3d = T3b - T3c;
+ T3e = T3a + T3d;
+ T6w = T3d - T3a;
+ }
+ }
+ {
+ E T3L, Tdf, T3X, Tar, T42, Tdi, T4e, Tay, T3S, Tdg, T3U, Tau, T49, Tdj, T4b;
+ E TaB, Tdh, Tdk;
+ {
+ E T3J, T3K, Tap, T3V, T3W, Taq;
+ T3J = I[WS(is, 5)];
+ T3K = I[WS(is, 69)];
+ Tap = T3J + T3K;
+ T3V = I[WS(is, 37)];
+ T3W = I[WS(is, 101)];
+ Taq = T3V + T3W;
+ T3L = T3J - T3K;
+ Tdf = Tap - Taq;
+ T3X = T3V - T3W;
+ Tar = Tap + Taq;
+ }
+ {
+ E T40, T41, Taw, T4c, T4d, Tax;
+ T40 = I[WS(is, 125)];
+ T41 = I[WS(is, 61)];
+ Taw = T40 + T41;
+ T4c = I[WS(is, 29)];
+ T4d = I[WS(is, 93)];
+ Tax = T4c + T4d;
+ T42 = T40 - T41;
+ Tdi = Taw - Tax;
+ T4e = T4c - T4d;
+ Tay = Taw + Tax;
+ }
+ {
+ E T3O, Tas, T3R, Tat;
+ {
+ E T3M, T3N, T3P, T3Q;
+ T3M = I[WS(is, 21)];
+ T3N = I[WS(is, 85)];
+ T3O = T3M - T3N;
+ Tas = T3M + T3N;
+ T3P = I[WS(is, 117)];
+ T3Q = I[WS(is, 53)];
+ T3R = T3P - T3Q;
+ Tat = T3P + T3Q;
+ }
+ T3S = KP707106781 * (T3O + T3R);
+ Tdg = Tat - Tas;
+ T3U = KP707106781 * (T3R - T3O);
+ Tau = Tas + Tat;
+ }
+ {
+ E T45, Taz, T48, TaA;
+ {
+ E T43, T44, T46, T47;
+ T43 = I[WS(is, 13)];
+ T44 = I[WS(is, 77)];
+ T45 = T43 - T44;
+ Taz = T43 + T44;
+ T46 = I[WS(is, 109)];
+ T47 = I[WS(is, 45)];
+ T48 = T46 - T47;
+ TaA = T46 + T47;
+ }
+ T49 = KP707106781 * (T45 + T48);
+ Tdj = TaA - Taz;
+ T4b = KP707106781 * (T48 - T45);
+ TaB = Taz + TaA;
+ }
+ TbZ = Tar + Tau;
+ Tc0 = Tay + TaB;
+ {
+ E T3T, T3Y, Tdq, Tdr;
+ T3T = T3L + T3S;
+ T3Y = T3U - T3X;
+ T3Z = FMA(KP980785280, T3T, KP195090322 * T3Y);
+ T4s = FNMS(KP195090322, T3T, KP980785280 * T3Y);
+ Tdq = FNMS(KP382683432, Tdf, KP923879532 * Tdg);
+ Tdr = FMA(KP382683432, Tdi, KP923879532 * Tdj);
+ Tds = Tdq + Tdr;
+ TeI = Tdr - Tdq;
+ }
+ {
+ E T4a, T4f, T7Y, T7Z;
+ T4a = T42 + T49;
+ T4f = T4b - T4e;
+ T4g = FNMS(KP195090322, T4f, KP980785280 * T4a);
+ T4t = FMA(KP195090322, T4a, KP980785280 * T4f);
+ T7Y = T42 - T49;
+ T7Z = T4e + T4b;
+ T80 = FNMS(KP555570233, T7Z, KP831469612 * T7Y);
+ T87 = FMA(KP555570233, T7Y, KP831469612 * T7Z);
+ }
+ Tdh = FMA(KP923879532, Tdf, KP382683432 * Tdg);
+ Tdk = FNMS(KP382683432, Tdj, KP923879532 * Tdi);
+ Tdl = Tdh + Tdk;
+ TeE = Tdk - Tdh;
+ {
+ E T7V, T7W, Tav, TaC;
+ T7V = T3L - T3S;
+ T7W = T3X + T3U;
+ T7X = FMA(KP831469612, T7V, KP555570233 * T7W);
+ T86 = FNMS(KP555570233, T7V, KP831469612 * T7W);
+ Tav = Tar - Tau;
+ TaC = Tay - TaB;
+ TaD = KP707106781 * (Tav + TaC);
+ TaM = KP707106781 * (TaC - Tav);
+ }
+ }
+ {
+ E T50, TdA, T5c, TaY, T5h, TdD, T5t, Tb5, T57, TdB, T59, Tb1, T5o, TdE, T5q;
+ E Tb8, TdC, TdF;
+ {
+ E T4Y, T4Z, TaW, T5a, T5b, TaX;
+ T4Y = I[WS(is, 3)];
+ T4Z = I[WS(is, 67)];
+ TaW = T4Y + T4Z;
+ T5a = I[WS(is, 35)];
+ T5b = I[WS(is, 99)];
+ TaX = T5a + T5b;
+ T50 = T4Y - T4Z;
+ TdA = TaW - TaX;
+ T5c = T5a - T5b;
+ TaY = TaW + TaX;
+ }
+ {
+ E T5f, T5g, Tb3, T5r, T5s, Tb4;
+ T5f = I[WS(is, 123)];
+ T5g = I[WS(is, 59)];
+ Tb3 = T5f + T5g;
+ T5r = I[WS(is, 27)];
+ T5s = I[WS(is, 91)];
+ Tb4 = T5r + T5s;
+ T5h = T5f - T5g;
+ TdD = Tb3 - Tb4;
+ T5t = T5r - T5s;
+ Tb5 = Tb3 + Tb4;
+ }
+ {
+ E T53, TaZ, T56, Tb0;
+ {
+ E T51, T52, T54, T55;
+ T51 = I[WS(is, 19)];
+ T52 = I[WS(is, 83)];
+ T53 = T51 - T52;
+ TaZ = T51 + T52;
+ T54 = I[WS(is, 115)];
+ T55 = I[WS(is, 51)];
+ T56 = T54 - T55;
+ Tb0 = T54 + T55;
+ }
+ T57 = KP707106781 * (T53 + T56);
+ TdB = Tb0 - TaZ;
+ T59 = KP707106781 * (T56 - T53);
+ Tb1 = TaZ + Tb0;
+ }
+ {
+ E T5k, Tb6, T5n, Tb7;
+ {
+ E T5i, T5j, T5l, T5m;
+ T5i = I[WS(is, 11)];
+ T5j = I[WS(is, 75)];
+ T5k = T5i - T5j;
+ Tb6 = T5i + T5j;
+ T5l = I[WS(is, 107)];
+ T5m = I[WS(is, 43)];
+ T5n = T5l - T5m;
+ Tb7 = T5l + T5m;
+ }
+ T5o = KP707106781 * (T5k + T5n);
+ TdE = Tb7 - Tb6;
+ T5q = KP707106781 * (T5n - T5k);
+ Tb8 = Tb6 + Tb7;
+ }
+ Tc6 = TaY + Tb1;
+ Tc7 = Tb5 + Tb8;
+ {
+ E T58, T5d, TdL, TdM;
+ T58 = T50 + T57;
+ T5d = T59 - T5c;
+ T5e = FMA(KP980785280, T58, KP195090322 * T5d);
+ T5H = FNMS(KP195090322, T58, KP980785280 * T5d);
+ TdL = FNMS(KP382683432, TdA, KP923879532 * TdB);
+ TdM = FMA(KP382683432, TdD, KP923879532 * TdE);
+ TdN = TdL + TdM;
+ TeM = TdM - TdL;
+ }
+ {
+ E T5p, T5u, T8h, T8i;
+ T5p = T5h + T5o;
+ T5u = T5q - T5t;
+ T5v = FNMS(KP195090322, T5u, KP980785280 * T5p);
+ T5I = FMA(KP195090322, T5p, KP980785280 * T5u);
+ T8h = T5h - T5o;
+ T8i = T5t + T5q;
+ T8j = FNMS(KP555570233, T8i, KP831469612 * T8h);
+ T8q = FMA(KP555570233, T8h, KP831469612 * T8i);
+ }
+ TdC = FMA(KP923879532, TdA, KP382683432 * TdB);
+ TdF = FNMS(KP382683432, TdE, KP923879532 * TdD);
+ TdG = TdC + TdF;
+ TeO = TdF - TdC;
+ {
+ E T8e, T8f, Tb2, Tb9;
+ T8e = T50 - T57;
+ T8f = T5c + T59;
+ T8g = FMA(KP831469612, T8e, KP555570233 * T8f);
+ T8p = FNMS(KP555570233, T8e, KP831469612 * T8f);
+ Tb2 = TaY - Tb1;
+ Tb9 = Tb5 - Tb8;
+ Tba = KP707106781 * (Tb2 + Tb9);
+ Tbj = KP707106781 * (Tb9 - Tb2);
+ }
+ }
+ {
+ E T11, TbV, Tc9, Tcf, T22, Tcb, Tc2, Tce;
+ {
+ E Tv, T10, Tc5, Tc8;
+ Tv = Tf + Tu;
+ T10 = TK + TZ;
+ T11 = Tv + T10;
+ TbV = Tv - T10;
+ Tc5 = Tc3 + Tc4;
+ Tc8 = Tc6 + Tc7;
+ Tc9 = Tc5 - Tc8;
+ Tcf = Tc5 + Tc8;
+ }
+ {
+ E T1w, T21, TbY, Tc1;
+ T1w = T1g + T1v;
+ T21 = T1L + T20;
+ T22 = T1w + T21;
+ Tcb = T21 - T1w;
+ TbY = TbW + TbX;
+ Tc1 = TbZ + Tc0;
+ Tc2 = TbY - Tc1;
+ Tce = TbY + Tc1;
+ }
+ ro[WS(ros, 32)] = T11 - T22;
+ io[WS(ios, 32)] = Tcf - Tce;
+ {
+ E Tca, Tcc, Tcd, Tcg;
+ Tca = KP707106781 * (Tc2 + Tc9);
+ ro[WS(ros, 48)] = TbV - Tca;
+ ro[WS(ros, 16)] = TbV + Tca;
+ Tcc = KP707106781 * (Tc9 - Tc2);
+ io[WS(ios, 16)] = Tcb + Tcc;
+ io[WS(ios, 48)] = Tcc - Tcb;
+ Tcd = T11 + T22;
+ Tcg = Tce + Tcf;
+ ro[WS(ros, 64)] = Tcd - Tcg;
+ ro[0] = Tcd + Tcg;
+ }
+ }
+ {
+ E Tch, Tcu, Tck, Tct, Tco, Tcy, Tcr, Tcz, Tci, Tcj;
+ Tch = Tf - Tu;
+ Tcu = TZ - TK;
+ Tci = T1g - T1v;
+ Tcj = T1L - T20;
+ Tck = KP707106781 * (Tci + Tcj);
+ Tct = KP707106781 * (Tcj - Tci);
+ {
+ E Tcm, Tcn, Tcp, Tcq;
+ Tcm = TbW - TbX;
+ Tcn = Tc0 - TbZ;
+ Tco = FMA(KP923879532, Tcm, KP382683432 * Tcn);
+ Tcy = FNMS(KP382683432, Tcm, KP923879532 * Tcn);
+ Tcp = Tc3 - Tc4;
+ Tcq = Tc7 - Tc6;
+ Tcr = FNMS(KP382683432, Tcq, KP923879532 * Tcp);
+ Tcz = FMA(KP382683432, Tcp, KP923879532 * Tcq);
+ }
+ {
+ E Tcl, Tcs, Tcx, TcA;
+ Tcl = Tch + Tck;
+ Tcs = Tco + Tcr;
+ ro[WS(ros, 56)] = Tcl - Tcs;
+ ro[WS(ros, 8)] = Tcl + Tcs;
+ Tcx = Tcu + Tct;
+ TcA = Tcy + Tcz;
+ io[WS(ios, 8)] = Tcx + TcA;
+ io[WS(ios, 56)] = TcA - Tcx;
+ }
+ {
+ E Tcv, Tcw, TcB, TcC;
+ Tcv = Tct - Tcu;
+ Tcw = Tcr - Tco;
+ io[WS(ios, 24)] = Tcv + Tcw;
+ io[WS(ios, 40)] = Tcw - Tcv;
+ TcB = Tch - Tck;
+ TcC = Tcz - Tcy;
+ ro[WS(ros, 40)] = TcB - TcC;
+ ro[WS(ros, 24)] = TcB + TcC;
+ }
+ }
+ {
+ E Ta9, TbB, Tbs, TbM, Tag, TbL, TbJ, TbR, TaO, Tbw, Tbp, TbC, TbG, TbQ, Tbl;
+ E Tbx, Ta8, Tbr;
+ Ta8 = KP707106781 * (Ta6 + Ta7);
+ Ta9 = Ta5 + Ta8;
+ TbB = Ta5 - Ta8;
+ Tbr = KP707106781 * (Ta7 - Ta6);
+ Tbs = Tbq + Tbr;
+ TbM = Tbr - Tbq;
+ {
+ E Tac, Taf, TbH, TbI;
+ Tac = FMA(KP923879532, Taa, KP382683432 * Tab);
+ Taf = FNMS(KP382683432, Tae, KP923879532 * Tad);
+ Tag = Tac + Taf;
+ TbL = Taf - Tac;
+ TbH = TaV - Tba;
+ TbI = Tbj - Tbi;
+ TbJ = FNMS(KP555570233, TbI, KP831469612 * TbH);
+ TbR = FMA(KP555570233, TbH, KP831469612 * TbI);
+ }
+ {
+ E TaE, TaN, Tbn, Tbo;
+ TaE = Tao + TaD;
+ TaN = TaL + TaM;
+ TaO = FMA(KP980785280, TaE, KP195090322 * TaN);
+ Tbw = FNMS(KP195090322, TaE, KP980785280 * TaN);
+ Tbn = FNMS(KP382683432, Taa, KP923879532 * Tab);
+ Tbo = FMA(KP382683432, Tad, KP923879532 * Tae);
+ Tbp = Tbn + Tbo;
+ TbC = Tbo - Tbn;
+ }
+ {
+ E TbE, TbF, Tbb, Tbk;
+ TbE = Tao - TaD;
+ TbF = TaM - TaL;
+ TbG = FMA(KP831469612, TbE, KP555570233 * TbF);
+ TbQ = FNMS(KP555570233, TbE, KP831469612 * TbF);
+ Tbb = TaV + Tba;
+ Tbk = Tbi + Tbj;
+ Tbl = FNMS(KP195090322, Tbk, KP980785280 * Tbb);
+ Tbx = FMA(KP195090322, Tbb, KP980785280 * Tbk);
+ }
+ {
+ E Tah, Tbm, Tbv, Tby;
+ Tah = Ta9 + Tag;
+ Tbm = TaO + Tbl;
+ ro[WS(ros, 60)] = Tah - Tbm;
+ ro[WS(ros, 4)] = Tah + Tbm;
+ Tbv = Tbs + Tbp;
+ Tby = Tbw + Tbx;
+ io[WS(ios, 4)] = Tbv + Tby;
+ io[WS(ios, 60)] = Tby - Tbv;
+ }
+ {
+ E Tbt, Tbu, Tbz, TbA;
+ Tbt = Tbp - Tbs;
+ Tbu = Tbl - TaO;
+ io[WS(ios, 28)] = Tbt + Tbu;
+ io[WS(ios, 36)] = Tbu - Tbt;
+ Tbz = Ta9 - Tag;
+ TbA = Tbx - Tbw;
+ ro[WS(ros, 36)] = Tbz - TbA;
+ ro[WS(ros, 28)] = Tbz + TbA;
+ }
+ {
+ E TbD, TbK, TbP, TbS;
+ TbD = TbB + TbC;
+ TbK = TbG + TbJ;
+ ro[WS(ros, 52)] = TbD - TbK;
+ ro[WS(ros, 12)] = TbD + TbK;
+ TbP = TbM + TbL;
+ TbS = TbQ + TbR;
+ io[WS(ios, 12)] = TbP + TbS;
+ io[WS(ios, 52)] = TbS - TbP;
+ }
+ {
+ E TbN, TbO, TbT, TbU;
+ TbN = TbL - TbM;
+ TbO = TbJ - TbG;
+ io[WS(ios, 20)] = TbN + TbO;
+ io[WS(ios, 44)] = TbO - TbN;
+ TbT = TbB - TbC;
+ TbU = TbR - TbQ;
+ ro[WS(ros, 44)] = TbT - TbU;
+ ro[WS(ros, 20)] = TbT + TbU;
+ }
+ }
+ {
+ E Tev, Tf7, Tfc, Tfm, Tff, Tfn, TeC, Tfh, TeK, Tf2, TeV, Tf8, TeY, Tfi, TeR;
+ E Tf3;
+ {
+ E Tet, Teu, Tfa, Tfb;
+ Tet = TcD - TcG;
+ Teu = TdY - TdX;
+ Tev = Tet - Teu;
+ Tf7 = Tet + Teu;
+ Tfa = TeF + TeE;
+ Tfb = TeH + TeI;
+ Tfc = FMA(KP290284677, Tfa, KP956940335 * Tfb);
+ Tfm = FNMS(KP290284677, Tfb, KP956940335 * Tfa);
+ }
+ {
+ E Tfd, Tfe, Tey, TeB;
+ Tfd = TeL + TeM;
+ Tfe = TeP + TeO;
+ Tff = FNMS(KP290284677, Tfe, KP956940335 * Tfd);
+ Tfn = FMA(KP956940335, Tfe, KP290284677 * Tfd);
+ Tey = FMA(KP555570233, Tew, KP831469612 * Tex);
+ TeB = FNMS(KP555570233, TeA, KP831469612 * Tez);
+ TeC = Tey - TeB;
+ Tfh = TeB + Tey;
+ }
+ {
+ E TeG, TeJ, TeT, TeU;
+ TeG = TeE - TeF;
+ TeJ = TeH - TeI;
+ TeK = FMA(KP471396736, TeG, KP881921264 * TeJ);
+ Tf2 = FNMS(KP471396736, TeJ, KP881921264 * TeG);
+ TeT = FNMS(KP555570233, Tex, KP831469612 * Tew);
+ TeU = FMA(KP831469612, TeA, KP555570233 * Tez);
+ TeV = TeT - TeU;
+ Tf8 = TeU + TeT;
+ }
+ {
+ E TeW, TeX, TeN, TeQ;
+ TeW = TcN - TcK;
+ TeX = TdV - TdU;
+ TeY = TeW - TeX;
+ Tfi = TeX + TeW;
+ TeN = TeL - TeM;
+ TeQ = TeO - TeP;
+ TeR = FNMS(KP471396736, TeQ, KP881921264 * TeN);
+ Tf3 = FMA(KP881921264, TeQ, KP471396736 * TeN);
+ }
+ {
+ E TeD, TeS, Tf1, Tf4;
+ TeD = Tev + TeC;
+ TeS = TeK + TeR;
+ ro[WS(ros, 54)] = TeD - TeS;
+ ro[WS(ros, 10)] = TeD + TeS;
+ Tf1 = TeY + TeV;
+ Tf4 = Tf2 + Tf3;
+ io[WS(ios, 10)] = Tf1 + Tf4;
+ io[WS(ios, 54)] = Tf4 - Tf1;
+ }
+ {
+ E TeZ, Tf0, Tf5, Tf6;
+ TeZ = TeV - TeY;
+ Tf0 = TeR - TeK;
+ io[WS(ios, 22)] = TeZ + Tf0;
+ io[WS(ios, 42)] = Tf0 - TeZ;
+ Tf5 = Tev - TeC;
+ Tf6 = Tf3 - Tf2;
+ ro[WS(ros, 42)] = Tf5 - Tf6;
+ ro[WS(ros, 22)] = Tf5 + Tf6;
+ }
+ {
+ E Tf9, Tfg, Tfl, Tfo;
+ Tf9 = Tf7 + Tf8;
+ Tfg = Tfc + Tff;
+ ro[WS(ros, 58)] = Tf9 - Tfg;
+ ro[WS(ros, 6)] = Tf9 + Tfg;
+ Tfl = Tfi + Tfh;
+ Tfo = Tfm + Tfn;
+ io[WS(ios, 6)] = Tfl + Tfo;
+ io[WS(ios, 58)] = Tfo - Tfl;
+ }
+ {
+ E Tfj, Tfk, Tfp, Tfq;
+ Tfj = Tfh - Tfi;
+ Tfk = Tff - Tfc;
+ io[WS(ios, 26)] = Tfj + Tfk;
+ io[WS(ios, 38)] = Tfk - Tfj;
+ Tfp = Tf7 - Tf8;
+ Tfq = Tfn - Tfm;
+ ro[WS(ros, 38)] = Tfp - Tfq;
+ ro[WS(ros, 26)] = Tfp + Tfq;
+ }
+ }
+ {
+ E TcP, Te9, Tee, Teo, Teh, Tep, Td8, Tej, Tdu, Te4, TdT, Tea, Te0, Tek, TdP;
+ E Te5;
+ {
+ E TcH, TcO, Tec, Ted;
+ TcH = TcD + TcG;
+ TcO = TcK + TcN;
+ TcP = TcH + TcO;
+ Te9 = TcH - TcO;
+ Tec = Tde - Tdl;
+ Ted = Tds - Tdp;
+ Tee = FMA(KP773010453, Tec, KP634393284 * Ted);
+ Teo = FNMS(KP634393284, Tec, KP773010453 * Ted);
+ }
+ {
+ E Tef, Teg, TcY, Td7;
+ Tef = Tdz - TdG;
+ Teg = TdN - TdK;
+ Teh = FNMS(KP634393284, Teg, KP773010453 * Tef);
+ Tep = FMA(KP634393284, Tef, KP773010453 * Teg);
+ TcY = FMA(KP980785280, TcU, KP195090322 * TcX);
+ Td7 = FNMS(KP195090322, Td6, KP980785280 * Td3);
+ Td8 = TcY + Td7;
+ Tej = Td7 - TcY;
+ }
+ {
+ E Tdm, Tdt, TdR, TdS;
+ Tdm = Tde + Tdl;
+ Tdt = Tdp + Tds;
+ Tdu = FMA(KP995184726, Tdm, KP098017140 * Tdt);
+ Te4 = FNMS(KP098017140, Tdm, KP995184726 * Tdt);
+ TdR = FNMS(KP195090322, TcU, KP980785280 * TcX);
+ TdS = FMA(KP195090322, Td3, KP980785280 * Td6);
+ TdT = TdR + TdS;
+ Tea = TdS - TdR;
+ }
+ {
+ E TdW, TdZ, TdH, TdO;
+ TdW = TdU + TdV;
+ TdZ = TdX + TdY;
+ Te0 = TdW + TdZ;
+ Tek = TdZ - TdW;
+ TdH = Tdz + TdG;
+ TdO = TdK + TdN;
+ TdP = FNMS(KP098017140, TdO, KP995184726 * TdH);
+ Te5 = FMA(KP098017140, TdH, KP995184726 * TdO);
+ }
+ {
+ E Td9, TdQ, Te3, Te6;
+ Td9 = TcP + Td8;
+ TdQ = Tdu + TdP;
+ ro[WS(ros, 62)] = Td9 - TdQ;
+ ro[WS(ros, 2)] = Td9 + TdQ;
+ Te3 = Te0 + TdT;
+ Te6 = Te4 + Te5;
+ io[WS(ios, 2)] = Te3 + Te6;
+ io[WS(ios, 62)] = Te6 - Te3;
+ }
+ {
+ E Te1, Te2, Te7, Te8;
+ Te1 = TdT - Te0;
+ Te2 = TdP - Tdu;
+ io[WS(ios, 30)] = Te1 + Te2;
+ io[WS(ios, 34)] = Te2 - Te1;
+ Te7 = TcP - Td8;
+ Te8 = Te5 - Te4;
+ ro[WS(ros, 34)] = Te7 - Te8;
+ ro[WS(ros, 30)] = Te7 + Te8;
+ }
+ {
+ E Teb, Tei, Ten, Teq;
+ Teb = Te9 + Tea;
+ Tei = Tee + Teh;
+ ro[WS(ros, 50)] = Teb - Tei;
+ ro[WS(ros, 14)] = Teb + Tei;
+ Ten = Tek + Tej;
+ Teq = Teo + Tep;
+ io[WS(ios, 14)] = Ten + Teq;
+ io[WS(ios, 50)] = Teq - Ten;
+ }
+ {
+ E Tel, Tem, Ter, Tes;
+ Tel = Tej - Tek;
+ Tem = Teh - Tee;
+ io[WS(ios, 18)] = Tel + Tem;
+ io[WS(ios, 46)] = Tem - Tel;
+ Ter = Te9 - Tea;
+ Tes = Tep - Teo;
+ ro[WS(ros, 46)] = Ter - Tes;
+ ro[WS(ros, 18)] = Ter + Tes;
+ }
+ }
+ {
+ E T6v, T77, T6C, T7h, T6Y, T7i, T6V, T78, T6R, T7n, T73, T7f, T6K, T7m, T72;
+ E T7c;
+ {
+ E T6t, T6u, T6T, T6U;
+ T6t = T27 - T2e;
+ T6u = T5Y - T5X;
+ T6v = T6t - T6u;
+ T77 = T6t + T6u;
+ {
+ E T6y, T6B, T6W, T6X;
+ T6y = FMA(KP773010453, T6w, KP634393284 * T6x);
+ T6B = FNMS(KP634393284, T6A, KP773010453 * T6z);
+ T6C = T6y - T6B;
+ T7h = T6B + T6y;
+ T6W = T2x - T2o;
+ T6X = T5V - T5S;
+ T6Y = T6W - T6X;
+ T7i = T6X + T6W;
+ }
+ T6T = FNMS(KP634393284, T6w, KP773010453 * T6x);
+ T6U = FMA(KP634393284, T6z, KP773010453 * T6A);
+ T6V = T6T - T6U;
+ T78 = T6U + T6T;
+ {
+ E T6N, T7d, T6Q, T7e, T6M, T6O;
+ T6M = T5I - T5H;
+ T6N = T6L - T6M;
+ T7d = T6L + T6M;
+ T6O = T5v - T5e;
+ T6Q = T6O - T6P;
+ T7e = T6P + T6O;
+ T6R = FNMS(KP427555093, T6Q, KP903989293 * T6N);
+ T7n = FMA(KP941544065, T7e, KP336889853 * T7d);
+ T73 = FMA(KP903989293, T6Q, KP427555093 * T6N);
+ T7f = FNMS(KP336889853, T7e, KP941544065 * T7d);
+ }
+ {
+ E T6G, T7a, T6J, T7b, T6E, T6I;
+ T6E = T4g - T3Z;
+ T6G = T6E - T6F;
+ T7a = T6F + T6E;
+ T6I = T4t - T4s;
+ T6J = T6H - T6I;
+ T7b = T6H + T6I;
+ T6K = FMA(KP427555093, T6G, KP903989293 * T6J);
+ T7m = FNMS(KP336889853, T7b, KP941544065 * T7a);
+ T72 = FNMS(KP427555093, T6J, KP903989293 * T6G);
+ T7c = FMA(KP336889853, T7a, KP941544065 * T7b);
+ }
+ }
+ {
+ E T6D, T6S, T71, T74;
+ T6D = T6v + T6C;
+ T6S = T6K + T6R;
+ ro[WS(ros, 55)] = T6D - T6S;
+ ro[WS(ros, 9)] = T6D + T6S;
+ T71 = T6Y + T6V;
+ T74 = T72 + T73;
+ io[WS(ios, 9)] = T71 + T74;
+ io[WS(ios, 55)] = T74 - T71;
+ }
+ {
+ E T6Z, T70, T75, T76;
+ T6Z = T6V - T6Y;
+ T70 = T6R - T6K;
+ io[WS(ios, 23)] = T6Z + T70;
+ io[WS(ios, 41)] = T70 - T6Z;
+ T75 = T6v - T6C;
+ T76 = T73 - T72;
+ ro[WS(ros, 41)] = T75 - T76;
+ ro[WS(ros, 23)] = T75 + T76;
+ }
+ {
+ E T79, T7g, T7l, T7o;
+ T79 = T77 + T78;
+ T7g = T7c + T7f;
+ ro[WS(ros, 57)] = T79 - T7g;
+ ro[WS(ros, 7)] = T79 + T7g;
+ T7l = T7i + T7h;
+ T7o = T7m + T7n;
+ io[WS(ios, 7)] = T7l + T7o;
+ io[WS(ios, 57)] = T7o - T7l;
+ }
+ {
+ E T7j, T7k, T7p, T7q;
+ T7j = T7h - T7i;
+ T7k = T7f - T7c;
+ io[WS(ios, 25)] = T7j + T7k;
+ io[WS(ios, 39)] = T7k - T7j;
+ T7p = T77 - T78;
+ T7q = T7n - T7m;
+ ro[WS(ros, 39)] = T7p - T7q;
+ ro[WS(ros, 25)] = T7p + T7q;
+ }
+ }
+ {
+ E T99, T9L, T9g, T9V, T9C, T9W, T9z, T9M, T9v, Ta1, T9H, T9T, T9o, Ta0, T9G;
+ E T9Q;
+ {
+ E T97, T98, T9x, T9y;
+ T97 = T7r - T7s;
+ T98 = T8C - T8B;
+ T99 = T97 - T98;
+ T9L = T97 + T98;
+ {
+ E T9c, T9f, T9A, T9B;
+ T9c = FMA(KP471396736, T9a, KP881921264 * T9b);
+ T9f = FNMS(KP471396736, T9e, KP881921264 * T9d);
+ T9g = T9c - T9f;
+ T9V = T9f + T9c;
+ T9A = T7z - T7w;
+ T9B = T8z - T8y;
+ T9C = T9A - T9B;
+ T9W = T9B + T9A;
+ }
+ T9x = FNMS(KP471396736, T9b, KP881921264 * T9a);
+ T9y = FMA(KP881921264, T9e, KP471396736 * T9d);
+ T9z = T9x - T9y;
+ T9M = T9y + T9x;
+ {
+ E T9r, T9R, T9u, T9S, T9q, T9s;
+ T9q = T8q - T8p;
+ T9r = T9p - T9q;
+ T9R = T9p + T9q;
+ T9s = T8j - T8g;
+ T9u = T9s - T9t;
+ T9S = T9t + T9s;
+ T9v = FNMS(KP514102744, T9u, KP857728610 * T9r);
+ Ta1 = FMA(KP970031253, T9S, KP242980179 * T9R);
+ T9H = FMA(KP857728610, T9u, KP514102744 * T9r);
+ T9T = FNMS(KP242980179, T9S, KP970031253 * T9R);
+ }
+ {
+ E T9k, T9O, T9n, T9P, T9i, T9m;
+ T9i = T80 - T7X;
+ T9k = T9i - T9j;
+ T9O = T9j + T9i;
+ T9m = T87 - T86;
+ T9n = T9l - T9m;
+ T9P = T9l + T9m;
+ T9o = FMA(KP514102744, T9k, KP857728610 * T9n);
+ Ta0 = FNMS(KP242980179, T9P, KP970031253 * T9O);
+ T9G = FNMS(KP514102744, T9n, KP857728610 * T9k);
+ T9Q = FMA(KP242980179, T9O, KP970031253 * T9P);
+ }
+ }
+ {
+ E T9h, T9w, T9F, T9I;
+ T9h = T99 + T9g;
+ T9w = T9o + T9v;
+ ro[WS(ros, 53)] = T9h - T9w;
+ ro[WS(ros, 11)] = T9h + T9w;
+ T9F = T9C + T9z;
+ T9I = T9G + T9H;
+ io[WS(ios, 11)] = T9F + T9I;
+ io[WS(ios, 53)] = T9I - T9F;
+ }
+ {
+ E T9D, T9E, T9J, T9K;
+ T9D = T9z - T9C;
+ T9E = T9v - T9o;
+ io[WS(ios, 21)] = T9D + T9E;
+ io[WS(ios, 43)] = T9E - T9D;
+ T9J = T99 - T9g;
+ T9K = T9H - T9G;
+ ro[WS(ros, 43)] = T9J - T9K;
+ ro[WS(ros, 21)] = T9J + T9K;
+ }
+ {
+ E T9N, T9U, T9Z, Ta2;
+ T9N = T9L + T9M;
+ T9U = T9Q + T9T;
+ ro[WS(ros, 59)] = T9N - T9U;
+ ro[WS(ros, 5)] = T9N + T9U;
+ T9Z = T9W + T9V;
+ Ta2 = Ta0 + Ta1;
+ io[WS(ios, 5)] = T9Z + Ta2;
+ io[WS(ios, 59)] = Ta2 - T9Z;
+ }
+ {
+ E T9X, T9Y, Ta3, Ta4;
+ T9X = T9V - T9W;
+ T9Y = T9T - T9Q;
+ io[WS(ios, 27)] = T9X + T9Y;
+ io[WS(ios, 37)] = T9Y - T9X;
+ Ta3 = T9L - T9M;
+ Ta4 = Ta1 - Ta0;
+ ro[WS(ros, 37)] = Ta3 - Ta4;
+ ro[WS(ros, 27)] = Ta3 + Ta4;
+ }
+ }
+ {
+ E T2z, T69, T3g, T6j, T60, T6k, T5P, T6a, T5L, T6p, T65, T6h, T4w, T6o, T64;
+ E T6e;
+ {
+ E T2f, T2y, T5N, T5O;
+ T2f = T27 + T2e;
+ T2y = T2o + T2x;
+ T2z = T2f + T2y;
+ T69 = T2f - T2y;
+ {
+ E T2U, T3f, T5W, T5Z;
+ T2U = FMA(KP098017140, T2M, KP995184726 * T2T);
+ T3f = FNMS(KP098017140, T3e, KP995184726 * T37);
+ T3g = T2U + T3f;
+ T6j = T3f - T2U;
+ T5W = T5S + T5V;
+ T5Z = T5X + T5Y;
+ T60 = T5W + T5Z;
+ T6k = T5Z - T5W;
+ }
+ T5N = FNMS(KP098017140, T2T, KP995184726 * T2M);
+ T5O = FMA(KP995184726, T3e, KP098017140 * T37);
+ T5P = T5N + T5O;
+ T6a = T5O - T5N;
+ {
+ E T5x, T6f, T5K, T6g, T5w, T5J;
+ T5w = T5e + T5v;
+ T5x = T4X + T5w;
+ T6f = T4X - T5w;
+ T5J = T5H + T5I;
+ T5K = T5G + T5J;
+ T6g = T5J - T5G;
+ T5L = FNMS(KP049067674, T5K, KP998795456 * T5x);
+ T6p = FMA(KP671558954, T6f, KP740951125 * T6g);
+ T65 = FMA(KP049067674, T5x, KP998795456 * T5K);
+ T6h = FNMS(KP671558954, T6g, KP740951125 * T6f);
+ }
+ {
+ E T4i, T6c, T4v, T6d, T4h, T4u;
+ T4h = T3Z + T4g;
+ T4i = T3I + T4h;
+ T6c = T3I - T4h;
+ T4u = T4s + T4t;
+ T4v = T4r + T4u;
+ T6d = T4u - T4r;
+ T4w = FMA(KP998795456, T4i, KP049067674 * T4v);
+ T6o = FNMS(KP671558954, T6c, KP740951125 * T6d);
+ T64 = FNMS(KP049067674, T4i, KP998795456 * T4v);
+ T6e = FMA(KP740951125, T6c, KP671558954 * T6d);
+ }
+ }
+ {
+ E T3h, T5M, T63, T66;
+ T3h = T2z + T3g;
+ T5M = T4w + T5L;
+ ro[WS(ros, 63)] = T3h - T5M;
+ ro[WS(ros, 1)] = T3h + T5M;
+ T63 = T60 + T5P;
+ T66 = T64 + T65;
+ io[WS(ios, 1)] = T63 + T66;
+ io[WS(ios, 63)] = T66 - T63;
+ }
+ {
+ E T61, T62, T67, T68;
+ T61 = T5P - T60;
+ T62 = T5L - T4w;
+ io[WS(ios, 31)] = T61 + T62;
+ io[WS(ios, 33)] = T62 - T61;
+ T67 = T2z - T3g;
+ T68 = T65 - T64;
+ ro[WS(ros, 33)] = T67 - T68;
+ ro[WS(ros, 31)] = T67 + T68;
+ }
+ {
+ E T6b, T6i, T6n, T6q;
+ T6b = T69 + T6a;
+ T6i = T6e + T6h;
+ ro[WS(ros, 49)] = T6b - T6i;
+ ro[WS(ros, 15)] = T6b + T6i;
+ T6n = T6k + T6j;
+ T6q = T6o + T6p;
+ io[WS(ios, 15)] = T6n + T6q;
+ io[WS(ios, 49)] = T6q - T6n;
+ }
+ {
+ E T6l, T6m, T6r, T6s;
+ T6l = T6j - T6k;
+ T6m = T6h - T6e;
+ io[WS(ios, 17)] = T6l + T6m;
+ io[WS(ios, 47)] = T6m - T6l;
+ T6r = T69 - T6a;
+ T6s = T6p - T6o;
+ ro[WS(ros, 47)] = T6r - T6s;
+ ro[WS(ros, 17)] = T6r + T6s;
+ }
+ }
+ {
+ E T7B, T8N, T7Q, T8X, T8E, T8Y, T8x, T8O, T8t, T93, T8J, T8V, T8a, T92, T8I;
+ E T8S;
+ {
+ E T7t, T7A, T8v, T8w;
+ T7t = T7r + T7s;
+ T7A = T7w + T7z;
+ T7B = T7t + T7A;
+ T8N = T7t - T7A;
+ {
+ E T7I, T7P, T8A, T8D;
+ T7I = FMA(KP956940335, T7E, KP290284677 * T7H);
+ T7P = FNMS(KP290284677, T7O, KP956940335 * T7L);
+ T7Q = T7I + T7P;
+ T8X = T7P - T7I;
+ T8A = T8y + T8z;
+ T8D = T8B + T8C;
+ T8E = T8A + T8D;
+ T8Y = T8D - T8A;
+ }
+ T8v = FNMS(KP290284677, T7E, KP956940335 * T7H);
+ T8w = FMA(KP290284677, T7L, KP956940335 * T7O);
+ T8x = T8v + T8w;
+ T8O = T8w - T8v;
+ {
+ E T8l, T8T, T8s, T8U, T8k, T8r;
+ T8k = T8g + T8j;
+ T8l = T8d + T8k;
+ T8T = T8d - T8k;
+ T8r = T8p + T8q;
+ T8s = T8o + T8r;
+ T8U = T8r - T8o;
+ T8t = FNMS(KP146730474, T8s, KP989176509 * T8l);
+ T93 = FMA(KP595699304, T8T, KP803207531 * T8U);
+ T8J = FMA(KP146730474, T8l, KP989176509 * T8s);
+ T8V = FNMS(KP595699304, T8U, KP803207531 * T8T);
+ }
+ {
+ E T82, T8Q, T89, T8R, T81, T88;
+ T81 = T7X + T80;
+ T82 = T7U + T81;
+ T8Q = T7U - T81;
+ T88 = T86 + T87;
+ T89 = T85 + T88;
+ T8R = T88 - T85;
+ T8a = FMA(KP989176509, T82, KP146730474 * T89);
+ T92 = FNMS(KP595699304, T8Q, KP803207531 * T8R);
+ T8I = FNMS(KP146730474, T82, KP989176509 * T89);
+ T8S = FMA(KP803207531, T8Q, KP595699304 * T8R);
+ }
+ }
+ {
+ E T7R, T8u, T8H, T8K;
+ T7R = T7B + T7Q;
+ T8u = T8a + T8t;
+ ro[WS(ros, 61)] = T7R - T8u;
+ ro[WS(ros, 3)] = T7R + T8u;
+ T8H = T8E + T8x;
+ T8K = T8I + T8J;
+ io[WS(ios, 3)] = T8H + T8K;
+ io[WS(ios, 61)] = T8K - T8H;
+ }
+ {
+ E T8F, T8G, T8L, T8M;
+ T8F = T8x - T8E;
+ T8G = T8t - T8a;
+ io[WS(ios, 29)] = T8F + T8G;
+ io[WS(ios, 35)] = T8G - T8F;
+ T8L = T7B - T7Q;
+ T8M = T8J - T8I;
+ ro[WS(ros, 35)] = T8L - T8M;
+ ro[WS(ros, 29)] = T8L + T8M;
+ }
+ {
+ E T8P, T8W, T91, T94;
+ T8P = T8N + T8O;
+ T8W = T8S + T8V;
+ ro[WS(ros, 51)] = T8P - T8W;
+ ro[WS(ros, 13)] = T8P + T8W;
+ T91 = T8Y + T8X;
+ T94 = T92 + T93;
+ io[WS(ios, 13)] = T91 + T94;
+ io[WS(ios, 51)] = T94 - T91;
+ }
+ {
+ E T8Z, T90, T95, T96;
+ T8Z = T8X - T8Y;
+ T90 = T8V - T8S;
+ io[WS(ios, 19)] = T8Z + T90;
+ io[WS(ios, 45)] = T90 - T8Z;
+ T95 = T8N - T8O;
+ T96 = T93 - T92;
+ ro[WS(ros, 45)] = T95 - T96;
+ ro[WS(ros, 19)] = T95 + T96;
+ }
+ }
+ }
+}
+
+static void mr2hc_128(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; --i) {
+ mr2hc_128_0(I, ro, io, is, ros, ios);
+ I += ivs;
+ ro += ovs;
+ io += ovs;
+ }
+}
+
+static const kr2hc_desc desc = { 128, "mr2hc_128", {812, 186, 144, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_mr2hc_128) (planner *p) {
+ X(kr2hc_register) (p, mr2hc_128, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c
new file mode 100644
index 0000000..4f351a4
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_32.c
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:45 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 32 -name mr2hc_32 -include r2hc.h */
+
+/*
+ * This function contains 156 FP additions, 42 FP multiplications,
+ * (or, 140 additions, 26 multiplications, 16 fused multiply/add),
+ * 53 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void mr2hc_32_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios)
+{
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ {
+ E T7, T2b, Tv, T1l, Te, T2o, Ty, T1k, Tt, T2d, TF, T1h, Tm, T2c, TC;
+ E T1i, T1Z, T22, T2k, T2j, T1e, T1C, T19, T1B, T1S, T1V, T2h, T2g, TX, T1z;
+ E TS, T1y;
+ {
+ E T1, T2, T3, T4, T5, T6;
+ T1 = I[0];
+ T2 = I[WS(is, 16)];
+ T3 = T1 + T2;
+ T4 = I[WS(is, 8)];
+ T5 = I[WS(is, 24)];
+ T6 = T4 + T5;
+ T7 = T3 + T6;
+ T2b = T3 - T6;
+ Tv = T1 - T2;
+ T1l = T4 - T5;
+ }
+ {
+ E Ta, Tw, Td, Tx;
+ {
+ E T8, T9, Tb, Tc;
+ T8 = I[WS(is, 4)];
+ T9 = I[WS(is, 20)];
+ Ta = T8 + T9;
+ Tw = T8 - T9;
+ Tb = I[WS(is, 28)];
+ Tc = I[WS(is, 12)];
+ Td = Tb + Tc;
+ Tx = Tb - Tc;
+ }
+ Te = Ta + Td;
+ T2o = Td - Ta;
+ Ty = KP707106781 * (Tw + Tx);
+ T1k = KP707106781 * (Tx - Tw);
+ }
+ {
+ E Tp, TD, Ts, TE;
+ {
+ E Tn, To, Tq, Tr;
+ Tn = I[WS(is, 30)];
+ To = I[WS(is, 14)];
+ Tp = Tn + To;
+ TD = Tn - To;
+ Tq = I[WS(is, 6)];
+ Tr = I[WS(is, 22)];
+ Ts = Tq + Tr;
+ TE = Tq - Tr;
+ }
+ Tt = Tp + Ts;
+ T2d = Tp - Ts;
+ TF = FMA(KP923879532, TD, KP382683432 * TE);
+ T1h = FNMS(KP923879532, TE, KP382683432 * TD);
+ }
+ {
+ E Ti, TA, Tl, TB;
+ {
+ E Tg, Th, Tj, Tk;
+ Tg = I[WS(is, 2)];
+ Th = I[WS(is, 18)];
+ Ti = Tg + Th;
+ TA = Tg - Th;
+ Tj = I[WS(is, 10)];
+ Tk = I[WS(is, 26)];
+ Tl = Tj + Tk;
+ TB = Tj - Tk;
+ }
+ Tm = Ti + Tl;
+ T2c = Ti - Tl;
+ TC = FNMS(KP382683432, TB, KP923879532 * TA);
+ T1i = FMA(KP382683432, TA, KP923879532 * TB);
+ }
+ {
+ E T11, T1X, T1d, T1Y, T14, T20, T17, T21, T1a, T18;
+ {
+ E TZ, T10, T1b, T1c;
+ TZ = I[WS(is, 31)];
+ T10 = I[WS(is, 15)];
+ T11 = TZ - T10;
+ T1X = TZ + T10;
+ T1b = I[WS(is, 7)];
+ T1c = I[WS(is, 23)];
+ T1d = T1b - T1c;
+ T1Y = T1b + T1c;
+ }
+ {
+ E T12, T13, T15, T16;
+ T12 = I[WS(is, 3)];
+ T13 = I[WS(is, 19)];
+ T14 = T12 - T13;
+ T20 = T12 + T13;
+ T15 = I[WS(is, 27)];
+ T16 = I[WS(is, 11)];
+ T17 = T15 - T16;
+ T21 = T15 + T16;
+ }
+ T1Z = T1X + T1Y;
+ T22 = T20 + T21;
+ T2k = T21 - T20;
+ T2j = T1X - T1Y;
+ T1a = KP707106781 * (T17 - T14);
+ T1e = T1a - T1d;
+ T1C = T1d + T1a;
+ T18 = KP707106781 * (T14 + T17);
+ T19 = T11 + T18;
+ T1B = T11 - T18;
+ }
+ {
+ E TK, T1Q, TW, T1R, TN, T1T, TQ, T1U, TT, TR;
+ {
+ E TI, TJ, TU, TV;
+ TI = I[WS(is, 1)];
+ TJ = I[WS(is, 17)];
+ TK = TI - TJ;
+ T1Q = TI + TJ;
+ TU = I[WS(is, 9)];
+ TV = I[WS(is, 25)];
+ TW = TU - TV;
+ T1R = TU + TV;
+ }
+ {
+ E TL, TM, TO, TP;
+ TL = I[WS(is, 5)];
+ TM = I[WS(is, 21)];
+ TN = TL - TM;
+ T1T = TL + TM;
+ TO = I[WS(is, 29)];
+ TP = I[WS(is, 13)];
+ TQ = TO - TP;
+ T1U = TO + TP;
+ }
+ T1S = T1Q + T1R;
+ T1V = T1T + T1U;
+ T2h = T1U - T1T;
+ T2g = T1Q - T1R;
+ TT = KP707106781 * (TQ - TN);
+ TX = TT - TW;
+ T1z = TW + TT;
+ TR = KP707106781 * (TN + TQ);
+ TS = TK + TR;
+ T1y = TK - TR;
+ }
+ {
+ E Tf, Tu, T27, T28, T29, T2a;
+ Tf = T7 + Te;
+ Tu = Tm + Tt;
+ T27 = Tf + Tu;
+ T28 = T1S + T1V;
+ T29 = T1Z + T22;
+ T2a = T28 + T29;
+ ro[WS(ros, 8)] = Tf - Tu;
+ io[WS(ios, 8)] = T29 - T28;
+ ro[WS(ros, 16)] = T27 - T2a;
+ ro[0] = T27 + T2a;
+ }
+ {
+ E T1P, T25, T24, T26, T1W, T23;
+ T1P = T7 - Te;
+ T25 = Tt - Tm;
+ T1W = T1S - T1V;
+ T23 = T1Z - T22;
+ T24 = KP707106781 * (T1W + T23);
+ T26 = KP707106781 * (T23 - T1W);
+ ro[WS(ros, 12)] = T1P - T24;
+ io[WS(ios, 12)] = T26 - T25;
+ ro[WS(ros, 4)] = T1P + T24;
+ io[WS(ios, 4)] = T25 + T26;
+ }
+ {
+ E T2f, T2v, T2p, T2r, T2m, T2q, T2u, T2w, T2e, T2n;
+ T2e = KP707106781 * (T2c + T2d);
+ T2f = T2b + T2e;
+ T2v = T2b - T2e;
+ T2n = KP707106781 * (T2d - T2c);
+ T2p = T2n - T2o;
+ T2r = T2o + T2n;
+ {
+ E T2i, T2l, T2s, T2t;
+ T2i = FMA(KP923879532, T2g, KP382683432 * T2h);
+ T2l = FNMS(KP382683432, T2k, KP923879532 * T2j);
+ T2m = T2i + T2l;
+ T2q = T2l - T2i;
+ T2s = FNMS(KP382683432, T2g, KP923879532 * T2h);
+ T2t = FMA(KP382683432, T2j, KP923879532 * T2k);
+ T2u = T2s + T2t;
+ T2w = T2t - T2s;
+ }
+ ro[WS(ros, 14)] = T2f - T2m;
+ io[WS(ios, 14)] = T2u - T2r;
+ ro[WS(ros, 2)] = T2f + T2m;
+ io[WS(ios, 2)] = T2r + T2u;
+ io[WS(ios, 6)] = T2p + T2q;
+ ro[WS(ros, 6)] = T2v + T2w;
+ io[WS(ios, 10)] = T2q - T2p;
+ ro[WS(ros, 10)] = T2v - T2w;
+ }
+ {
+ E TH, T1t, T1s, T1u, T1g, T1o, T1n, T1p;
+ {
+ E Tz, TG, T1q, T1r;
+ Tz = Tv + Ty;
+ TG = TC + TF;
+ TH = Tz + TG;
+ T1t = Tz - TG;
+ T1q = FNMS(KP195090322, TS, KP980785280 * TX);
+ T1r = FMA(KP195090322, T19, KP980785280 * T1e);
+ T1s = T1q + T1r;
+ T1u = T1r - T1q;
+ }
+ {
+ E TY, T1f, T1j, T1m;
+ TY = FMA(KP980785280, TS, KP195090322 * TX);
+ T1f = FNMS(KP195090322, T1e, KP980785280 * T19);
+ T1g = TY + T1f;
+ T1o = T1f - TY;
+ T1j = T1h - T1i;
+ T1m = T1k - T1l;
+ T1n = T1j - T1m;
+ T1p = T1m + T1j;
+ }
+ ro[WS(ros, 15)] = TH - T1g;
+ io[WS(ios, 15)] = T1s - T1p;
+ ro[WS(ros, 1)] = TH + T1g;
+ io[WS(ios, 1)] = T1p + T1s;
+ io[WS(ios, 7)] = T1n + T1o;
+ ro[WS(ros, 7)] = T1t + T1u;
+ io[WS(ios, 9)] = T1o - T1n;
+ ro[WS(ros, 9)] = T1t - T1u;
+ }
+ {
+ E T1x, T1N, T1M, T1O, T1E, T1I, T1H, T1J;
+ {
+ E T1v, T1w, T1K, T1L;
+ T1v = Tv - Ty;
+ T1w = T1i + T1h;
+ T1x = T1v + T1w;
+ T1N = T1v - T1w;
+ T1K = FNMS(KP555570233, T1y, KP831469612 * T1z);
+ T1L = FMA(KP555570233, T1B, KP831469612 * T1C);
+ T1M = T1K + T1L;
+ T1O = T1L - T1K;
+ }
+ {
+ E T1A, T1D, T1F, T1G;
+ T1A = FMA(KP831469612, T1y, KP555570233 * T1z);
+ T1D = FNMS(KP555570233, T1C, KP831469612 * T1B);
+ T1E = T1A + T1D;
+ T1I = T1D - T1A;
+ T1F = TF - TC;
+ T1G = T1l + T1k;
+ T1H = T1F - T1G;
+ T1J = T1G + T1F;
+ }
+ ro[WS(ros, 13)] = T1x - T1E;
+ io[WS(ios, 13)] = T1M - T1J;
+ ro[WS(ros, 3)] = T1x + T1E;
+ io[WS(ios, 3)] = T1J + T1M;
+ io[WS(ios, 5)] = T1H + T1I;
+ ro[WS(ros, 5)] = T1N + T1O;
+ io[WS(ios, 11)] = T1I - T1H;
+ ro[WS(ros, 11)] = T1N - T1O;
+ }
+ }
+}
+
+static void mr2hc_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; --i) {
+ mr2hc_32_0(I, ro, io, is, ros, ios);
+ I += ivs;
+ ro += ovs;
+ io += ovs;
+ }
+}
+
+static const kr2hc_desc desc = { 32, "mr2hc_32", {140, 26, 16, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_mr2hc_32) (planner *p) {
+ X(kr2hc_register) (p, mr2hc_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c b/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c
new file mode 100644
index 0000000..c859fbf
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/mr2hc_64.c
@@ -0,0 +1,729 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:49 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc_noinline -compact -variables 4 -n 64 -name mr2hc_64 -include r2hc.h */
+
+/*
+ * This function contains 394 FP additions, 124 FP multiplications,
+ * (or, 342 additions, 72 multiplications, 52 fused multiply/add),
+ * 105 stack variables, and 128 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: mr2hc_64.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void mr2hc_64_0(const R *I, R *ro, R *io, stride is, stride ros, stride ios)
+{
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ {
+ E T4l, T5a, T15, T3n, T2T, T3Q, T7, Te, Tf, T4A, T4L, T1X, T3B, T23, T3y;
+ E T5I, T66, T4R, T52, T2j, T3F, T2H, T3I, T5P, T69, T1i, T3t, T1l, T3u, TZ;
+ E T63, T4v, T58, T1r, T3r, T1u, T3q, TK, T62, T4s, T57, Tm, Tt, Tu, T4o;
+ E T5b, T1c, T3R, T2Q, T3o, T1M, T3z, T5L, T67, T26, T3C, T4H, T4M, T2y, T3J;
+ E T5S, T6a, T2C, T3G, T4Y, T53;
+ {
+ E T3, T11, Td, T13, T6, T2S, Ta, T12, T14, T2R;
+ {
+ E T1, T2, Tb, Tc;
+ T1 = I[0];
+ T2 = I[WS(is, 32)];
+ T3 = T1 + T2;
+ T11 = T1 - T2;
+ Tb = I[WS(is, 56)];
+ Tc = I[WS(is, 24)];
+ Td = Tb + Tc;
+ T13 = Tb - Tc;
+ }
+ {
+ E T4, T5, T8, T9;
+ T4 = I[WS(is, 16)];
+ T5 = I[WS(is, 48)];
+ T6 = T4 + T5;
+ T2S = T4 - T5;
+ T8 = I[WS(is, 8)];
+ T9 = I[WS(is, 40)];
+ Ta = T8 + T9;
+ T12 = T8 - T9;
+ }
+ T4l = T3 - T6;
+ T5a = Td - Ta;
+ T14 = KP707106781 * (T12 + T13);
+ T15 = T11 + T14;
+ T3n = T11 - T14;
+ T2R = KP707106781 * (T13 - T12);
+ T2T = T2R - T2S;
+ T3Q = T2S + T2R;
+ T7 = T3 + T6;
+ Te = Ta + Td;
+ Tf = T7 + Te;
+ }
+ {
+ E T1P, T4J, T21, T4y, T1S, T4K, T1W, T4z;
+ {
+ E T1N, T1O, T1Z, T20;
+ T1N = I[WS(is, 57)];
+ T1O = I[WS(is, 25)];
+ T1P = T1N - T1O;
+ T4J = T1N + T1O;
+ T1Z = I[WS(is, 1)];
+ T20 = I[WS(is, 33)];
+ T21 = T1Z - T20;
+ T4y = T1Z + T20;
+ }
+ {
+ E T1Q, T1R, T1U, T1V;
+ T1Q = I[WS(is, 9)];
+ T1R = I[WS(is, 41)];
+ T1S = T1Q - T1R;
+ T4K = T1Q + T1R;
+ T1U = I[WS(is, 17)];
+ T1V = I[WS(is, 49)];
+ T1W = T1U - T1V;
+ T4z = T1U + T1V;
+ }
+ T4A = T4y - T4z;
+ T4L = T4J - T4K;
+ {
+ E T1T, T22, T5G, T5H;
+ T1T = KP707106781 * (T1P - T1S);
+ T1X = T1T - T1W;
+ T3B = T1W + T1T;
+ T22 = KP707106781 * (T1S + T1P);
+ T23 = T21 + T22;
+ T3y = T21 - T22;
+ T5G = T4y + T4z;
+ T5H = T4K + T4J;
+ T5I = T5G + T5H;
+ T66 = T5G - T5H;
+ }
+ }
+ {
+ E T2b, T4P, T2G, T4Q, T2e, T51, T2h, T50;
+ {
+ E T29, T2a, T2E, T2F;
+ T29 = I[WS(is, 63)];
+ T2a = I[WS(is, 31)];
+ T2b = T29 - T2a;
+ T4P = T29 + T2a;
+ T2E = I[WS(is, 15)];
+ T2F = I[WS(is, 47)];
+ T2G = T2E - T2F;
+ T4Q = T2E + T2F;
+ }
+ {
+ E T2c, T2d, T2f, T2g;
+ T2c = I[WS(is, 7)];
+ T2d = I[WS(is, 39)];
+ T2e = T2c - T2d;
+ T51 = T2c + T2d;
+ T2f = I[WS(is, 55)];
+ T2g = I[WS(is, 23)];
+ T2h = T2f - T2g;
+ T50 = T2f + T2g;
+ }
+ T4R = T4P - T4Q;
+ T52 = T50 - T51;
+ {
+ E T2i, T2D, T5N, T5O;
+ T2i = KP707106781 * (T2e + T2h);
+ T2j = T2b + T2i;
+ T3F = T2b - T2i;
+ T2D = KP707106781 * (T2h - T2e);
+ T2H = T2D - T2G;
+ T3I = T2G + T2D;
+ T5N = T4P + T4Q;
+ T5O = T51 + T50;
+ T5P = T5N + T5O;
+ T69 = T5N - T5O;
+ }
+ }
+ {
+ E TN, T1e, TX, T1g, TQ, T1k, TU, T1f, T1h, T1j;
+ {
+ E TL, TM, TV, TW;
+ TL = I[WS(is, 62)];
+ TM = I[WS(is, 30)];
+ TN = TL + TM;
+ T1e = TL - TM;
+ TV = I[WS(is, 54)];
+ TW = I[WS(is, 22)];
+ TX = TV + TW;
+ T1g = TV - TW;
+ }
+ {
+ E TO, TP, TS, TT;
+ TO = I[WS(is, 14)];
+ TP = I[WS(is, 46)];
+ TQ = TO + TP;
+ T1k = TO - TP;
+ TS = I[WS(is, 6)];
+ TT = I[WS(is, 38)];
+ TU = TS + TT;
+ T1f = TS - TT;
+ }
+ T1h = KP707106781 * (T1f + T1g);
+ T1i = T1e + T1h;
+ T3t = T1e - T1h;
+ T1j = KP707106781 * (T1g - T1f);
+ T1l = T1j - T1k;
+ T3u = T1k + T1j;
+ {
+ E TR, TY, T4t, T4u;
+ TR = TN + TQ;
+ TY = TU + TX;
+ TZ = TR + TY;
+ T63 = TR - TY;
+ T4t = TN - TQ;
+ T4u = TX - TU;
+ T4v = FNMS(KP382683432, T4u, KP923879532 * T4t);
+ T58 = FMA(KP382683432, T4t, KP923879532 * T4u);
+ }
+ }
+ {
+ E Ty, T1s, TI, T1n, TB, T1q, TF, T1o, T1p, T1t;
+ {
+ E Tw, Tx, TG, TH;
+ Tw = I[WS(is, 2)];
+ Tx = I[WS(is, 34)];
+ Ty = Tw + Tx;
+ T1s = Tw - Tx;
+ TG = I[WS(is, 58)];
+ TH = I[WS(is, 26)];
+ TI = TG + TH;
+ T1n = TG - TH;
+ }
+ {
+ E Tz, TA, TD, TE;
+ Tz = I[WS(is, 18)];
+ TA = I[WS(is, 50)];
+ TB = Tz + TA;
+ T1q = Tz - TA;
+ TD = I[WS(is, 10)];
+ TE = I[WS(is, 42)];
+ TF = TD + TE;
+ T1o = TD - TE;
+ }
+ T1p = KP707106781 * (T1n - T1o);
+ T1r = T1p - T1q;
+ T3r = T1q + T1p;
+ T1t = KP707106781 * (T1o + T1n);
+ T1u = T1s + T1t;
+ T3q = T1s - T1t;
+ {
+ E TC, TJ, T4q, T4r;
+ TC = Ty + TB;
+ TJ = TF + TI;
+ TK = TC + TJ;
+ T62 = TC - TJ;
+ T4q = Ty - TB;
+ T4r = TI - TF;
+ T4s = FMA(KP923879532, T4q, KP382683432 * T4r);
+ T57 = FNMS(KP382683432, T4q, KP923879532 * T4r);
+ }
+ }
+ {
+ E Ti, T16, Ts, T1a, Tl, T17, Tp, T19, T4m, T4n;
+ {
+ E Tg, Th, Tq, Tr;
+ Tg = I[WS(is, 4)];
+ Th = I[WS(is, 36)];
+ Ti = Tg + Th;
+ T16 = Tg - Th;
+ Tq = I[WS(is, 12)];
+ Tr = I[WS(is, 44)];
+ Ts = Tq + Tr;
+ T1a = Tq - Tr;
+ }
+ {
+ E Tj, Tk, Tn, To;
+ Tj = I[WS(is, 20)];
+ Tk = I[WS(is, 52)];
+ Tl = Tj + Tk;
+ T17 = Tj - Tk;
+ Tn = I[WS(is, 60)];
+ To = I[WS(is, 28)];
+ Tp = Tn + To;
+ T19 = Tn - To;
+ }
+ Tm = Ti + Tl;
+ Tt = Tp + Ts;
+ Tu = Tm + Tt;
+ T4m = Ti - Tl;
+ T4n = Tp - Ts;
+ T4o = KP707106781 * (T4m + T4n);
+ T5b = KP707106781 * (T4n - T4m);
+ {
+ E T18, T1b, T2O, T2P;
+ T18 = FNMS(KP382683432, T17, KP923879532 * T16);
+ T1b = FMA(KP923879532, T19, KP382683432 * T1a);
+ T1c = T18 + T1b;
+ T3R = T1b - T18;
+ T2O = FNMS(KP923879532, T1a, KP382683432 * T19);
+ T2P = FMA(KP382683432, T16, KP923879532 * T17);
+ T2Q = T2O - T2P;
+ T3o = T2P + T2O;
+ }
+ }
+ {
+ E T1A, T4E, T1K, T4C, T1D, T4F, T1H, T4B;
+ {
+ E T1y, T1z, T1I, T1J;
+ T1y = I[WS(is, 61)];
+ T1z = I[WS(is, 29)];
+ T1A = T1y - T1z;
+ T4E = T1y + T1z;
+ T1I = I[WS(is, 21)];
+ T1J = I[WS(is, 53)];
+ T1K = T1I - T1J;
+ T4C = T1I + T1J;
+ }
+ {
+ E T1B, T1C, T1F, T1G;
+ T1B = I[WS(is, 13)];
+ T1C = I[WS(is, 45)];
+ T1D = T1B - T1C;
+ T4F = T1B + T1C;
+ T1F = I[WS(is, 5)];
+ T1G = I[WS(is, 37)];
+ T1H = T1F - T1G;
+ T4B = T1F + T1G;
+ }
+ {
+ E T1E, T1L, T5J, T5K;
+ T1E = FNMS(KP923879532, T1D, KP382683432 * T1A);
+ T1L = FMA(KP382683432, T1H, KP923879532 * T1K);
+ T1M = T1E - T1L;
+ T3z = T1L + T1E;
+ T5J = T4B + T4C;
+ T5K = T4E + T4F;
+ T5L = T5J + T5K;
+ T67 = T5K - T5J;
+ }
+ {
+ E T24, T25, T4D, T4G;
+ T24 = FNMS(KP382683432, T1K, KP923879532 * T1H);
+ T25 = FMA(KP923879532, T1A, KP382683432 * T1D);
+ T26 = T24 + T25;
+ T3C = T25 - T24;
+ T4D = T4B - T4C;
+ T4G = T4E - T4F;
+ T4H = KP707106781 * (T4D + T4G);
+ T4M = KP707106781 * (T4G - T4D);
+ }
+ }
+ {
+ E T2m, T4S, T2w, T4W, T2p, T4T, T2t, T4V;
+ {
+ E T2k, T2l, T2u, T2v;
+ T2k = I[WS(is, 3)];
+ T2l = I[WS(is, 35)];
+ T2m = T2k - T2l;
+ T4S = T2k + T2l;
+ T2u = I[WS(is, 11)];
+ T2v = I[WS(is, 43)];
+ T2w = T2u - T2v;
+ T4W = T2u + T2v;
+ }
+ {
+ E T2n, T2o, T2r, T2s;
+ T2n = I[WS(is, 19)];
+ T2o = I[WS(is, 51)];
+ T2p = T2n - T2o;
+ T4T = T2n + T2o;
+ T2r = I[WS(is, 59)];
+ T2s = I[WS(is, 27)];
+ T2t = T2r - T2s;
+ T4V = T2r + T2s;
+ }
+ {
+ E T2q, T2x, T5Q, T5R;
+ T2q = FNMS(KP382683432, T2p, KP923879532 * T2m);
+ T2x = FMA(KP923879532, T2t, KP382683432 * T2w);
+ T2y = T2q + T2x;
+ T3J = T2x - T2q;
+ T5Q = T4S + T4T;
+ T5R = T4V + T4W;
+ T5S = T5Q + T5R;
+ T6a = T5R - T5Q;
+ }
+ {
+ E T2A, T2B, T4U, T4X;
+ T2A = FNMS(KP923879532, T2w, KP382683432 * T2t);
+ T2B = FMA(KP382683432, T2m, KP923879532 * T2p);
+ T2C = T2A - T2B;
+ T3G = T2B + T2A;
+ T4U = T4S - T4T;
+ T4X = T4V - T4W;
+ T4Y = KP707106781 * (T4U + T4X);
+ T53 = KP707106781 * (T4X - T4U);
+ }
+ }
+ {
+ E Tv, T10, T5X, T5Y, T5Z, T60;
+ Tv = Tf + Tu;
+ T10 = TK + TZ;
+ T5X = Tv + T10;
+ T5Y = T5I + T5L;
+ T5Z = T5P + T5S;
+ T60 = T5Y + T5Z;
+ ro[WS(ros, 16)] = Tv - T10;
+ io[WS(ios, 16)] = T5Z - T5Y;
+ ro[WS(ros, 32)] = T5X - T60;
+ ro[0] = T5X + T60;
+ }
+ {
+ E T5F, T5V, T5U, T5W, T5M, T5T;
+ T5F = Tf - Tu;
+ T5V = TZ - TK;
+ T5M = T5I - T5L;
+ T5T = T5P - T5S;
+ T5U = KP707106781 * (T5M + T5T);
+ T5W = KP707106781 * (T5T - T5M);
+ ro[WS(ros, 24)] = T5F - T5U;
+ io[WS(ios, 24)] = T5W - T5V;
+ ro[WS(ros, 8)] = T5F + T5U;
+ io[WS(ios, 8)] = T5V + T5W;
+ }
+ {
+ E T65, T6l, T6k, T6m, T6c, T6g, T6f, T6h;
+ {
+ E T61, T64, T6i, T6j;
+ T61 = T7 - Te;
+ T64 = KP707106781 * (T62 + T63);
+ T65 = T61 + T64;
+ T6l = T61 - T64;
+ T6i = FNMS(KP382683432, T66, KP923879532 * T67);
+ T6j = FMA(KP382683432, T69, KP923879532 * T6a);
+ T6k = T6i + T6j;
+ T6m = T6j - T6i;
+ }
+ {
+ E T68, T6b, T6d, T6e;
+ T68 = FMA(KP923879532, T66, KP382683432 * T67);
+ T6b = FNMS(KP382683432, T6a, KP923879532 * T69);
+ T6c = T68 + T6b;
+ T6g = T6b - T68;
+ T6d = KP707106781 * (T63 - T62);
+ T6e = Tt - Tm;
+ T6f = T6d - T6e;
+ T6h = T6e + T6d;
+ }
+ ro[WS(ros, 28)] = T65 - T6c;
+ io[WS(ios, 28)] = T6k - T6h;
+ ro[WS(ros, 4)] = T65 + T6c;
+ io[WS(ios, 4)] = T6h + T6k;
+ io[WS(ios, 12)] = T6f + T6g;
+ ro[WS(ros, 12)] = T6l + T6m;
+ io[WS(ios, 20)] = T6g - T6f;
+ ro[WS(ros, 20)] = T6l - T6m;
+ }
+ {
+ E T5n, T5D, T5x, T5z, T5q, T5A, T5t, T5B;
+ {
+ E T5l, T5m, T5v, T5w;
+ T5l = T4l - T4o;
+ T5m = T58 - T57;
+ T5n = T5l + T5m;
+ T5D = T5l - T5m;
+ T5v = T4v - T4s;
+ T5w = T5b - T5a;
+ T5x = T5v - T5w;
+ T5z = T5w + T5v;
+ }
+ {
+ E T5o, T5p, T5r, T5s;
+ T5o = T4A - T4H;
+ T5p = T4M - T4L;
+ T5q = FMA(KP831469612, T5o, KP555570233 * T5p);
+ T5A = FNMS(KP555570233, T5o, KP831469612 * T5p);
+ T5r = T4R - T4Y;
+ T5s = T53 - T52;
+ T5t = FNMS(KP555570233, T5s, KP831469612 * T5r);
+ T5B = FMA(KP555570233, T5r, KP831469612 * T5s);
+ }
+ {
+ E T5u, T5C, T5y, T5E;
+ T5u = T5q + T5t;
+ ro[WS(ros, 26)] = T5n - T5u;
+ ro[WS(ros, 6)] = T5n + T5u;
+ T5C = T5A + T5B;
+ io[WS(ios, 6)] = T5z + T5C;
+ io[WS(ios, 26)] = T5C - T5z;
+ T5y = T5t - T5q;
+ io[WS(ios, 10)] = T5x + T5y;
+ io[WS(ios, 22)] = T5y - T5x;
+ T5E = T5B - T5A;
+ ro[WS(ros, 22)] = T5D - T5E;
+ ro[WS(ros, 10)] = T5D + T5E;
+ }
+ }
+ {
+ E T4x, T5j, T5d, T5f, T4O, T5g, T55, T5h;
+ {
+ E T4p, T4w, T59, T5c;
+ T4p = T4l + T4o;
+ T4w = T4s + T4v;
+ T4x = T4p + T4w;
+ T5j = T4p - T4w;
+ T59 = T57 + T58;
+ T5c = T5a + T5b;
+ T5d = T59 - T5c;
+ T5f = T5c + T59;
+ }
+ {
+ E T4I, T4N, T4Z, T54;
+ T4I = T4A + T4H;
+ T4N = T4L + T4M;
+ T4O = FMA(KP980785280, T4I, KP195090322 * T4N);
+ T5g = FNMS(KP195090322, T4I, KP980785280 * T4N);
+ T4Z = T4R + T4Y;
+ T54 = T52 + T53;
+ T55 = FNMS(KP195090322, T54, KP980785280 * T4Z);
+ T5h = FMA(KP195090322, T4Z, KP980785280 * T54);
+ }
+ {
+ E T56, T5i, T5e, T5k;
+ T56 = T4O + T55;
+ ro[WS(ros, 30)] = T4x - T56;
+ ro[WS(ros, 2)] = T4x + T56;
+ T5i = T5g + T5h;
+ io[WS(ios, 2)] = T5f + T5i;
+ io[WS(ios, 30)] = T5i - T5f;
+ T5e = T55 - T4O;
+ io[WS(ios, 14)] = T5d + T5e;
+ io[WS(ios, 18)] = T5e - T5d;
+ T5k = T5h - T5g;
+ ro[WS(ros, 18)] = T5j - T5k;
+ ro[WS(ros, 14)] = T5j + T5k;
+ }
+ }
+ {
+ E T3p, T41, T4c, T3S, T3w, T4b, T49, T4h, T3P, T42, T3E, T3W, T46, T4g, T3L;
+ E T3X;
+ {
+ E T3s, T3v, T3A, T3D;
+ T3p = T3n + T3o;
+ T41 = T3n - T3o;
+ T4c = T3R - T3Q;
+ T3S = T3Q + T3R;
+ T3s = FMA(KP831469612, T3q, KP555570233 * T3r);
+ T3v = FNMS(KP555570233, T3u, KP831469612 * T3t);
+ T3w = T3s + T3v;
+ T4b = T3v - T3s;
+ {
+ E T47, T48, T3N, T3O;
+ T47 = T3F - T3G;
+ T48 = T3J - T3I;
+ T49 = FNMS(KP471396736, T48, KP881921264 * T47);
+ T4h = FMA(KP471396736, T47, KP881921264 * T48);
+ T3N = FNMS(KP555570233, T3q, KP831469612 * T3r);
+ T3O = FMA(KP555570233, T3t, KP831469612 * T3u);
+ T3P = T3N + T3O;
+ T42 = T3O - T3N;
+ }
+ T3A = T3y + T3z;
+ T3D = T3B + T3C;
+ T3E = FMA(KP956940335, T3A, KP290284677 * T3D);
+ T3W = FNMS(KP290284677, T3A, KP956940335 * T3D);
+ {
+ E T44, T45, T3H, T3K;
+ T44 = T3y - T3z;
+ T45 = T3C - T3B;
+ T46 = FMA(KP881921264, T44, KP471396736 * T45);
+ T4g = FNMS(KP471396736, T44, KP881921264 * T45);
+ T3H = T3F + T3G;
+ T3K = T3I + T3J;
+ T3L = FNMS(KP290284677, T3K, KP956940335 * T3H);
+ T3X = FMA(KP290284677, T3H, KP956940335 * T3K);
+ }
+ }
+ {
+ E T3x, T3M, T3V, T3Y;
+ T3x = T3p + T3w;
+ T3M = T3E + T3L;
+ ro[WS(ros, 29)] = T3x - T3M;
+ ro[WS(ros, 3)] = T3x + T3M;
+ T3V = T3S + T3P;
+ T3Y = T3W + T3X;
+ io[WS(ios, 3)] = T3V + T3Y;
+ io[WS(ios, 29)] = T3Y - T3V;
+ }
+ {
+ E T3T, T3U, T3Z, T40;
+ T3T = T3P - T3S;
+ T3U = T3L - T3E;
+ io[WS(ios, 13)] = T3T + T3U;
+ io[WS(ios, 19)] = T3U - T3T;
+ T3Z = T3p - T3w;
+ T40 = T3X - T3W;
+ ro[WS(ros, 19)] = T3Z - T40;
+ ro[WS(ros, 13)] = T3Z + T40;
+ }
+ {
+ E T43, T4a, T4f, T4i;
+ T43 = T41 + T42;
+ T4a = T46 + T49;
+ ro[WS(ros, 27)] = T43 - T4a;
+ ro[WS(ros, 5)] = T43 + T4a;
+ T4f = T4c + T4b;
+ T4i = T4g + T4h;
+ io[WS(ios, 5)] = T4f + T4i;
+ io[WS(ios, 27)] = T4i - T4f;
+ }
+ {
+ E T4d, T4e, T4j, T4k;
+ T4d = T4b - T4c;
+ T4e = T49 - T46;
+ io[WS(ios, 11)] = T4d + T4e;
+ io[WS(ios, 21)] = T4e - T4d;
+ T4j = T41 - T42;
+ T4k = T4h - T4g;
+ ro[WS(ros, 21)] = T4j - T4k;
+ ro[WS(ros, 11)] = T4j + T4k;
+ }
+ }
+ {
+ E T1d, T33, T3e, T2U, T1w, T3d, T3b, T3j, T2N, T34, T28, T2Y, T38, T3i, T2J;
+ E T2Z;
+ {
+ E T1m, T1v, T1Y, T27;
+ T1d = T15 - T1c;
+ T33 = T15 + T1c;
+ T3e = T2T + T2Q;
+ T2U = T2Q - T2T;
+ T1m = FMA(KP195090322, T1i, KP980785280 * T1l);
+ T1v = FNMS(KP195090322, T1u, KP980785280 * T1r);
+ T1w = T1m - T1v;
+ T3d = T1v + T1m;
+ {
+ E T39, T3a, T2L, T2M;
+ T39 = T2j + T2y;
+ T3a = T2H + T2C;
+ T3b = FNMS(KP098017140, T3a, KP995184726 * T39);
+ T3j = FMA(KP995184726, T3a, KP098017140 * T39);
+ T2L = FNMS(KP195090322, T1l, KP980785280 * T1i);
+ T2M = FMA(KP980785280, T1u, KP195090322 * T1r);
+ T2N = T2L - T2M;
+ T34 = T2M + T2L;
+ }
+ T1Y = T1M - T1X;
+ T27 = T23 - T26;
+ T28 = FMA(KP634393284, T1Y, KP773010453 * T27);
+ T2Y = FNMS(KP634393284, T27, KP773010453 * T1Y);
+ {
+ E T36, T37, T2z, T2I;
+ T36 = T1X + T1M;
+ T37 = T23 + T26;
+ T38 = FMA(KP098017140, T36, KP995184726 * T37);
+ T3i = FNMS(KP098017140, T37, KP995184726 * T36);
+ T2z = T2j - T2y;
+ T2I = T2C - T2H;
+ T2J = FNMS(KP634393284, T2I, KP773010453 * T2z);
+ T2Z = FMA(KP773010453, T2I, KP634393284 * T2z);
+ }
+ }
+ {
+ E T1x, T2K, T2X, T30;
+ T1x = T1d + T1w;
+ T2K = T28 + T2J;
+ ro[WS(ros, 25)] = T1x - T2K;
+ ro[WS(ros, 7)] = T1x + T2K;
+ T2X = T2U + T2N;
+ T30 = T2Y + T2Z;
+ io[WS(ios, 7)] = T2X + T30;
+ io[WS(ios, 25)] = T30 - T2X;
+ }
+ {
+ E T2V, T2W, T31, T32;
+ T2V = T2N - T2U;
+ T2W = T2J - T28;
+ io[WS(ios, 9)] = T2V + T2W;
+ io[WS(ios, 23)] = T2W - T2V;
+ T31 = T1d - T1w;
+ T32 = T2Z - T2Y;
+ ro[WS(ros, 23)] = T31 - T32;
+ ro[WS(ros, 9)] = T31 + T32;
+ }
+ {
+ E T35, T3c, T3h, T3k;
+ T35 = T33 + T34;
+ T3c = T38 + T3b;
+ ro[WS(ros, 31)] = T35 - T3c;
+ ro[WS(ros, 1)] = T35 + T3c;
+ T3h = T3e + T3d;
+ T3k = T3i + T3j;
+ io[WS(ios, 1)] = T3h + T3k;
+ io[WS(ios, 31)] = T3k - T3h;
+ }
+ {
+ E T3f, T3g, T3l, T3m;
+ T3f = T3d - T3e;
+ T3g = T3b - T38;
+ io[WS(ios, 15)] = T3f + T3g;
+ io[WS(ios, 17)] = T3g - T3f;
+ T3l = T33 - T34;
+ T3m = T3j - T3i;
+ ro[WS(ros, 17)] = T3l - T3m;
+ ro[WS(ros, 15)] = T3l + T3m;
+ }
+ }
+ }
+}
+
+static void mr2hc_64(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; --i) {
+ mr2hc_64_0(I, ro, io, is, ros, ios);
+ I += ivs;
+ ro += ovs;
+ io += ovs;
+ }
+}
+
+static const kr2hc_desc desc = { 64, "mr2hc_64", {342, 72, 52, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_mr2hc_64) (planner *p) {
+ X(kr2hc_register) (p, mr2hc_64, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c
new file mode 100644
index 0000000..d163e75
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_10.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:12 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 10 -name r2hcII_10 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 32 FP additions, 12 FP multiplications,
+ * (or, 26 additions, 6 multiplications, 6 fused multiply/add),
+ * 21 stack variables, and 20 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_10(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, To, T8, Tq, T9, Tp, Te, Ts, Th, Tn;
+ T1 = I[0];
+ To = I[WS(is, 5)];
+ {
+ E T2, T3, T4, T5, T6, T7;
+ T2 = I[WS(is, 4)];
+ T3 = I[WS(is, 6)];
+ T4 = T2 - T3;
+ T5 = I[WS(is, 8)];
+ T6 = I[WS(is, 2)];
+ T7 = T5 - T6;
+ T8 = T4 + T7;
+ Tq = T5 + T6;
+ T9 = KP559016994 * (T4 - T7);
+ Tp = T2 + T3;
+ }
+ {
+ E Tc, Td, Tm, Tf, Tg, Tl;
+ Tc = I[WS(is, 1)];
+ Td = I[WS(is, 9)];
+ Tm = Tc + Td;
+ Tf = I[WS(is, 3)];
+ Tg = I[WS(is, 7)];
+ Tl = Tf + Tg;
+ Te = Tc - Td;
+ Ts = KP559016994 * (Tm + Tl);
+ Th = Tf - Tg;
+ Tn = Tl - Tm;
+ }
+ ro[WS(ros, 2)] = T1 + T8;
+ io[WS(ios, 2)] = Tn - To;
+ {
+ E Ti, Tk, Tb, Tj, Ta;
+ Ti = FMA(KP951056516, Te, KP587785252 * Th);
+ Tk = FNMS(KP587785252, Te, KP951056516 * Th);
+ Ta = FNMS(KP250000000, T8, T1);
+ Tb = T9 + Ta;
+ Tj = Ta - T9;
+ ro[WS(ros, 4)] = Tb - Ti;
+ ro[WS(ros, 3)] = Tj + Tk;
+ ro[0] = Tb + Ti;
+ ro[WS(ros, 1)] = Tj - Tk;
+ }
+ {
+ E Tr, Tw, Tu, Tv, Tt;
+ Tr = FMA(KP951056516, Tp, KP587785252 * Tq);
+ Tw = FNMS(KP587785252, Tp, KP951056516 * Tq);
+ Tt = FMA(KP250000000, Tn, To);
+ Tu = Ts + Tt;
+ Tv = Tt - Ts;
+ io[0] = -(Tr + Tu);
+ io[WS(ios, 3)] = Tw + Tv;
+ io[WS(ios, 4)] = Tr - Tu;
+ io[WS(ios, 1)] = Tv - Tw;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 10, "r2hcII_10", {26, 6, 6, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_10) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_10, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c
new file mode 100644
index 0000000..9e01c7b
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_12.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:14 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 12 -name r2hcII_12 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 43 FP additions, 12 FP multiplications,
+ * (or, 39 additions, 8 multiplications, 4 fused multiply/add),
+ * 28 stack variables, and 24 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_12(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP353553390, +0.353553390593273762200422181052424519642417969);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ DK(KP612372435, +0.612372435695794524549321018676472847991486870);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E Tx, Tg, T4, Tz, Ty, Tj, TA, T9, Tm, Tl, Te, Tp, To, Tf, TE;
+ E TF;
+ {
+ E T1, T3, T2, Th, Ti;
+ T1 = I[0];
+ T3 = I[WS(is, 4)];
+ T2 = I[WS(is, 8)];
+ Tx = KP866025403 * (T2 + T3);
+ Tg = FMA(KP500000000, T3 - T2, T1);
+ T4 = T1 + T2 - T3;
+ Tz = I[WS(is, 6)];
+ Th = I[WS(is, 10)];
+ Ti = I[WS(is, 2)];
+ Ty = Th + Ti;
+ Tj = KP866025403 * (Th - Ti);
+ TA = FMA(KP500000000, Ty, Tz);
+ }
+ {
+ E T5, T6, T7, T8;
+ T5 = I[WS(is, 3)];
+ T6 = I[WS(is, 11)];
+ T7 = I[WS(is, 7)];
+ T8 = T6 - T7;
+ T9 = T5 + T8;
+ Tm = KP612372435 * (T6 + T7);
+ Tl = FNMS(KP353553390, T8, KP707106781 * T5);
+ }
+ {
+ E Td, Ta, Tb, Tc;
+ Td = I[WS(is, 9)];
+ Ta = I[WS(is, 5)];
+ Tb = I[WS(is, 1)];
+ Tc = Ta - Tb;
+ Te = Tc - Td;
+ Tp = FMA(KP353553390, Tc, KP707106781 * Td);
+ To = KP612372435 * (Ta + Tb);
+ }
+ Tf = KP707106781 * (T9 + Te);
+ ro[WS(ros, 1)] = T4 - Tf;
+ ro[WS(ros, 4)] = T4 + Tf;
+ TE = KP707106781 * (Te - T9);
+ TF = Tz - Ty;
+ io[WS(ios, 4)] = TE - TF;
+ io[WS(ios, 1)] = TE + TF;
+ {
+ E Tk, TB, Tr, Tw, Tn, Tq;
+ Tk = Tg - Tj;
+ TB = Tx - TA;
+ Tn = Tl - Tm;
+ Tq = To - Tp;
+ Tr = Tn + Tq;
+ Tw = Tn - Tq;
+ ro[WS(ros, 5)] = Tk - Tr;
+ io[WS(ios, 2)] = Tw + TB;
+ ro[0] = Tk + Tr;
+ io[WS(ios, 3)] = Tw - TB;
+ }
+ {
+ E Ts, TD, Tv, TC, Tt, Tu;
+ Ts = Tg + Tj;
+ TD = Tx + TA;
+ Tt = To + Tp;
+ Tu = Tm + Tl;
+ Tv = Tt - Tu;
+ TC = Tu + Tt;
+ ro[WS(ros, 3)] = Ts - Tv;
+ io[WS(ios, 5)] = TD - TC;
+ ro[WS(ros, 2)] = Ts + Tv;
+ io[0] = -(TC + TD);
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 12, "r2hcII_12", {39, 8, 4, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_12) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_12, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c
new file mode 100644
index 0000000..72e014a
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_15.c
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:16 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 15 -name r2hcII_15 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 72 FP additions, 33 FP multiplications,
+ * (or, 54 additions, 15 multiplications, 18 fused multiply/add),
+ * 37 stack variables, and 30 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_15(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP809016994, +0.809016994374947424102293417182819058860154590);
+ DK(KP309016994, +0.309016994374947424102293417182819058860154590);
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2, Tx, TR, TE, T7, TD, Th, Tm, Tr, TQ, TA, TB, Tf, Te;
+ E Tu, TS, Td, TH, TO;
+ T1 = I[WS(is, 10)];
+ {
+ E T3, Tv, T6, Tw, T4, T5;
+ T2 = I[WS(is, 4)];
+ T3 = I[WS(is, 1)];
+ Tv = T2 + T3;
+ T4 = I[WS(is, 7)];
+ T5 = I[WS(is, 13)];
+ T6 = T4 + T5;
+ Tw = T4 - T5;
+ Tx = FMA(KP951056516, Tv, KP587785252 * Tw);
+ TR = FNMS(KP587785252, Tv, KP951056516 * Tw);
+ TE = KP559016994 * (T3 - T6);
+ T7 = T3 + T6;
+ TD = KP250000000 * T7;
+ }
+ {
+ E Ti, Tl, Tj, Tk, Tp, Tq;
+ Th = I[0];
+ Ti = I[WS(is, 9)];
+ Tl = I[WS(is, 12)];
+ Tj = I[WS(is, 3)];
+ Tk = I[WS(is, 6)];
+ Tp = Tk + Ti;
+ Tq = Tl + Tj;
+ Tm = Ti + Tj - (Tk + Tl);
+ Tr = FMA(KP951056516, Tp, KP587785252 * Tq);
+ TQ = FNMS(KP951056516, Tq, KP587785252 * Tp);
+ TA = FMA(KP250000000, Tm, Th);
+ TB = KP559016994 * (Tl + Ti - (Tk + Tj));
+ }
+ {
+ E T9, Tt, Tc, Ts, Ta, Tb, TG;
+ Tf = I[WS(is, 5)];
+ T9 = I[WS(is, 14)];
+ Te = I[WS(is, 11)];
+ Tt = T9 + Te;
+ Ta = I[WS(is, 2)];
+ Tb = I[WS(is, 8)];
+ Tc = Ta + Tb;
+ Ts = Ta - Tb;
+ Tu = FNMS(KP951056516, Tt, KP587785252 * Ts);
+ TS = FMA(KP951056516, Ts, KP587785252 * Tt);
+ Td = T9 + Tc;
+ TG = KP559016994 * (T9 - Tc);
+ TH = FNMS(KP309016994, Te, TG) + FNMA(KP250000000, Td, Tf);
+ TO = FMS(KP809016994, Te, Tf) + FNMA(KP250000000, Td, TG);
+ }
+ {
+ E Tn, T8, Tg, To;
+ Tn = Th - Tm;
+ T8 = T1 + T2 - T7;
+ Tg = Td - Te - Tf;
+ To = T8 + Tg;
+ io[WS(ios, 2)] = KP866025403 * (T8 - Tg);
+ ro[WS(ros, 2)] = FNMS(KP500000000, To, Tn);
+ ro[WS(ros, 7)] = Tn + To;
+ }
+ {
+ E TM, TX, TT, TV, TP, TU, TN, TW;
+ TM = TB + TA;
+ TX = KP866025403 * (TR + TS);
+ TT = TR - TS;
+ TV = FMS(KP500000000, TT, TQ);
+ TN = T1 + TE + FNMS(KP809016994, T2, TD);
+ TP = TN + TO;
+ TU = KP866025403 * (TO - TN);
+ ro[WS(ros, 1)] = TM + TP;
+ io[WS(ios, 1)] = TQ + TT;
+ io[WS(ios, 6)] = TU - TV;
+ io[WS(ios, 3)] = TU + TV;
+ TW = FNMS(KP500000000, TP, TM);
+ ro[WS(ros, 3)] = TW - TX;
+ ro[WS(ros, 6)] = TW + TX;
+ }
+ {
+ E Tz, TC, Ty, TK, TI, TL, TF, TJ;
+ Tz = KP866025403 * (Tx + Tu);
+ TC = TA - TB;
+ Ty = Tu - Tx;
+ TK = FMS(KP500000000, Ty, Tr);
+ TF = FMA(KP309016994, T2, T1) + TD - TE;
+ TI = TF + TH;
+ TL = KP866025403 * (TH - TF);
+ io[WS(ios, 4)] = Tr + Ty;
+ ro[WS(ros, 4)] = TC + TI;
+ io[WS(ios, 5)] = TK - TL;
+ io[0] = TK + TL;
+ TJ = FNMS(KP500000000, TI, TC);
+ ro[0] = Tz + TJ;
+ ro[WS(ros, 5)] = TJ - Tz;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 15, "r2hcII_15", {54, 15, 18, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_15) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_15, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c
new file mode 100644
index 0000000..4535bde
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_16.c
@@ -0,0 +1,171 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:21 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 16 -name r2hcII_16 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 66 FP additions, 30 FP multiplications,
+ * (or, 54 additions, 18 multiplications, 12 fused multiply/add),
+ * 32 stack variables, and 32 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_16(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T5, T11, TB, TV, Tr, TK, Tu, TJ, Ti, TH, Tl, TG, Tc, T10, TE;
+ E TS;
+ {
+ E T1, TU, T4, TT, T2, T3;
+ T1 = I[0];
+ TU = I[WS(is, 8)];
+ T2 = I[WS(is, 4)];
+ T3 = I[WS(is, 12)];
+ T4 = KP707106781 * (T2 - T3);
+ TT = KP707106781 * (T2 + T3);
+ T5 = T1 + T4;
+ T11 = TU - TT;
+ TB = T1 - T4;
+ TV = TT + TU;
+ }
+ {
+ E Tq, Tt, Tp, Ts, Tn, To;
+ Tq = I[WS(is, 15)];
+ Tt = I[WS(is, 7)];
+ Tn = I[WS(is, 3)];
+ To = I[WS(is, 11)];
+ Tp = KP707106781 * (Tn - To);
+ Ts = KP707106781 * (Tn + To);
+ Tr = Tp - Tq;
+ TK = Tt - Ts;
+ Tu = Ts + Tt;
+ TJ = Tp + Tq;
+ }
+ {
+ E Te, Tk, Th, Tj, Tf, Tg;
+ Te = I[WS(is, 1)];
+ Tk = I[WS(is, 9)];
+ Tf = I[WS(is, 5)];
+ Tg = I[WS(is, 13)];
+ Th = KP707106781 * (Tf - Tg);
+ Tj = KP707106781 * (Tf + Tg);
+ Ti = Te + Th;
+ TH = Tk - Tj;
+ Tl = Tj + Tk;
+ TG = Te - Th;
+ }
+ {
+ E T8, TC, Tb, TD;
+ {
+ E T6, T7, T9, Ta;
+ T6 = I[WS(is, 2)];
+ T7 = I[WS(is, 10)];
+ T8 = FNMS(KP382683432, T7, KP923879532 * T6);
+ TC = FMA(KP382683432, T6, KP923879532 * T7);
+ T9 = I[WS(is, 6)];
+ Ta = I[WS(is, 14)];
+ Tb = FNMS(KP923879532, Ta, KP382683432 * T9);
+ TD = FMA(KP923879532, T9, KP382683432 * Ta);
+ }
+ Tc = T8 + Tb;
+ T10 = Tb - T8;
+ TE = TC - TD;
+ TS = TC + TD;
+ }
+ {
+ E Td, TW, Tw, TR, Tm, Tv;
+ Td = T5 - Tc;
+ TW = TS + TV;
+ Tm = FMA(KP195090322, Ti, KP980785280 * Tl);
+ Tv = FNMS(KP980785280, Tu, KP195090322 * Tr);
+ Tw = Tm + Tv;
+ TR = Tv - Tm;
+ ro[WS(ros, 4)] = Td - Tw;
+ io[WS(ios, 7)] = TR + TW;
+ ro[WS(ros, 3)] = Td + Tw;
+ io[0] = TR - TW;
+ }
+ {
+ E Tx, TY, TA, TX, Ty, Tz;
+ Tx = T5 + Tc;
+ TY = TV - TS;
+ Ty = FNMS(KP195090322, Tl, KP980785280 * Ti);
+ Tz = FMA(KP980785280, Tr, KP195090322 * Tu);
+ TA = Ty + Tz;
+ TX = Tz - Ty;
+ ro[WS(ros, 7)] = Tx - TA;
+ io[WS(ios, 3)] = TX + TY;
+ ro[0] = Tx + TA;
+ io[WS(ios, 4)] = TX - TY;
+ }
+ {
+ E TF, T12, TM, TZ, TI, TL;
+ TF = TB + TE;
+ T12 = T10 - T11;
+ TI = FMA(KP831469612, TG, KP555570233 * TH);
+ TL = FMA(KP831469612, TJ, KP555570233 * TK);
+ TM = TI - TL;
+ TZ = TI + TL;
+ ro[WS(ros, 6)] = TF - TM;
+ io[WS(ios, 2)] = T12 - TZ;
+ ro[WS(ros, 1)] = TF + TM;
+ io[WS(ios, 5)] = -(TZ + T12);
+ }
+ {
+ E TN, T14, TQ, T13, TO, TP;
+ TN = TB - TE;
+ T14 = T10 + T11;
+ TO = FNMS(KP555570233, TJ, KP831469612 * TK);
+ TP = FNMS(KP555570233, TG, KP831469612 * TH);
+ TQ = TO - TP;
+ T13 = TP + TO;
+ ro[WS(ros, 5)] = TN - TQ;
+ io[WS(ios, 1)] = T13 + T14;
+ ro[WS(ros, 2)] = TN + TQ;
+ io[WS(ios, 6)] = T13 - T14;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 16, "r2hcII_16", {54, 18, 12, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_16) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_16, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c
new file mode 100644
index 0000000..00ca93b
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_2.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:02 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 2 -name r2hcII_2 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 0 FP additions, 0 FP multiplications,
+ * (or, 0 additions, 0 multiplications, 0 fused multiply/add),
+ * 3 stack variables, and 4 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_2(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2;
+ T1 = I[0];
+ ro[0] = T1;
+ T2 = I[WS(is, 1)];
+ io[0] = -T2;
+ }
+}
+
+static const kr2hc_desc desc = { 2, "r2hcII_2", {0, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_2) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_2, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c
new file mode 100644
index 0000000..afdc6d1
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_3.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:02 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 3 -name r2hcII_3 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 4 FP additions, 2 FP multiplications,
+ * (or, 3 additions, 1 multiplications, 1 fused multiply/add),
+ * 7 stack variables, and 6 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_3(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2, T3, T4;
+ T1 = I[0];
+ T2 = I[WS(is, 1)];
+ T3 = I[WS(is, 2)];
+ T4 = T2 - T3;
+ ro[WS(ros, 1)] = T1 - T4;
+ io[0] = -(KP866025403 * (T2 + T3));
+ ro[0] = FMA(KP500000000, T4, T1);
+ }
+}
+
+static const kr2hc_desc desc = { 3, "r2hcII_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_3) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_3, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c
new file mode 100644
index 0000000..728ae3d
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_32.c
@@ -0,0 +1,358 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:28 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 32 -name r2hcII_32 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 174 FP additions, 82 FP multiplications,
+ * (or, 138 additions, 46 multiplications, 36 fused multiply/add),
+ * 62 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP471396736, +0.471396736825997648556387625905254377657460319);
+ DK(KP881921264, +0.881921264348355029712756863660388349508442621);
+ DK(KP634393284, +0.634393284163645498215171613225493370675687095);
+ DK(KP773010453, +0.773010453362736960810906609758469800971041293);
+ DK(KP290284677, +0.290284677254462367636192375817395274691476278);
+ DK(KP956940335, +0.956940335732208864935797886980269969482849206);
+ DK(KP995184726, +0.995184726672196886244836953109479921575474869);
+ DK(KP098017140, +0.098017140329560601994195563888641845861136673);
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T5, T2D, T1z, T2q, Tc, T2C, T1C, T2n, Tm, T1k, T1J, T26, Tv, T1l, T1G;
+ E T27, T15, T1r, T1Y, T2e, T1c, T1s, T1V, T2d, TK, T1o, T1R, T2b, TR, T1p;
+ E T1O, T2a;
+ {
+ E T1, T2p, T4, T2o, T2, T3;
+ T1 = I[0];
+ T2p = I[WS(is, 16)];
+ T2 = I[WS(is, 8)];
+ T3 = I[WS(is, 24)];
+ T4 = KP707106781 * (T2 - T3);
+ T2o = KP707106781 * (T2 + T3);
+ T5 = T1 + T4;
+ T2D = T2p - T2o;
+ T1z = T1 - T4;
+ T2q = T2o + T2p;
+ }
+ {
+ E T8, T1A, Tb, T1B;
+ {
+ E T6, T7, T9, Ta;
+ T6 = I[WS(is, 4)];
+ T7 = I[WS(is, 20)];
+ T8 = FNMS(KP382683432, T7, KP923879532 * T6);
+ T1A = FMA(KP382683432, T6, KP923879532 * T7);
+ T9 = I[WS(is, 12)];
+ Ta = I[WS(is, 28)];
+ Tb = FNMS(KP923879532, Ta, KP382683432 * T9);
+ T1B = FMA(KP923879532, T9, KP382683432 * Ta);
+ }
+ Tc = T8 + Tb;
+ T2C = Tb - T8;
+ T1C = T1A - T1B;
+ T2n = T1A + T1B;
+ }
+ {
+ E Te, Tk, Th, Tj, Tf, Tg;
+ Te = I[WS(is, 2)];
+ Tk = I[WS(is, 18)];
+ Tf = I[WS(is, 10)];
+ Tg = I[WS(is, 26)];
+ Th = KP707106781 * (Tf - Tg);
+ Tj = KP707106781 * (Tf + Tg);
+ {
+ E Ti, Tl, T1H, T1I;
+ Ti = Te + Th;
+ Tl = Tj + Tk;
+ Tm = FNMS(KP195090322, Tl, KP980785280 * Ti);
+ T1k = FMA(KP195090322, Ti, KP980785280 * Tl);
+ T1H = Tk - Tj;
+ T1I = Te - Th;
+ T1J = FNMS(KP555570233, T1I, KP831469612 * T1H);
+ T26 = FMA(KP831469612, T1I, KP555570233 * T1H);
+ }
+ }
+ {
+ E Tq, Tt, Tp, Ts, Tn, To;
+ Tq = I[WS(is, 30)];
+ Tt = I[WS(is, 14)];
+ Tn = I[WS(is, 6)];
+ To = I[WS(is, 22)];
+ Tp = KP707106781 * (Tn - To);
+ Ts = KP707106781 * (Tn + To);
+ {
+ E Tr, Tu, T1E, T1F;
+ Tr = Tp - Tq;
+ Tu = Ts + Tt;
+ Tv = FMA(KP980785280, Tr, KP195090322 * Tu);
+ T1l = FNMS(KP980785280, Tu, KP195090322 * Tr);
+ T1E = Tt - Ts;
+ T1F = Tp + Tq;
+ T1G = FNMS(KP555570233, T1F, KP831469612 * T1E);
+ T27 = FMA(KP831469612, T1F, KP555570233 * T1E);
+ }
+ }
+ {
+ E TW, T1a, TV, T19, T10, T16, T13, T17, TT, TU;
+ TW = I[WS(is, 31)];
+ T1a = I[WS(is, 15)];
+ TT = I[WS(is, 7)];
+ TU = I[WS(is, 23)];
+ TV = KP707106781 * (TT - TU);
+ T19 = KP707106781 * (TT + TU);
+ {
+ E TY, TZ, T11, T12;
+ TY = I[WS(is, 3)];
+ TZ = I[WS(is, 19)];
+ T10 = FNMS(KP382683432, TZ, KP923879532 * TY);
+ T16 = FMA(KP382683432, TY, KP923879532 * TZ);
+ T11 = I[WS(is, 11)];
+ T12 = I[WS(is, 27)];
+ T13 = FNMS(KP923879532, T12, KP382683432 * T11);
+ T17 = FMA(KP923879532, T11, KP382683432 * T12);
+ }
+ {
+ E TX, T14, T1W, T1X;
+ TX = TV - TW;
+ T14 = T10 + T13;
+ T15 = TX + T14;
+ T1r = TX - T14;
+ T1W = T13 - T10;
+ T1X = T1a - T19;
+ T1Y = T1W - T1X;
+ T2e = T1W + T1X;
+ }
+ {
+ E T18, T1b, T1T, T1U;
+ T18 = T16 + T17;
+ T1b = T19 + T1a;
+ T1c = T18 + T1b;
+ T1s = T1b - T18;
+ T1T = TV + TW;
+ T1U = T16 - T17;
+ T1V = T1T + T1U;
+ T2d = T1U - T1T;
+ }
+ }
+ {
+ E Ty, TP, TB, TO, TF, TL, TI, TM, Tz, TA;
+ Ty = I[WS(is, 1)];
+ TP = I[WS(is, 17)];
+ Tz = I[WS(is, 9)];
+ TA = I[WS(is, 25)];
+ TB = KP707106781 * (Tz - TA);
+ TO = KP707106781 * (Tz + TA);
+ {
+ E TD, TE, TG, TH;
+ TD = I[WS(is, 5)];
+ TE = I[WS(is, 21)];
+ TF = FNMS(KP382683432, TE, KP923879532 * TD);
+ TL = FMA(KP382683432, TD, KP923879532 * TE);
+ TG = I[WS(is, 13)];
+ TH = I[WS(is, 29)];
+ TI = FNMS(KP923879532, TH, KP382683432 * TG);
+ TM = FMA(KP923879532, TG, KP382683432 * TH);
+ }
+ {
+ E TC, TJ, T1P, T1Q;
+ TC = Ty + TB;
+ TJ = TF + TI;
+ TK = TC + TJ;
+ T1o = TC - TJ;
+ T1P = TI - TF;
+ T1Q = TP - TO;
+ T1R = T1P - T1Q;
+ T2b = T1P + T1Q;
+ }
+ {
+ E TN, TQ, T1M, T1N;
+ TN = TL + TM;
+ TQ = TO + TP;
+ TR = TN + TQ;
+ T1p = TQ - TN;
+ T1M = Ty - TB;
+ T1N = TL - TM;
+ T1O = T1M - T1N;
+ T2a = T1M + T1N;
+ }
+ }
+ {
+ E Tx, T1f, T2s, T2u, T1e, T2l, T1i, T2t;
+ {
+ E Td, Tw, T2m, T2r;
+ Td = T5 + Tc;
+ Tw = Tm + Tv;
+ Tx = Td - Tw;
+ T1f = Td + Tw;
+ T2m = T1l - T1k;
+ T2r = T2n + T2q;
+ T2s = T2m - T2r;
+ T2u = T2m + T2r;
+ }
+ {
+ E TS, T1d, T1g, T1h;
+ TS = FMA(KP098017140, TK, KP995184726 * TR);
+ T1d = FNMS(KP995184726, T1c, KP098017140 * T15);
+ T1e = TS + T1d;
+ T2l = T1d - TS;
+ T1g = FNMS(KP098017140, TR, KP995184726 * TK);
+ T1h = FMA(KP995184726, T15, KP098017140 * T1c);
+ T1i = T1g + T1h;
+ T2t = T1h - T1g;
+ }
+ ro[WS(ros, 8)] = Tx - T1e;
+ io[WS(ios, 8)] = T2t - T2u;
+ ro[WS(ros, 7)] = Tx + T1e;
+ io[WS(ios, 7)] = T2t + T2u;
+ ro[WS(ros, 15)] = T1f - T1i;
+ io[WS(ios, 15)] = T2l - T2s;
+ ro[0] = T1f + T1i;
+ io[0] = T2l + T2s;
+ }
+ {
+ E T29, T2h, T2M, T2O, T2g, T2J, T2k, T2N;
+ {
+ E T25, T28, T2K, T2L;
+ T25 = T1z + T1C;
+ T28 = T26 - T27;
+ T29 = T25 + T28;
+ T2h = T25 - T28;
+ T2K = T1J + T1G;
+ T2L = T2C + T2D;
+ T2M = T2K - T2L;
+ T2O = T2K + T2L;
+ }
+ {
+ E T2c, T2f, T2i, T2j;
+ T2c = FMA(KP956940335, T2a, KP290284677 * T2b);
+ T2f = FNMS(KP290284677, T2e, KP956940335 * T2d);
+ T2g = T2c + T2f;
+ T2J = T2f - T2c;
+ T2i = FMA(KP290284677, T2d, KP956940335 * T2e);
+ T2j = FNMS(KP290284677, T2a, KP956940335 * T2b);
+ T2k = T2i - T2j;
+ T2N = T2j + T2i;
+ }
+ ro[WS(ros, 14)] = T29 - T2g;
+ io[WS(ios, 14)] = T2N - T2O;
+ ro[WS(ros, 1)] = T29 + T2g;
+ io[WS(ios, 1)] = T2N + T2O;
+ ro[WS(ros, 9)] = T2h - T2k;
+ io[WS(ios, 9)] = T2J - T2M;
+ ro[WS(ros, 6)] = T2h + T2k;
+ io[WS(ios, 6)] = T2J + T2M;
+ }
+ {
+ E T1n, T1v, T2y, T2A, T1u, T2v, T1y, T2z;
+ {
+ E T1j, T1m, T2w, T2x;
+ T1j = T5 - Tc;
+ T1m = T1k + T1l;
+ T1n = T1j + T1m;
+ T1v = T1j - T1m;
+ T2w = Tv - Tm;
+ T2x = T2q - T2n;
+ T2y = T2w - T2x;
+ T2A = T2w + T2x;
+ }
+ {
+ E T1q, T1t, T1w, T1x;
+ T1q = FMA(KP773010453, T1o, KP634393284 * T1p);
+ T1t = FNMS(KP634393284, T1s, KP773010453 * T1r);
+ T1u = T1q + T1t;
+ T2v = T1t - T1q;
+ T1w = FMA(KP634393284, T1r, KP773010453 * T1s);
+ T1x = FNMS(KP634393284, T1o, KP773010453 * T1p);
+ T1y = T1w - T1x;
+ T2z = T1x + T1w;
+ }
+ ro[WS(ros, 12)] = T1n - T1u;
+ io[WS(ios, 12)] = T2z - T2A;
+ ro[WS(ros, 3)] = T1n + T1u;
+ io[WS(ios, 3)] = T2z + T2A;
+ ro[WS(ros, 11)] = T1v - T1y;
+ io[WS(ios, 11)] = T2v - T2y;
+ ro[WS(ros, 4)] = T1v + T1y;
+ io[WS(ios, 4)] = T2v + T2y;
+ }
+ {
+ E T1L, T21, T2G, T2I, T20, T2H, T24, T2B;
+ {
+ E T1D, T1K, T2E, T2F;
+ T1D = T1z - T1C;
+ T1K = T1G - T1J;
+ T1L = T1D + T1K;
+ T21 = T1D - T1K;
+ T2E = T2C - T2D;
+ T2F = T26 + T27;
+ T2G = T2E - T2F;
+ T2I = T2F + T2E;
+ }
+ {
+ E T1S, T1Z, T22, T23;
+ T1S = FMA(KP881921264, T1O, KP471396736 * T1R);
+ T1Z = FMA(KP881921264, T1V, KP471396736 * T1Y);
+ T20 = T1S - T1Z;
+ T2H = T1S + T1Z;
+ T22 = FNMS(KP471396736, T1V, KP881921264 * T1Y);
+ T23 = FNMS(KP471396736, T1O, KP881921264 * T1R);
+ T24 = T22 - T23;
+ T2B = T23 + T22;
+ }
+ ro[WS(ros, 13)] = T1L - T20;
+ io[WS(ios, 13)] = T2B - T2G;
+ ro[WS(ros, 2)] = T1L + T20;
+ io[WS(ios, 2)] = T2B + T2G;
+ ro[WS(ros, 10)] = T21 - T24;
+ io[WS(ios, 10)] = T2I - T2H;
+ ro[WS(ros, 5)] = T21 + T24;
+ io[WS(ios, 5)] = -(T2H + T2I);
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 32, "r2hcII_32", {138, 46, 36, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_32) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c
new file mode 100644
index 0000000..94aaf84
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_4.c
@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:02 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 4 -name r2hcII_4 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 6 FP additions, 2 FP multiplications,
+ * (or, 6 additions, 2 multiplications, 0 fused multiply/add),
+ * 8 stack variables, and 8 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_4(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T6, T4, T5, T2, T3;
+ T1 = I[0];
+ T6 = I[WS(is, 2)];
+ T2 = I[WS(is, 1)];
+ T3 = I[WS(is, 3)];
+ T4 = KP707106781 * (T2 - T3);
+ T5 = KP707106781 * (T2 + T3);
+ ro[WS(ros, 1)] = T1 - T4;
+ io[WS(ios, 1)] = T6 - T5;
+ ro[0] = T1 + T4;
+ io[0] = -(T5 + T6);
+ }
+}
+
+static const kr2hc_desc desc = { 4, "r2hcII_4", {6, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_4) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_4, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c
new file mode 100644
index 0000000..bb40e64
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_5.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:03 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 5 -name r2hcII_5 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 12 FP additions, 6 FP multiplications,
+ * (or, 9 additions, 3 multiplications, 3 fused multiply/add),
+ * 17 stack variables, and 10 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_5(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T8, T3, T6, T9, Tc, Tb, T7, Ta;
+ T8 = I[0];
+ {
+ E T1, T2, T4, T5;
+ T1 = I[WS(is, 2)];
+ T2 = I[WS(is, 3)];
+ T3 = T1 - T2;
+ T4 = I[WS(is, 4)];
+ T5 = I[WS(is, 1)];
+ T6 = T4 - T5;
+ T9 = T3 + T6;
+ Tc = T4 + T5;
+ Tb = T1 + T2;
+ }
+ ro[WS(ros, 2)] = T8 + T9;
+ io[WS(ios, 1)] = FNMS(KP951056516, Tc, KP587785252 * Tb);
+ io[0] = -(FMA(KP951056516, Tb, KP587785252 * Tc));
+ T7 = KP559016994 * (T3 - T6);
+ Ta = FNMS(KP250000000, T9, T8);
+ ro[0] = T7 + Ta;
+ ro[WS(ros, 1)] = Ta - T7;
+ }
+}
+
+static const kr2hc_desc desc = { 5, "r2hcII_5", {9, 3, 3, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_5) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_5, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c
new file mode 100644
index 0000000..04e76c9
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_6.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:03 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 6 -name r2hcII_6 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 13 FP additions, 4 FP multiplications,
+ * (or, 11 additions, 2 multiplications, 2 fused multiply/add),
+ * 14 stack variables, and 12 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_6(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E Ta, T7, T9, T1, T3, T2, T8, T4, T5, T6, Tb;
+ Ta = I[WS(is, 3)];
+ T5 = I[WS(is, 5)];
+ T6 = I[WS(is, 1)];
+ T7 = KP866025403 * (T5 - T6);
+ T9 = T5 + T6;
+ T1 = I[0];
+ T3 = I[WS(is, 2)];
+ T2 = I[WS(is, 4)];
+ T8 = KP866025403 * (T2 + T3);
+ T4 = FMA(KP500000000, T3 - T2, T1);
+ ro[0] = T4 - T7;
+ ro[WS(ros, 2)] = T4 + T7;
+ io[WS(ios, 1)] = Ta - T9;
+ ro[WS(ros, 1)] = T1 + T2 - T3;
+ Tb = FMA(KP500000000, T9, Ta);
+ io[0] = -(T8 + Tb);
+ io[WS(ios, 2)] = T8 - Tb;
+ }
+}
+
+static const kr2hc_desc desc = { 6, "r2hcII_6", {11, 2, 2, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_6) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_6, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c
new file mode 100644
index 0000000..13fb676
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_7.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:04 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 7 -name r2hcII_7 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 24 FP additions, 18 FP multiplications,
+ * (or, 12 additions, 6 multiplications, 12 fused multiply/add),
+ * 20 stack variables, and 14 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_7(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP900968867, +0.900968867902419126236102319507445051165919162);
+ DK(KP222520933, +0.222520933956314404288902564496794759466355569);
+ DK(KP623489801, +0.623489801858733530525004884004239810632274731);
+ DK(KP433883739, +0.433883739117558120475768332848358754609990728);
+ DK(KP974927912, +0.974927912181823607018131682993931217232785801);
+ DK(KP781831482, +0.781831482468029808708444526674057750232334519);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, Ta, Td, T4, Tb, T7, Tc, T8, T9;
+ T1 = I[0];
+ T8 = I[WS(is, 1)];
+ T9 = I[WS(is, 6)];
+ Ta = T8 - T9;
+ Td = T8 + T9;
+ {
+ E T2, T3, T5, T6;
+ T2 = I[WS(is, 2)];
+ T3 = I[WS(is, 5)];
+ T4 = T2 - T3;
+ Tb = T2 + T3;
+ T5 = I[WS(is, 3)];
+ T6 = I[WS(is, 4)];
+ T7 = T5 - T6;
+ Tc = T5 + T6;
+ }
+ io[0] = -(FMA(KP781831482, Tb, KP974927912 * Tc) + (KP433883739 * Td));
+ io[WS(ios, 1)] = FNMS(KP974927912, Td, KP781831482 * Tc) - (KP433883739 * Tb);
+ ro[0] = FMA(KP623489801, T4, T1) + FMA(KP222520933, T7, KP900968867 * Ta);
+ io[WS(ios, 2)] = FNMS(KP781831482, Td, KP974927912 * Tb) - (KP433883739 * Tc);
+ ro[WS(ros, 2)] = FMA(KP900968867, T7, T1) + FNMA(KP623489801, Ta, KP222520933 * T4);
+ ro[WS(ros, 1)] = FMA(KP222520933, Ta, T1) + FNMA(KP623489801, T7, KP900968867 * T4);
+ ro[WS(ros, 3)] = T1 + T4 - (T7 + Ta);
+ }
+}
+
+static const kr2hc_desc desc = { 7, "r2hcII_7", {12, 6, 12, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_7) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_7, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c
new file mode 100644
index 0000000..d6d2aaf
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_8.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:04 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 8 -name r2hcII_8 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 22 FP additions, 10 FP multiplications,
+ * (or, 18 additions, 6 multiplications, 4 fused multiply/add),
+ * 18 stack variables, and 16 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_8(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, Tj, T4, Ti, T8, Te, Tb, Tf, T2, T3;
+ T1 = I[0];
+ Tj = I[WS(is, 4)];
+ T2 = I[WS(is, 2)];
+ T3 = I[WS(is, 6)];
+ T4 = KP707106781 * (T2 - T3);
+ Ti = KP707106781 * (T2 + T3);
+ {
+ E T6, T7, T9, Ta;
+ T6 = I[WS(is, 1)];
+ T7 = I[WS(is, 5)];
+ T8 = FNMS(KP382683432, T7, KP923879532 * T6);
+ Te = FMA(KP382683432, T6, KP923879532 * T7);
+ T9 = I[WS(is, 3)];
+ Ta = I[WS(is, 7)];
+ Tb = FNMS(KP923879532, Ta, KP382683432 * T9);
+ Tf = FMA(KP923879532, T9, KP382683432 * Ta);
+ }
+ {
+ E T5, Tc, Th, Tk;
+ T5 = T1 + T4;
+ Tc = T8 + Tb;
+ ro[WS(ros, 3)] = T5 - Tc;
+ ro[0] = T5 + Tc;
+ Th = Te + Tf;
+ Tk = Ti + Tj;
+ io[0] = -(Th + Tk);
+ io[WS(ios, 3)] = Tk - Th;
+ }
+ {
+ E Td, Tg, Tl, Tm;
+ Td = T1 - T4;
+ Tg = Te - Tf;
+ ro[WS(ros, 2)] = Td - Tg;
+ ro[WS(ros, 1)] = Td + Tg;
+ Tl = Tb - T8;
+ Tm = Tj - Ti;
+ io[WS(ios, 2)] = Tl - Tm;
+ io[WS(ios, 1)] = Tl + Tm;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 8, "r2hcII_8", {18, 6, 4, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_8) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_8, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hcII_9.c b/src/fftw3/rdft/codelets/r2hc/r2hcII_9.c
new file mode 100644
index 0000000..a046b93
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hcII_9.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:58:09 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 9 -name r2hcII_9 -dft-II -include r2hcII.h */
+
+/*
+ * This function contains 42 FP additions, 30 FP multiplications,
+ * (or, 25 additions, 13 multiplications, 17 fused multiply/add),
+ * 39 stack variables, and 18 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hcII_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hcII.h"
+
+static void r2hcII_9(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP663413948, +0.663413948168938396205421319635891297216863310);
+ DK(KP642787609, +0.642787609686539326322643409907263432907559884);
+ DK(KP556670399, +0.556670399226419366452912952047023132968291906);
+ DK(KP766044443, +0.766044443118978035202392650555416673935832457);
+ DK(KP852868531, +0.852868531952443209628250963940074071936020296);
+ DK(KP173648177, +0.173648177666930348851716626769314796000375677);
+ DK(KP984807753, +0.984807753012208059366743024589523013670643252);
+ DK(KP150383733, +0.150383733180435296639271897612501926072238258);
+ DK(KP813797681, +0.813797681349373692844693217248393223289101568);
+ DK(KP342020143, +0.342020143325668733044099614682259580763083368);
+ DK(KP939692620, +0.939692620785908384054109277324731469936208134);
+ DK(KP296198132, +0.296198132726023843175338011893050938967728390);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T4, To, Ta, Tl, Tk, Tf, Ti, Th, T2, T3, T5, Tg;
+ T1 = I[0];
+ T2 = I[WS(is, 3)];
+ T3 = I[WS(is, 6)];
+ T4 = T2 - T3;
+ To = T2 + T3;
+ {
+ E T6, T7, T8, T9;
+ T6 = I[WS(is, 2)];
+ T7 = I[WS(is, 5)];
+ T8 = I[WS(is, 8)];
+ T9 = T7 - T8;
+ Ta = T6 - T9;
+ Tl = T7 + T8;
+ Tk = FMA(KP500000000, T9, T6);
+ }
+ {
+ E Tb, Tc, Td, Te;
+ Tb = I[WS(is, 4)];
+ Tc = I[WS(is, 1)];
+ Td = I[WS(is, 7)];
+ Te = Tc + Td;
+ Tf = Tb - Te;
+ Ti = FMA(KP500000000, Te, Tb);
+ Th = Tc - Td;
+ }
+ io[WS(ios, 1)] = KP866025403 * (Tf - Ta);
+ T5 = T1 - T4;
+ Tg = Ta + Tf;
+ ro[WS(ros, 1)] = FNMS(KP500000000, Tg, T5);
+ ro[WS(ros, 4)] = T5 + Tg;
+ {
+ E Tr, Tt, Tw, Tv, Tu, Tp, Tq, Ts, Tj, Tm, Tn;
+ Tr = FMA(KP500000000, T4, T1);
+ Tt = FMA(KP296198132, Th, KP939692620 * Ti);
+ Tw = FNMS(KP813797681, Th, KP342020143 * Ti);
+ Tv = FNMS(KP984807753, Tk, KP150383733 * Tl);
+ Tu = FMA(KP173648177, Tk, KP852868531 * Tl);
+ Tp = FNMS(KP556670399, Tl, KP766044443 * Tk);
+ Tq = FMA(KP852868531, Th, KP173648177 * Ti);
+ Ts = Tp + Tq;
+ Tj = FNMS(KP984807753, Ti, KP150383733 * Th);
+ Tm = FMA(KP642787609, Tk, KP663413948 * Tl);
+ Tn = Tj - Tm;
+ io[0] = FNMS(KP866025403, To, Tn);
+ ro[0] = Tr + Ts;
+ io[WS(ios, 3)] = FNMS(KP500000000, Tn, KP866025403 * ((Tp - Tq) - To));
+ ro[WS(ros, 3)] = FMA(KP866025403, Tm + Tj, Tr) - (KP500000000 * Ts);
+ io[WS(ios, 2)] = FMA(KP866025403, To - (Tu + Tt), KP500000000 * (Tw - Tv));
+ ro[WS(ros, 2)] = FMA(KP500000000, Tt - Tu, Tr) + (KP866025403 * (Tv + Tw));
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 9, "r2hcII_9", {25, 13, 17, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hcII_9) (planner *p) {
+ X(kr2hcII_register) (p, r2hcII_9, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_10.c b/src/fftw3/rdft/codelets/r2hc/r2hc_10.c
new file mode 100644
index 0000000..38e1766
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_10.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 10 -name r2hc_10 -include r2hc.h */
+
+/*
+ * This function contains 34 FP additions, 12 FP multiplications,
+ * (or, 28 additions, 6 multiplications, 6 fused multiply/add),
+ * 26 stack variables, and 20 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_10.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_10(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E Ti, Tt, Ta, Tn, Td, To, Te, Tv, T3, Tq, T6, Tr, T7, Tu, Tg;
+ E Th;
+ Tg = I[0];
+ Th = I[WS(is, 5)];
+ Ti = Tg - Th;
+ Tt = Tg + Th;
+ {
+ E T8, T9, Tb, Tc;
+ T8 = I[WS(is, 4)];
+ T9 = I[WS(is, 9)];
+ Ta = T8 - T9;
+ Tn = T8 + T9;
+ Tb = I[WS(is, 6)];
+ Tc = I[WS(is, 1)];
+ Td = Tb - Tc;
+ To = Tb + Tc;
+ }
+ Te = Ta + Td;
+ Tv = Tn + To;
+ {
+ E T1, T2, T4, T5;
+ T1 = I[WS(is, 2)];
+ T2 = I[WS(is, 7)];
+ T3 = T1 - T2;
+ Tq = T1 + T2;
+ T4 = I[WS(is, 8)];
+ T5 = I[WS(is, 3)];
+ T6 = T4 - T5;
+ Tr = T4 + T5;
+ }
+ T7 = T3 + T6;
+ Tu = Tq + Tr;
+ {
+ E Tl, Tm, Tf, Tj, Tk;
+ Tl = Td - Ta;
+ Tm = T3 - T6;
+ io[WS(ios, 1)] = FNMS(KP951056516, Tm, KP587785252 * Tl);
+ io[WS(ios, 3)] = FMA(KP587785252, Tm, KP951056516 * Tl);
+ Tf = KP559016994 * (T7 - Te);
+ Tj = T7 + Te;
+ Tk = FNMS(KP250000000, Tj, Ti);
+ ro[WS(ros, 1)] = Tf + Tk;
+ ro[WS(ros, 5)] = Ti + Tj;
+ ro[WS(ros, 3)] = Tk - Tf;
+ }
+ {
+ E Tp, Ts, Ty, Tw, Tx;
+ Tp = Tn - To;
+ Ts = Tq - Tr;
+ io[WS(ios, 2)] = FNMS(KP587785252, Ts, KP951056516 * Tp);
+ io[WS(ios, 4)] = FMA(KP951056516, Ts, KP587785252 * Tp);
+ Ty = KP559016994 * (Tu - Tv);
+ Tw = Tu + Tv;
+ Tx = FNMS(KP250000000, Tw, Tt);
+ ro[WS(ros, 2)] = Tx - Ty;
+ ro[0] = Tt + Tw;
+ ro[WS(ros, 4)] = Ty + Tx;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 10, "r2hc_10", {28, 6, 6, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_10) (planner *p) {
+ X(kr2hc_register) (p, r2hc_10, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_11.c b/src/fftw3/rdft/codelets/r2hc/r2hc_11.c
new file mode 100644
index 0000000..cceb091
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_11.c
@@ -0,0 +1,102 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 11 -name r2hc_11 -include r2hc.h */
+
+/*
+ * This function contains 60 FP additions, 50 FP multiplications,
+ * (or, 20 additions, 10 multiplications, 40 fused multiply/add),
+ * 28 stack variables, and 22 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_11.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_11(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP654860733, +0.654860733945285064056925072466293553183791199);
+ DK(KP142314838, +0.142314838273285140443792668616369668791051361);
+ DK(KP959492973, +0.959492973614497389890368057066327699062454848);
+ DK(KP415415013, +0.415415013001886425529274149229623203524004910);
+ DK(KP841253532, +0.841253532831181168861811648919367717513292498);
+ DK(KP989821441, +0.989821441880932732376092037776718787376519372);
+ DK(KP909631995, +0.909631995354518371411715383079028460060241051);
+ DK(KP281732556, +0.281732556841429697711417915346616899035777899);
+ DK(KP540640817, +0.540640817455597582107635954318691695431770608);
+ DK(KP755749574, +0.755749574354258283774035843972344420179717445);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T4, Tl, Tg, Th, Td, Ti, Ta, Tk, T7, Tj, Tb, Tc;
+ T1 = I[0];
+ {
+ E T2, T3, Te, Tf;
+ T2 = I[WS(is, 2)];
+ T3 = I[WS(is, 9)];
+ T4 = T2 + T3;
+ Tl = T3 - T2;
+ Te = I[WS(is, 1)];
+ Tf = I[WS(is, 10)];
+ Tg = Te + Tf;
+ Th = Tf - Te;
+ }
+ Tb = I[WS(is, 3)];
+ Tc = I[WS(is, 8)];
+ Td = Tb + Tc;
+ Ti = Tc - Tb;
+ {
+ E T8, T9, T5, T6;
+ T8 = I[WS(is, 5)];
+ T9 = I[WS(is, 6)];
+ Ta = T8 + T9;
+ Tk = T9 - T8;
+ T5 = I[WS(is, 4)];
+ T6 = I[WS(is, 7)];
+ T7 = T5 + T6;
+ Tj = T6 - T5;
+ }
+ io[WS(ios, 4)] = FMA(KP755749574, Th, KP540640817 * Ti) + FNMS(KP909631995, Tk, KP281732556 * Tj) - (KP989821441 * Tl);
+ ro[WS(ros, 4)] = FMA(KP841253532, Td, T1) + FNMS(KP959492973, T7, KP415415013 * Ta) + FNMA(KP142314838, T4, KP654860733 * Tg);
+ io[WS(ios, 2)] = FMA(KP909631995, Th, KP755749574 * Tl) + FNMA(KP540640817, Tk, KP989821441 * Tj) - (KP281732556 * Ti);
+ io[WS(ios, 5)] = FMA(KP281732556, Th, KP755749574 * Ti) + FNMS(KP909631995, Tj, KP989821441 * Tk) - (KP540640817 * Tl);
+ io[WS(ios, 1)] = FMA(KP540640817, Th, KP909631995 * Tl) + FMA(KP989821441, Ti, KP755749574 * Tj) + (KP281732556 * Tk);
+ io[WS(ios, 3)] = FMA(KP989821441, Th, KP540640817 * Tj) + FNMS(KP909631995, Ti, KP755749574 * Tk) - (KP281732556 * Tl);
+ ro[WS(ros, 3)] = FMA(KP415415013, Td, T1) + FNMS(KP654860733, Ta, KP841253532 * T7) + FNMA(KP959492973, T4, KP142314838 * Tg);
+ ro[WS(ros, 1)] = FMA(KP841253532, Tg, T1) + FNMS(KP959492973, Ta, KP415415013 * T4) + FNMA(KP654860733, T7, KP142314838 * Td);
+ ro[0] = T1 + Tg + T4 + Td + T7 + Ta;
+ ro[WS(ros, 2)] = FMA(KP415415013, Tg, T1) + FNMS(KP142314838, T7, KP841253532 * Ta) + FNMA(KP959492973, Td, KP654860733 * T4);
+ ro[WS(ros, 5)] = FMA(KP841253532, T4, T1) + FNMS(KP142314838, Ta, KP415415013 * T7) + FNMA(KP654860733, Td, KP959492973 * Tg);
+ }
+}
+
+static const kr2hc_desc desc = { 11, "r2hc_11", {20, 10, 40, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_11) (planner *p) {
+ X(kr2hc_register) (p, r2hc_11, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_12.c b/src/fftw3/rdft/codelets/r2hc/r2hc_12.c
new file mode 100644
index 0000000..81a5273
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_12.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 12 -name r2hc_12 -include r2hc.h */
+
+/*
+ * This function contains 38 FP additions, 8 FP multiplications,
+ * (or, 34 additions, 4 multiplications, 4 fused multiply/add),
+ * 21 stack variables, and 24 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_12.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_12(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T5, Tp, Tb, Tn, Ty, Tt, Ta, Tq, Tc, Ti, Tz, Tu, Td, To;
+ {
+ E T1, T2, T3, T4;
+ T1 = I[0];
+ T2 = I[WS(is, 4)];
+ T3 = I[WS(is, 8)];
+ T4 = T2 + T3;
+ T5 = T1 + T4;
+ Tp = FNMS(KP500000000, T4, T1);
+ Tb = T3 - T2;
+ }
+ {
+ E Tj, Tk, Tl, Tm;
+ Tj = I[WS(is, 3)];
+ Tk = I[WS(is, 7)];
+ Tl = I[WS(is, 11)];
+ Tm = Tk + Tl;
+ Tn = FNMS(KP500000000, Tm, Tj);
+ Ty = Tl - Tk;
+ Tt = Tj + Tm;
+ }
+ {
+ E T6, T7, T8, T9;
+ T6 = I[WS(is, 6)];
+ T7 = I[WS(is, 10)];
+ T8 = I[WS(is, 2)];
+ T9 = T7 + T8;
+ Ta = T6 + T9;
+ Tq = FNMS(KP500000000, T9, T6);
+ Tc = T8 - T7;
+ }
+ {
+ E Te, Tf, Tg, Th;
+ Te = I[WS(is, 9)];
+ Tf = I[WS(is, 1)];
+ Tg = I[WS(is, 5)];
+ Th = Tf + Tg;
+ Ti = FNMS(KP500000000, Th, Te);
+ Tz = Tg - Tf;
+ Tu = Te + Th;
+ }
+ ro[WS(ros, 3)] = T5 - Ta;
+ io[WS(ios, 3)] = Tt - Tu;
+ Td = KP866025403 * (Tb - Tc);
+ To = Ti - Tn;
+ io[WS(ios, 1)] = Td + To;
+ io[WS(ios, 5)] = To - Td;
+ {
+ E Tx, TA, Tv, Tw;
+ Tx = Tp - Tq;
+ TA = KP866025403 * (Ty - Tz);
+ ro[WS(ros, 5)] = Tx - TA;
+ ro[WS(ros, 1)] = Tx + TA;
+ Tv = T5 + Ta;
+ Tw = Tt + Tu;
+ ro[WS(ros, 6)] = Tv - Tw;
+ ro[0] = Tv + Tw;
+ }
+ {
+ E Tr, Ts, TB, TC;
+ Tr = Tp + Tq;
+ Ts = Tn + Ti;
+ ro[WS(ros, 2)] = Tr - Ts;
+ ro[WS(ros, 4)] = Tr + Ts;
+ TB = Ty + Tz;
+ TC = Tb + Tc;
+ io[WS(ios, 2)] = KP866025403 * (TB - TC);
+ io[WS(ios, 4)] = KP866025403 * (TC + TB);
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 12, "r2hc_12", {34, 4, 4, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_12) (planner *p) {
+ X(kr2hc_register) (p, r2hc_12, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_13.c b/src/fftw3/rdft/codelets/r2hc/r2hc_13.c
new file mode 100644
index 0000000..deb7914
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_13.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 13 -name r2hc_13 -include r2hc.h */
+
+/*
+ * This function contains 76 FP additions, 34 FP multiplications,
+ * (or, 57 additions, 15 multiplications, 19 fused multiply/add),
+ * 55 stack variables, and 26 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_13.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_13(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP083333333, +0.083333333333333333333333333333333333333333333);
+ DK(KP075902986, +0.075902986037193865983102897245103540356428373);
+ DK(KP251768516, +0.251768516431883313623436926934233488546674281);
+ DK(KP503537032, +0.503537032863766627246873853868466977093348562);
+ DK(KP113854479, +0.113854479055790798974654345867655310534642560);
+ DK(KP265966249, +0.265966249214837287587521063842185948798330267);
+ DK(KP387390585, +0.387390585467617292130675966426762851778775217);
+ DK(KP300462606, +0.300462606288665774426601772289207995520941381);
+ DK(KP132983124, +0.132983124607418643793760531921092974399165133);
+ DK(KP258260390, +0.258260390311744861420450644284508567852516811);
+ DK(KP2_000000000, +2.000000000000000000000000000000000000000000000);
+ DK(KP1_732050807, +1.732050807568877293527446341505872366942805254);
+ DK(KP300238635, +0.300238635966332641462884626667381504676006424);
+ DK(KP011599105, +0.011599105605768290721655456654083252189827041);
+ DK(KP156891391, +0.156891391051584611046832726756003269660212636);
+ DK(KP256247671, +0.256247671582936600958684654061725059144125175);
+ DK(KP174138601, +0.174138601152135905005660794929264742616964676);
+ DK(KP575140729, +0.575140729474003121368385547455453388461001608);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T13, Tb, Tm, TW, TX, T14, TU, T10, Tz, TB, Tu, TC, TR, T11;
+ T13 = I[0];
+ {
+ E Te, TO, Ta, Tv, To, T5, Tw, Tp, Th, Tr, Tk, Ts, Tl, TP, Tc;
+ E Td;
+ Tc = I[WS(is, 8)];
+ Td = I[WS(is, 5)];
+ Te = Tc - Td;
+ TO = Tc + Td;
+ {
+ E T6, T7, T8, T9;
+ T6 = I[WS(is, 1)];
+ T7 = I[WS(is, 3)];
+ T8 = I[WS(is, 9)];
+ T9 = T7 + T8;
+ Ta = T6 + T9;
+ Tv = T7 - T8;
+ To = FNMS(KP500000000, T9, T6);
+ }
+ {
+ E T1, T2, T3, T4;
+ T1 = I[WS(is, 12)];
+ T2 = I[WS(is, 10)];
+ T3 = I[WS(is, 4)];
+ T4 = T2 + T3;
+ T5 = T1 + T4;
+ Tw = T2 - T3;
+ Tp = FNMS(KP500000000, T4, T1);
+ }
+ {
+ E Tf, Tg, Ti, Tj;
+ Tf = I[WS(is, 11)];
+ Tg = I[WS(is, 6)];
+ Th = Tf - Tg;
+ Tr = Tf + Tg;
+ Ti = I[WS(is, 7)];
+ Tj = I[WS(is, 2)];
+ Tk = Ti - Tj;
+ Ts = Ti + Tj;
+ }
+ Tl = Th + Tk;
+ TP = Tr + Ts;
+ Tb = T5 - Ta;
+ Tm = Te + Tl;
+ TW = Ta + T5;
+ TX = TO + TP;
+ T14 = TW + TX;
+ {
+ E TS, TT, Tx, Ty;
+ TS = Tv + Tw;
+ TT = Th - Tk;
+ TU = TS - TT;
+ T10 = TS + TT;
+ Tx = KP866025403 * (Tv - Tw);
+ Ty = FNMS(KP500000000, Tl, Te);
+ Tz = Tx + Ty;
+ TB = Ty - Tx;
+ }
+ {
+ E Tq, Tt, TN, TQ;
+ Tq = To - Tp;
+ Tt = KP866025403 * (Tr - Ts);
+ Tu = Tq - Tt;
+ TC = Tq + Tt;
+ TN = To + Tp;
+ TQ = FNMS(KP500000000, TP, TO);
+ TR = TN - TQ;
+ T11 = TN + TQ;
+ }
+ }
+ ro[0] = T13 + T14;
+ {
+ E Tn, TG, TE, TF, TJ, TM, TK, TL;
+ Tn = FNMS(KP174138601, Tm, KP575140729 * Tb);
+ TG = FMA(KP174138601, Tb, KP575140729 * Tm);
+ {
+ E TA, TD, TH, TI;
+ TA = FNMS(KP156891391, Tz, KP256247671 * Tu);
+ TD = FNMS(KP300238635, TC, KP011599105 * TB);
+ TE = TA + TD;
+ TF = KP1_732050807 * (TD - TA);
+ TH = FMA(KP300238635, TB, KP011599105 * TC);
+ TI = FMA(KP256247671, Tz, KP156891391 * Tu);
+ TJ = TH - TI;
+ TM = KP1_732050807 * (TI + TH);
+ }
+ io[WS(ios, 5)] = FMA(KP2_000000000, TE, Tn);
+ io[WS(ios, 1)] = FMA(KP2_000000000, TJ, TG);
+ TK = TG - TJ;
+ io[WS(ios, 4)] = TF - TK;
+ io[WS(ios, 3)] = TF + TK;
+ TL = Tn - TE;
+ io[WS(ios, 2)] = TL - TM;
+ io[WS(ios, 6)] = TL + TM;
+ }
+ {
+ E TZ, T1b, T19, T1e, T16, T1a, TV, TY, T1c, T1d;
+ TV = FNMS(KP132983124, TU, KP258260390 * TR);
+ TY = KP300462606 * (TW - TX);
+ TZ = FMA(KP2_000000000, TV, TY);
+ T1b = TY - TV;
+ {
+ E T17, T18, T12, T15;
+ T17 = FMA(KP387390585, TU, KP265966249 * TR);
+ T18 = FNMS(KP503537032, T11, KP113854479 * T10);
+ T19 = T17 - T18;
+ T1e = T17 + T18;
+ T12 = FMA(KP251768516, T10, KP075902986 * T11);
+ T15 = FNMS(KP083333333, T14, T13);
+ T16 = FMA(KP2_000000000, T12, T15);
+ T1a = T15 - T12;
+ }
+ ro[WS(ros, 1)] = TZ + T16;
+ ro[WS(ros, 5)] = T16 - TZ;
+ T1c = T1a - T1b;
+ ro[WS(ros, 2)] = T19 + T1c;
+ ro[WS(ros, 6)] = T1c - T19;
+ T1d = T1b + T1a;
+ ro[WS(ros, 3)] = T1d - T1e;
+ ro[WS(ros, 4)] = T1e + T1d;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 13, "r2hc_13", {57, 15, 19, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_13) (planner *p) {
+ X(kr2hc_register) (p, r2hc_13, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_14.c b/src/fftw3/rdft/codelets/r2hc/r2hc_14.c
new file mode 100644
index 0000000..497d84a
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_14.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 14 -name r2hc_14 -include r2hc.h */
+
+/*
+ * This function contains 62 FP additions, 36 FP multiplications,
+ * (or, 38 additions, 12 multiplications, 24 fused multiply/add),
+ * 29 stack variables, and 28 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_14.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_14(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP900968867, +0.900968867902419126236102319507445051165919162);
+ DK(KP222520933, +0.222520933956314404288902564496794759466355569);
+ DK(KP623489801, +0.623489801858733530525004884004239810632274731);
+ DK(KP433883739, +0.433883739117558120475768332848358754609990728);
+ DK(KP974927912, +0.974927912181823607018131682993931217232785801);
+ DK(KP781831482, +0.781831482468029808708444526674057750232334519);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T3, TB, T6, Tv, Tn, Ts, Tk, Tt, Td, Ty, T9, Tw, Tg, Tz, T1;
+ E T2;
+ T1 = I[0];
+ T2 = I[WS(is, 7)];
+ T3 = T1 - T2;
+ TB = T1 + T2;
+ {
+ E T4, T5, Tl, Tm;
+ T4 = I[WS(is, 4)];
+ T5 = I[WS(is, 11)];
+ T6 = T4 - T5;
+ Tv = T4 + T5;
+ Tl = I[WS(is, 12)];
+ Tm = I[WS(is, 5)];
+ Tn = Tl - Tm;
+ Ts = Tl + Tm;
+ }
+ {
+ E Ti, Tj, Tb, Tc;
+ Ti = I[WS(is, 2)];
+ Tj = I[WS(is, 9)];
+ Tk = Ti - Tj;
+ Tt = Ti + Tj;
+ Tb = I[WS(is, 6)];
+ Tc = I[WS(is, 13)];
+ Td = Tb - Tc;
+ Ty = Tb + Tc;
+ }
+ {
+ E T7, T8, Te, Tf;
+ T7 = I[WS(is, 10)];
+ T8 = I[WS(is, 3)];
+ T9 = T7 - T8;
+ Tw = T7 + T8;
+ Te = I[WS(is, 8)];
+ Tf = I[WS(is, 1)];
+ Tg = Te - Tf;
+ Tz = Te + Tf;
+ }
+ {
+ E Tp, Tr, Tq, Ta, To, Th;
+ Tp = Tn - Tk;
+ Tr = Tg - Td;
+ Tq = T9 - T6;
+ io[WS(ios, 1)] = FMA(KP781831482, Tp, KP974927912 * Tq) + (KP433883739 * Tr);
+ io[WS(ios, 5)] = FMA(KP433883739, Tq, KP781831482 * Tr) - (KP974927912 * Tp);
+ io[WS(ios, 3)] = FMA(KP433883739, Tp, KP974927912 * Tr) - (KP781831482 * Tq);
+ Ta = T6 + T9;
+ To = Tk + Tn;
+ Th = Td + Tg;
+ ro[WS(ros, 3)] = FMA(KP623489801, Ta, T3) + FNMA(KP222520933, Th, KP900968867 * To);
+ ro[WS(ros, 7)] = T3 + To + Ta + Th;
+ ro[WS(ros, 1)] = FMA(KP623489801, To, T3) + FNMA(KP900968867, Th, KP222520933 * Ta);
+ ro[WS(ros, 5)] = FMA(KP623489801, Th, T3) + FNMA(KP900968867, Ta, KP222520933 * To);
+ }
+ {
+ E Tu, TA, Tx, TC, TE, TD;
+ Tu = Ts - Tt;
+ TA = Ty - Tz;
+ Tx = Tv - Tw;
+ io[WS(ios, 2)] = FMA(KP974927912, Tu, KP433883739 * Tx) + (KP781831482 * TA);
+ io[WS(ios, 6)] = FMA(KP974927912, Tx, KP433883739 * TA) - (KP781831482 * Tu);
+ io[WS(ios, 4)] = FNMS(KP781831482, Tx, KP974927912 * TA) - (KP433883739 * Tu);
+ TC = Tt + Ts;
+ TE = Tv + Tw;
+ TD = Ty + Tz;
+ ro[WS(ros, 6)] = FMA(KP623489801, TC, TB) + FNMA(KP900968867, TD, KP222520933 * TE);
+ ro[WS(ros, 2)] = FMA(KP623489801, TD, TB) + FNMA(KP900968867, TE, KP222520933 * TC);
+ ro[WS(ros, 4)] = FMA(KP623489801, TE, TB) + FNMA(KP222520933, TD, KP900968867 * TC);
+ ro[0] = TB + TC + TE + TD;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 14, "r2hc_14", {38, 12, 24, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_14) (planner *p) {
+ X(kr2hc_register) (p, r2hc_14, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_15.c b/src/fftw3/rdft/codelets/r2hc/r2hc_15.c
new file mode 100644
index 0000000..71c4aba
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_15.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:42 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 15 -name r2hc_15 -include r2hc.h */
+
+/*
+ * This function contains 64 FP additions, 25 FP multiplications,
+ * (or, 50 additions, 11 multiplications, 14 fused multiply/add),
+ * 47 stack variables, and 30 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_15.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_15(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP484122918, +0.484122918275927110647408174972799951354115213);
+ DK(KP216506350, +0.216506350946109661690930792688234045867850657);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP509036960, +0.509036960455127183450980863393907648510733164);
+ DK(KP823639103, +0.823639103546331925877420039278190003029660514);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E Ti, TR, TL, TD, TE, T7, Te, Tf, TV, TW, TX, Tv, Ty, TH, To;
+ E Tr, TG, TS, TT, TU;
+ {
+ E TJ, Tg, Th, TK;
+ TJ = I[0];
+ Tg = I[WS(is, 10)];
+ Th = I[WS(is, 5)];
+ TK = Th + Tg;
+ Ti = Tg - Th;
+ TR = TJ + TK;
+ TL = FNMS(KP500000000, TK, TJ);
+ }
+ {
+ E Tm, Tt, Tw, Tp, T3, Tx, Ta, Tn, Td, Tq, T6, Tu;
+ Tm = I[WS(is, 3)];
+ Tt = I[WS(is, 6)];
+ Tw = I[WS(is, 9)];
+ Tp = I[WS(is, 12)];
+ {
+ E T1, T2, T8, T9;
+ T1 = I[WS(is, 14)];
+ T2 = I[WS(is, 4)];
+ T3 = T1 - T2;
+ Tx = T1 + T2;
+ T8 = I[WS(is, 13)];
+ T9 = I[WS(is, 8)];
+ Ta = T8 - T9;
+ Tn = T9 + T8;
+ }
+ {
+ E Tb, Tc, T4, T5;
+ Tb = I[WS(is, 7)];
+ Tc = I[WS(is, 2)];
+ Td = Tb - Tc;
+ Tq = Tc + Tb;
+ T4 = I[WS(is, 1)];
+ T5 = I[WS(is, 11)];
+ T6 = T4 - T5;
+ Tu = T5 + T4;
+ }
+ TD = Ta - Td;
+ TE = T6 + T3;
+ T7 = T3 - T6;
+ Te = Ta + Td;
+ Tf = T7 - Te;
+ TV = Tt + Tu;
+ TW = Tw + Tx;
+ TX = TV + TW;
+ Tv = FNMS(KP500000000, Tu, Tt);
+ Ty = FNMS(KP500000000, Tx, Tw);
+ TH = Tv + Ty;
+ To = FNMS(KP500000000, Tn, Tm);
+ Tr = FNMS(KP500000000, Tq, Tp);
+ TG = To + Tr;
+ TS = Tm + Tn;
+ TT = Tp + Tq;
+ TU = TS + TT;
+ }
+ io[WS(ios, 5)] = KP866025403 * (Tf - Ti);
+ {
+ E TF, TP, TI, TM, TN, TQ, TO;
+ TF = FMA(KP823639103, TD, KP509036960 * TE);
+ TP = FNMS(KP509036960, TD, KP823639103 * TE);
+ TI = KP559016994 * (TG - TH);
+ TM = TG + TH;
+ TN = FNMS(KP250000000, TM, TL);
+ ro[WS(ros, 5)] = TL + TM;
+ TQ = TN - TI;
+ ro[WS(ros, 2)] = TP + TQ;
+ ro[WS(ros, 7)] = TQ - TP;
+ TO = TI + TN;
+ ro[WS(ros, 1)] = TF + TO;
+ ro[WS(ros, 4)] = TO - TF;
+ }
+ {
+ E T11, T12, T10, TY, TZ;
+ T11 = TS - TT;
+ T12 = TW - TV;
+ io[WS(ios, 3)] = FMA(KP587785252, T11, KP951056516 * T12);
+ io[WS(ios, 6)] = FNMS(KP951056516, T11, KP587785252 * T12);
+ T10 = KP559016994 * (TU - TX);
+ TY = TU + TX;
+ TZ = FNMS(KP250000000, TY, TR);
+ ro[WS(ros, 3)] = TZ - T10;
+ ro[0] = TR + TY;
+ ro[WS(ros, 6)] = T10 + TZ;
+ {
+ E Tl, TB, TA, TC;
+ {
+ E Tj, Tk, Ts, Tz;
+ Tj = FMA(KP866025403, Ti, KP216506350 * Tf);
+ Tk = KP484122918 * (Te + T7);
+ Tl = Tj + Tk;
+ TB = Tk - Tj;
+ Ts = To - Tr;
+ Tz = Tv - Ty;
+ TA = FMA(KP951056516, Ts, KP587785252 * Tz);
+ TC = FNMS(KP587785252, Ts, KP951056516 * Tz);
+ }
+ io[WS(ios, 1)] = Tl - TA;
+ io[WS(ios, 7)] = TC - TB;
+ io[WS(ios, 4)] = Tl + TA;
+ io[WS(ios, 2)] = TB + TC;
+ }
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 15, "r2hc_15", {50, 11, 14, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_15) (planner *p) {
+ X(kr2hc_register) (p, r2hc_15, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_16.c b/src/fftw3/rdft/codelets/r2hc/r2hc_16.c
new file mode 100644
index 0000000..e28d6d5
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_16.c
@@ -0,0 +1,159 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:43 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 16 -name r2hc_16 -include r2hc.h */
+
+/*
+ * This function contains 58 FP additions, 12 FP multiplications,
+ * (or, 54 additions, 8 multiplications, 4 fused multiply/add),
+ * 34 stack variables, and 32 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_16.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_16(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T3, T6, T7, Tz, Ti, Ta, Td, Te, TA, Th, Tq, TV, TF, TP, Tx;
+ E TU, TE, TM, Tg, Tf, TJ, TQ;
+ {
+ E T1, T2, T4, T5;
+ T1 = I[0];
+ T2 = I[WS(is, 8)];
+ T3 = T1 + T2;
+ T4 = I[WS(is, 4)];
+ T5 = I[WS(is, 12)];
+ T6 = T4 + T5;
+ T7 = T3 + T6;
+ Tz = T1 - T2;
+ Ti = T4 - T5;
+ }
+ {
+ E T8, T9, Tb, Tc;
+ T8 = I[WS(is, 2)];
+ T9 = I[WS(is, 10)];
+ Ta = T8 + T9;
+ Tg = T8 - T9;
+ Tb = I[WS(is, 14)];
+ Tc = I[WS(is, 6)];
+ Td = Tb + Tc;
+ Tf = Tb - Tc;
+ }
+ Te = Ta + Td;
+ TA = KP707106781 * (Tg + Tf);
+ Th = KP707106781 * (Tf - Tg);
+ {
+ E Tm, TN, Tp, TO;
+ {
+ E Tk, Tl, Tn, To;
+ Tk = I[WS(is, 15)];
+ Tl = I[WS(is, 7)];
+ Tm = Tk - Tl;
+ TN = Tk + Tl;
+ Tn = I[WS(is, 3)];
+ To = I[WS(is, 11)];
+ Tp = Tn - To;
+ TO = Tn + To;
+ }
+ Tq = FNMS(KP923879532, Tp, KP382683432 * Tm);
+ TV = TN + TO;
+ TF = FMA(KP923879532, Tm, KP382683432 * Tp);
+ TP = TN - TO;
+ }
+ {
+ E Tt, TK, Tw, TL;
+ {
+ E Tr, Ts, Tu, Tv;
+ Tr = I[WS(is, 1)];
+ Ts = I[WS(is, 9)];
+ Tt = Tr - Ts;
+ TK = Tr + Ts;
+ Tu = I[WS(is, 5)];
+ Tv = I[WS(is, 13)];
+ Tw = Tu - Tv;
+ TL = Tu + Tv;
+ }
+ Tx = FMA(KP382683432, Tt, KP923879532 * Tw);
+ TU = TK + TL;
+ TE = FNMS(KP382683432, Tw, KP923879532 * Tt);
+ TM = TK - TL;
+ }
+ ro[WS(ros, 4)] = T7 - Te;
+ io[WS(ios, 4)] = TV - TU;
+ {
+ E Tj, Ty, TD, TG;
+ Tj = Th - Ti;
+ Ty = Tq - Tx;
+ io[WS(ios, 1)] = Tj + Ty;
+ io[WS(ios, 7)] = Ty - Tj;
+ TD = Tz + TA;
+ TG = TE + TF;
+ ro[WS(ros, 7)] = TD - TG;
+ ro[WS(ros, 1)] = TD + TG;
+ }
+ {
+ E TB, TC, TH, TI;
+ TB = Tz - TA;
+ TC = Tx + Tq;
+ ro[WS(ros, 5)] = TB - TC;
+ ro[WS(ros, 3)] = TB + TC;
+ TH = Ti + Th;
+ TI = TF - TE;
+ io[WS(ios, 3)] = TH + TI;
+ io[WS(ios, 5)] = TI - TH;
+ }
+ TJ = T3 - T6;
+ TQ = KP707106781 * (TM + TP);
+ ro[WS(ros, 6)] = TJ - TQ;
+ ro[WS(ros, 2)] = TJ + TQ;
+ {
+ E TR, TS, TT, TW;
+ TR = Td - Ta;
+ TS = KP707106781 * (TP - TM);
+ io[WS(ios, 2)] = TR + TS;
+ io[WS(ios, 6)] = TS - TR;
+ TT = T7 + Te;
+ TW = TU + TV;
+ ro[WS(ros, 8)] = TT - TW;
+ ro[0] = TT + TW;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 16, "r2hc_16", {54, 8, 4, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_16) (planner *p) {
+ X(kr2hc_register) (p, r2hc_16, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_2.c b/src/fftw3/rdft/codelets/r2hc/r2hc_2.c
new file mode 100644
index 0000000..b0d8450
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_2.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 2 -name r2hc_2 -include r2hc.h */
+
+/*
+ * This function contains 2 FP additions, 0 FP multiplications,
+ * (or, 2 additions, 0 multiplications, 0 fused multiply/add),
+ * 3 stack variables, and 4 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_2.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_2(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2;
+ T1 = I[0];
+ T2 = I[WS(is, 1)];
+ ro[WS(ros, 1)] = T1 - T2;
+ ro[0] = T1 + T2;
+ }
+}
+
+static const kr2hc_desc desc = { 2, "r2hc_2", {2, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_2) (planner *p) {
+ X(kr2hc_register) (p, r2hc_2, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_3.c b/src/fftw3/rdft/codelets/r2hc/r2hc_3.c
new file mode 100644
index 0000000..84041fc
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_3.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 3 -name r2hc_3 -include r2hc.h */
+
+/*
+ * This function contains 4 FP additions, 2 FP multiplications,
+ * (or, 3 additions, 1 multiplications, 1 fused multiply/add),
+ * 7 stack variables, and 6 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_3.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_3(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2, T3, T4;
+ T1 = I[0];
+ T2 = I[WS(is, 1)];
+ T3 = I[WS(is, 2)];
+ T4 = T2 + T3;
+ ro[WS(ros, 1)] = FNMS(KP500000000, T4, T1);
+ io[WS(ios, 1)] = KP866025403 * (T3 - T2);
+ ro[0] = T1 + T4;
+ }
+}
+
+static const kr2hc_desc desc = { 3, "r2hc_3", {3, 1, 1, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_3) (planner *p) {
+ X(kr2hc_register) (p, r2hc_3, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_32.c b/src/fftw3/rdft/codelets/r2hc/r2hc_32.c
new file mode 100644
index 0000000..b3e0a9d
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_32.c
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:44 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 32 -name r2hc_32 -include r2hc.h */
+
+/*
+ * This function contains 156 FP additions, 42 FP multiplications,
+ * (or, 140 additions, 26 multiplications, 16 fused multiply/add),
+ * 54 stack variables, and 64 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_32.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_32(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP555570233, +0.555570233019602224742830813948532874374937191);
+ DK(KP831469612, +0.831469612302545237078788377617905756738560812);
+ DK(KP195090322, +0.195090322016128267848284868477022240927691618);
+ DK(KP980785280, +0.980785280403230449126182236134239036973933731);
+ DK(KP382683432, +0.382683432365089771728459984030398866761344562);
+ DK(KP923879532, +0.923879532511286756128183189396788286822416626);
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T7, T2b, Tv, T1l, Te, T2o, Ty, T1k, Tt, T2d, TF, T1h, Tm, T2c, TC;
+ E T1i, T1Z, T22, T2k, T2j, T1e, T1C, T19, T1B, T1S, T1V, T2h, T2g, TX, T1z;
+ E TS, T1y;
+ {
+ E T1, T2, T3, T4, T5, T6;
+ T1 = I[0];
+ T2 = I[WS(is, 16)];
+ T3 = T1 + T2;
+ T4 = I[WS(is, 8)];
+ T5 = I[WS(is, 24)];
+ T6 = T4 + T5;
+ T7 = T3 + T6;
+ T2b = T3 - T6;
+ Tv = T1 - T2;
+ T1l = T4 - T5;
+ }
+ {
+ E Ta, Tw, Td, Tx;
+ {
+ E T8, T9, Tb, Tc;
+ T8 = I[WS(is, 4)];
+ T9 = I[WS(is, 20)];
+ Ta = T8 + T9;
+ Tw = T8 - T9;
+ Tb = I[WS(is, 28)];
+ Tc = I[WS(is, 12)];
+ Td = Tb + Tc;
+ Tx = Tb - Tc;
+ }
+ Te = Ta + Td;
+ T2o = Td - Ta;
+ Ty = KP707106781 * (Tw + Tx);
+ T1k = KP707106781 * (Tx - Tw);
+ }
+ {
+ E Tp, TD, Ts, TE;
+ {
+ E Tn, To, Tq, Tr;
+ Tn = I[WS(is, 30)];
+ To = I[WS(is, 14)];
+ Tp = Tn + To;
+ TD = Tn - To;
+ Tq = I[WS(is, 6)];
+ Tr = I[WS(is, 22)];
+ Ts = Tq + Tr;
+ TE = Tq - Tr;
+ }
+ Tt = Tp + Ts;
+ T2d = Tp - Ts;
+ TF = FMA(KP923879532, TD, KP382683432 * TE);
+ T1h = FNMS(KP923879532, TE, KP382683432 * TD);
+ }
+ {
+ E Ti, TA, Tl, TB;
+ {
+ E Tg, Th, Tj, Tk;
+ Tg = I[WS(is, 2)];
+ Th = I[WS(is, 18)];
+ Ti = Tg + Th;
+ TA = Tg - Th;
+ Tj = I[WS(is, 10)];
+ Tk = I[WS(is, 26)];
+ Tl = Tj + Tk;
+ TB = Tj - Tk;
+ }
+ Tm = Ti + Tl;
+ T2c = Ti - Tl;
+ TC = FNMS(KP382683432, TB, KP923879532 * TA);
+ T1i = FMA(KP382683432, TA, KP923879532 * TB);
+ }
+ {
+ E T11, T1X, T1d, T1Y, T14, T20, T17, T21, T1a, T18;
+ {
+ E TZ, T10, T1b, T1c;
+ TZ = I[WS(is, 31)];
+ T10 = I[WS(is, 15)];
+ T11 = TZ - T10;
+ T1X = TZ + T10;
+ T1b = I[WS(is, 7)];
+ T1c = I[WS(is, 23)];
+ T1d = T1b - T1c;
+ T1Y = T1b + T1c;
+ }
+ {
+ E T12, T13, T15, T16;
+ T12 = I[WS(is, 3)];
+ T13 = I[WS(is, 19)];
+ T14 = T12 - T13;
+ T20 = T12 + T13;
+ T15 = I[WS(is, 27)];
+ T16 = I[WS(is, 11)];
+ T17 = T15 - T16;
+ T21 = T15 + T16;
+ }
+ T1Z = T1X + T1Y;
+ T22 = T20 + T21;
+ T2k = T21 - T20;
+ T2j = T1X - T1Y;
+ T1a = KP707106781 * (T17 - T14);
+ T1e = T1a - T1d;
+ T1C = T1d + T1a;
+ T18 = KP707106781 * (T14 + T17);
+ T19 = T11 + T18;
+ T1B = T11 - T18;
+ }
+ {
+ E TK, T1Q, TW, T1R, TN, T1T, TQ, T1U, TT, TR;
+ {
+ E TI, TJ, TU, TV;
+ TI = I[WS(is, 1)];
+ TJ = I[WS(is, 17)];
+ TK = TI - TJ;
+ T1Q = TI + TJ;
+ TU = I[WS(is, 9)];
+ TV = I[WS(is, 25)];
+ TW = TU - TV;
+ T1R = TU + TV;
+ }
+ {
+ E TL, TM, TO, TP;
+ TL = I[WS(is, 5)];
+ TM = I[WS(is, 21)];
+ TN = TL - TM;
+ T1T = TL + TM;
+ TO = I[WS(is, 29)];
+ TP = I[WS(is, 13)];
+ TQ = TO - TP;
+ T1U = TO + TP;
+ }
+ T1S = T1Q + T1R;
+ T1V = T1T + T1U;
+ T2h = T1U - T1T;
+ T2g = T1Q - T1R;
+ TT = KP707106781 * (TQ - TN);
+ TX = TT - TW;
+ T1z = TW + TT;
+ TR = KP707106781 * (TN + TQ);
+ TS = TK + TR;
+ T1y = TK - TR;
+ }
+ {
+ E Tf, Tu, T27, T28, T29, T2a;
+ Tf = T7 + Te;
+ Tu = Tm + Tt;
+ T27 = Tf + Tu;
+ T28 = T1S + T1V;
+ T29 = T1Z + T22;
+ T2a = T28 + T29;
+ ro[WS(ros, 8)] = Tf - Tu;
+ io[WS(ios, 8)] = T29 - T28;
+ ro[WS(ros, 16)] = T27 - T2a;
+ ro[0] = T27 + T2a;
+ }
+ {
+ E T1P, T25, T24, T26, T1W, T23;
+ T1P = T7 - Te;
+ T25 = Tt - Tm;
+ T1W = T1S - T1V;
+ T23 = T1Z - T22;
+ T24 = KP707106781 * (T1W + T23);
+ T26 = KP707106781 * (T23 - T1W);
+ ro[WS(ros, 12)] = T1P - T24;
+ io[WS(ios, 12)] = T26 - T25;
+ ro[WS(ros, 4)] = T1P + T24;
+ io[WS(ios, 4)] = T25 + T26;
+ }
+ {
+ E T2f, T2v, T2p, T2r, T2m, T2q, T2u, T2w, T2e, T2n;
+ T2e = KP707106781 * (T2c + T2d);
+ T2f = T2b + T2e;
+ T2v = T2b - T2e;
+ T2n = KP707106781 * (T2d - T2c);
+ T2p = T2n - T2o;
+ T2r = T2o + T2n;
+ {
+ E T2i, T2l, T2s, T2t;
+ T2i = FMA(KP923879532, T2g, KP382683432 * T2h);
+ T2l = FNMS(KP382683432, T2k, KP923879532 * T2j);
+ T2m = T2i + T2l;
+ T2q = T2l - T2i;
+ T2s = FNMS(KP382683432, T2g, KP923879532 * T2h);
+ T2t = FMA(KP382683432, T2j, KP923879532 * T2k);
+ T2u = T2s + T2t;
+ T2w = T2t - T2s;
+ }
+ ro[WS(ros, 14)] = T2f - T2m;
+ io[WS(ios, 14)] = T2u - T2r;
+ ro[WS(ros, 2)] = T2f + T2m;
+ io[WS(ios, 2)] = T2r + T2u;
+ io[WS(ios, 6)] = T2p + T2q;
+ ro[WS(ros, 6)] = T2v + T2w;
+ io[WS(ios, 10)] = T2q - T2p;
+ ro[WS(ros, 10)] = T2v - T2w;
+ }
+ {
+ E TH, T1t, T1s, T1u, T1g, T1o, T1n, T1p;
+ {
+ E Tz, TG, T1q, T1r;
+ Tz = Tv + Ty;
+ TG = TC + TF;
+ TH = Tz + TG;
+ T1t = Tz - TG;
+ T1q = FNMS(KP195090322, TS, KP980785280 * TX);
+ T1r = FMA(KP195090322, T19, KP980785280 * T1e);
+ T1s = T1q + T1r;
+ T1u = T1r - T1q;
+ }
+ {
+ E TY, T1f, T1j, T1m;
+ TY = FMA(KP980785280, TS, KP195090322 * TX);
+ T1f = FNMS(KP195090322, T1e, KP980785280 * T19);
+ T1g = TY + T1f;
+ T1o = T1f - TY;
+ T1j = T1h - T1i;
+ T1m = T1k - T1l;
+ T1n = T1j - T1m;
+ T1p = T1m + T1j;
+ }
+ ro[WS(ros, 15)] = TH - T1g;
+ io[WS(ios, 15)] = T1s - T1p;
+ ro[WS(ros, 1)] = TH + T1g;
+ io[WS(ios, 1)] = T1p + T1s;
+ io[WS(ios, 7)] = T1n + T1o;
+ ro[WS(ros, 7)] = T1t + T1u;
+ io[WS(ios, 9)] = T1o - T1n;
+ ro[WS(ros, 9)] = T1t - T1u;
+ }
+ {
+ E T1x, T1N, T1M, T1O, T1E, T1I, T1H, T1J;
+ {
+ E T1v, T1w, T1K, T1L;
+ T1v = Tv - Ty;
+ T1w = T1i + T1h;
+ T1x = T1v + T1w;
+ T1N = T1v - T1w;
+ T1K = FNMS(KP555570233, T1y, KP831469612 * T1z);
+ T1L = FMA(KP555570233, T1B, KP831469612 * T1C);
+ T1M = T1K + T1L;
+ T1O = T1L - T1K;
+ }
+ {
+ E T1A, T1D, T1F, T1G;
+ T1A = FMA(KP831469612, T1y, KP555570233 * T1z);
+ T1D = FNMS(KP555570233, T1C, KP831469612 * T1B);
+ T1E = T1A + T1D;
+ T1I = T1D - T1A;
+ T1F = TF - TC;
+ T1G = T1l + T1k;
+ T1H = T1F - T1G;
+ T1J = T1G + T1F;
+ }
+ ro[WS(ros, 13)] = T1x - T1E;
+ io[WS(ios, 13)] = T1M - T1J;
+ ro[WS(ros, 3)] = T1x + T1E;
+ io[WS(ios, 3)] = T1J + T1M;
+ io[WS(ios, 5)] = T1H + T1I;
+ ro[WS(ros, 5)] = T1N + T1O;
+ io[WS(ios, 11)] = T1I - T1H;
+ ro[WS(ros, 11)] = T1N - T1O;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 32, "r2hc_32", {140, 26, 16, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_32) (planner *p) {
+ X(kr2hc_register) (p, r2hc_32, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_4.c b/src/fftw3/rdft/codelets/r2hc/r2hc_4.c
new file mode 100644
index 0000000..0ef1567
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_4.c
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 4 -name r2hc_4 -include r2hc.h */
+
+/*
+ * This function contains 6 FP additions, 0 FP multiplications,
+ * (or, 6 additions, 0 multiplications, 0 fused multiply/add),
+ * 7 stack variables, and 8 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_4.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_4(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T2, T3, T4, T5, T6;
+ T1 = I[0];
+ T2 = I[WS(is, 2)];
+ T3 = T1 + T2;
+ T4 = I[WS(is, 1)];
+ T5 = I[WS(is, 3)];
+ T6 = T4 + T5;
+ ro[WS(ros, 1)] = T1 - T2;
+ io[WS(ios, 1)] = T5 - T4;
+ ro[WS(ros, 2)] = T3 - T6;
+ ro[0] = T3 + T6;
+ }
+}
+
+static const kr2hc_desc desc = { 4, "r2hc_4", {6, 0, 0, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_4) (planner *p) {
+ X(kr2hc_register) (p, r2hc_4, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_5.c b/src/fftw3/rdft/codelets/r2hc/r2hc_5.c
new file mode 100644
index 0000000..14f4849
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_5.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 5 -name r2hc_5 -include r2hc.h */
+
+/*
+ * This function contains 12 FP additions, 6 FP multiplications,
+ * (or, 9 additions, 3 multiplications, 3 fused multiply/add),
+ * 17 stack variables, and 10 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_5.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_5(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP250000000, +0.250000000000000000000000000000000000000000000);
+ DK(KP559016994, +0.559016994374947424102293417182819058860154590);
+ DK(KP587785252, +0.587785252292473129168705954639072768597652438);
+ DK(KP951056516, +0.951056516295153572116439333379382143405698634);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E Ta, T7, T8, T3, Tb, T6, T9, Tc;
+ Ta = I[0];
+ {
+ E T1, T2, T4, T5;
+ T1 = I[WS(is, 4)];
+ T2 = I[WS(is, 1)];
+ T7 = T2 + T1;
+ T4 = I[WS(is, 2)];
+ T5 = I[WS(is, 3)];
+ T8 = T4 + T5;
+ T3 = T1 - T2;
+ Tb = T7 + T8;
+ T6 = T4 - T5;
+ }
+ io[WS(ios, 1)] = FNMS(KP587785252, T6, KP951056516 * T3);
+ ro[0] = Ta + Tb;
+ io[WS(ios, 2)] = FMA(KP587785252, T3, KP951056516 * T6);
+ T9 = KP559016994 * (T7 - T8);
+ Tc = FNMS(KP250000000, Tb, Ta);
+ ro[WS(ros, 1)] = T9 + Tc;
+ ro[WS(ros, 2)] = Tc - T9;
+ }
+}
+
+static const kr2hc_desc desc = { 5, "r2hc_5", {9, 3, 3, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_5) (planner *p) {
+ X(kr2hc_register) (p, r2hc_5, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_6.c b/src/fftw3/rdft/codelets/r2hc/r2hc_6.c
new file mode 100644
index 0000000..5fadce3
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_6.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 6 -name r2hc_6 -include r2hc.h */
+
+/*
+ * This function contains 14 FP additions, 4 FP multiplications,
+ * (or, 12 additions, 2 multiplications, 2 fused multiply/add),
+ * 17 stack variables, and 12 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_6.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_6(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T3, Td, T9, Tc, T6, Tb, T1, T2, Ta, Te;
+ T1 = I[0];
+ T2 = I[WS(is, 3)];
+ T3 = T1 - T2;
+ Td = T1 + T2;
+ {
+ E T7, T8, T4, T5;
+ T7 = I[WS(is, 4)];
+ T8 = I[WS(is, 1)];
+ T9 = T7 - T8;
+ Tc = T7 + T8;
+ T4 = I[WS(is, 2)];
+ T5 = I[WS(is, 5)];
+ T6 = T4 - T5;
+ Tb = T4 + T5;
+ }
+ io[WS(ios, 1)] = KP866025403 * (T9 - T6);
+ Ta = T6 + T9;
+ ro[WS(ros, 1)] = FNMS(KP500000000, Ta, T3);
+ ro[WS(ros, 3)] = T3 + Ta;
+ io[WS(ios, 2)] = KP866025403 * (Tb - Tc);
+ Te = Tb + Tc;
+ ro[WS(ros, 2)] = FNMS(KP500000000, Te, Td);
+ ro[0] = Td + Te;
+ }
+}
+
+static const kr2hc_desc desc = { 6, "r2hc_6", {12, 2, 2, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_6) (planner *p) {
+ X(kr2hc_register) (p, r2hc_6, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_7.c b/src/fftw3/rdft/codelets/r2hc/r2hc_7.c
new file mode 100644
index 0000000..8548e93
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_7.c
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 7 -name r2hc_7 -include r2hc.h */
+
+/*
+ * This function contains 24 FP additions, 18 FP multiplications,
+ * (or, 12 additions, 6 multiplications, 12 fused multiply/add),
+ * 20 stack variables, and 14 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_7.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_7(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP222520933, +0.222520933956314404288902564496794759466355569);
+ DK(KP900968867, +0.900968867902419126236102319507445051165919162);
+ DK(KP623489801, +0.623489801858733530525004884004239810632274731);
+ DK(KP433883739, +0.433883739117558120475768332848358754609990728);
+ DK(KP781831482, +0.781831482468029808708444526674057750232334519);
+ DK(KP974927912, +0.974927912181823607018131682993931217232785801);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, Ta, Tb, T4, Td, T7, Tc, T8, T9;
+ T1 = I[0];
+ T8 = I[WS(is, 1)];
+ T9 = I[WS(is, 6)];
+ Ta = T8 + T9;
+ Tb = T9 - T8;
+ {
+ E T2, T3, T5, T6;
+ T2 = I[WS(is, 2)];
+ T3 = I[WS(is, 5)];
+ T4 = T2 + T3;
+ Td = T3 - T2;
+ T5 = I[WS(is, 3)];
+ T6 = I[WS(is, 4)];
+ T7 = T5 + T6;
+ Tc = T6 - T5;
+ }
+ io[WS(ios, 2)] = FNMS(KP781831482, Tc, KP974927912 * Tb) - (KP433883739 * Td);
+ io[WS(ios, 1)] = FMA(KP781831482, Tb, KP974927912 * Td) + (KP433883739 * Tc);
+ ro[WS(ros, 2)] = FMA(KP623489801, T7, T1) + FNMA(KP900968867, T4, KP222520933 * Ta);
+ io[WS(ios, 3)] = FMA(KP433883739, Tb, KP974927912 * Tc) - (KP781831482 * Td);
+ ro[WS(ros, 3)] = FMA(KP623489801, T4, T1) + FNMA(KP222520933, T7, KP900968867 * Ta);
+ ro[WS(ros, 1)] = FMA(KP623489801, Ta, T1) + FNMA(KP900968867, T7, KP222520933 * T4);
+ ro[0] = T1 + Ta + T4 + T7;
+ }
+}
+
+static const kr2hc_desc desc = { 7, "r2hc_7", {12, 6, 12, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_7) (planner *p) {
+ X(kr2hc_register) (p, r2hc_7, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_8.c b/src/fftw3/rdft/codelets/r2hc/r2hc_8.c
new file mode 100644
index 0000000..b502b94
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_8.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:41 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 8 -name r2hc_8 -include r2hc.h */
+
+/*
+ * This function contains 20 FP additions, 2 FP multiplications,
+ * (or, 20 additions, 2 multiplications, 0 fused multiply/add),
+ * 14 stack variables, and 16 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_8.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_8(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP707106781, +0.707106781186547524400844362104849039284835938);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T3, T7, Td, Tj, T6, Tg, Ta, Ti;
+ {
+ E T1, T2, Tb, Tc;
+ T1 = I[0];
+ T2 = I[WS(is, 4)];
+ T3 = T1 + T2;
+ T7 = T1 - T2;
+ Tb = I[WS(is, 7)];
+ Tc = I[WS(is, 3)];
+ Td = Tb - Tc;
+ Tj = Tb + Tc;
+ }
+ {
+ E T4, T5, T8, T9;
+ T4 = I[WS(is, 2)];
+ T5 = I[WS(is, 6)];
+ T6 = T4 + T5;
+ Tg = T4 - T5;
+ T8 = I[WS(is, 1)];
+ T9 = I[WS(is, 5)];
+ Ta = T8 - T9;
+ Ti = T8 + T9;
+ }
+ ro[WS(ros, 2)] = T3 - T6;
+ io[WS(ios, 2)] = Tj - Ti;
+ {
+ E Te, Tf, Th, Tk;
+ Te = KP707106781 * (Ta + Td);
+ ro[WS(ros, 3)] = T7 - Te;
+ ro[WS(ros, 1)] = T7 + Te;
+ Tf = KP707106781 * (Td - Ta);
+ io[WS(ios, 1)] = Tf - Tg;
+ io[WS(ios, 3)] = Tg + Tf;
+ Th = T3 + T6;
+ Tk = Ti + Tj;
+ ro[WS(ros, 4)] = Th - Tk;
+ ro[0] = Th + Tk;
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 8, "r2hc_8", {20, 2, 0, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_8) (planner *p) {
+ X(kr2hc_register) (p, r2hc_8, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/r2hc_9.c b/src/fftw3/rdft/codelets/r2hc/r2hc_9.c
new file mode 100644
index 0000000..df3808f
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/r2hc_9.c
@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2003 Matteo Frigo
+ * Copyright (c) 2003 Massachusetts Institute of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ */
+
+/* This file was automatically generated --- DO NOT EDIT */
+/* Generated on Sat Jul 5 21:56:40 EDT 2003 */
+
+#include "codelet-rdft.h"
+
+/* Generated by: /homee/stevenj/cvs/fftw3.0.1/genfft/gen_r2hc -compact -variables 4 -n 9 -name r2hc_9 -include r2hc.h */
+
+/*
+ * This function contains 38 FP additions, 26 FP multiplications,
+ * (or, 21 additions, 9 multiplications, 17 fused multiply/add),
+ * 36 stack variables, and 18 memory accesses
+ */
+/*
+ * Generator Id's :
+ * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ * $Id: r2hc_9.c,v 1.1 2008/10/17 06:12:34 scuri Exp $
+ */
+
+#include "r2hc.h"
+
+static void r2hc_9(const R *I, R *ro, R *io, stride is, stride ros, stride ios, int v, int ivs, int ovs)
+{
+ DK(KP939692620, +0.939692620785908384054109277324731469936208134);
+ DK(KP296198132, +0.296198132726023843175338011893050938967728390);
+ DK(KP342020143, +0.342020143325668733044099614682259580763083368);
+ DK(KP813797681, +0.813797681349373692844693217248393223289101568);
+ DK(KP984807753, +0.984807753012208059366743024589523013670643252);
+ DK(KP150383733, +0.150383733180435296639271897612501926072238258);
+ DK(KP642787609, +0.642787609686539326322643409907263432907559884);
+ DK(KP663413948, +0.663413948168938396205421319635891297216863310);
+ DK(KP852868531, +0.852868531952443209628250963940074071936020296);
+ DK(KP173648177, +0.173648177666930348851716626769314796000375677);
+ DK(KP556670399, +0.556670399226419366452912952047023132968291906);
+ DK(KP766044443, +0.766044443118978035202392650555416673935832457);
+ DK(KP866025403, +0.866025403784438646763723170752936183471402627);
+ DK(KP500000000, +0.500000000000000000000000000000000000000000000);
+ int i;
+ for (i = v; i > 0; i = i - 1, I = I + ivs, ro = ro + ovs, io = io + ovs) {
+ E T1, T4, Tr, Ta, Tl, Ti, Tf, Tk, Tj, T2, T3, T5, Tg;
+ T1 = I[0];
+ T2 = I[WS(is, 3)];
+ T3 = I[WS(is, 6)];
+ T4 = T2 + T3;
+ Tr = T3 - T2;
+ {
+ E T6, T7, T8, T9;
+ T6 = I[WS(is, 1)];
+ T7 = I[WS(is, 4)];
+ T8 = I[WS(is, 7)];
+ T9 = T7 + T8;
+ Ta = T6 + T9;
+ Tl = T8 - T7;
+ Ti = FNMS(KP500000000, T9, T6);
+ }
+ {
+ E Tb, Tc, Td, Te;
+ Tb = I[WS(is, 2)];
+ Tc = I[WS(is, 5)];
+ Td = I[WS(is, 8)];
+ Te = Tc + Td;
+ Tf = Tb + Te;
+ Tk = FNMS(KP500000000, Te, Tb);
+ Tj = Td - Tc;
+ }
+ io[WS(ios, 3)] = KP866025403 * (Tf - Ta);
+ T5 = T1 + T4;
+ Tg = Ta + Tf;
+ ro[WS(ros, 3)] = FNMS(KP500000000, Tg, T5);
+ ro[0] = T5 + Tg;
+ {
+ E Tt, Th, Tm, Tn, To, Tp, Tq, Ts;
+ Tt = KP866025403 * Tr;
+ Th = FNMS(KP500000000, T4, T1);
+ Tm = FMA(KP766044443, Ti, KP556670399 * Tl);
+ Tn = FMA(KP173648177, Tk, KP852868531 * Tj);
+ To = Tm + Tn;
+ Tp = FNMS(KP642787609, Ti, KP663413948 * Tl);
+ Tq = FNMS(KP984807753, Tk, KP150383733 * Tj);
+ Ts = Tp + Tq;
+ ro[WS(ros, 1)] = Th + To;
+ io[WS(ios, 1)] = Tt + Ts;
+ ro[WS(ros, 4)] = FMA(KP866025403, Tp - Tq, Th) - (KP500000000 * To);
+ io[WS(ios, 4)] = FNMS(KP500000000, Ts, KP866025403 * (Tr + (Tn - Tm)));
+ io[WS(ios, 2)] = FNMS(KP342020143, Tk, KP813797681 * Tj) + FNMA(KP150383733, Tl, KP984807753 * Ti) - Tt;
+ ro[WS(ros, 2)] = FMA(KP173648177, Ti, Th) + FNMA(KP296198132, Tj, KP939692620 * Tk) - (KP852868531 * Tl);
+ }
+ }
+}
+
+static const kr2hc_desc desc = { 9, "r2hc_9", {21, 9, 17, 0}, &GENUS, 0, 0, 0, 0, 0 };
+
+void X(codelet_r2hc_9) (planner *p) {
+ X(kr2hc_register) (p, r2hc_9, &desc);
+}
diff --git a/src/fftw3/rdft/codelets/r2hc/rhcodlist.c b/src/fftw3/rdft/codelets/r2hc/rhcodlist.c
new file mode 100644
index 0000000..a4ac1bc
--- /dev/null
+++ b/src/fftw3/rdft/codelets/r2hc/rhcodlist.c
@@ -0,0 +1,114 @@
+#include "ifftw.h"
+
+extern void X(codelet_r2hc_2)(planner *);
+extern void X(codelet_r2hc_3)(planner *);
+extern void X(codelet_r2hc_4)(planner *);
+extern void X(codelet_r2hc_5)(planner *);
+extern void X(codelet_r2hc_6)(planner *);
+extern void X(codelet_r2hc_7)(planner *);
+extern void X(codelet_r2hc_8)(planner *);
+extern void X(codelet_r2hc_9)(planner *);
+extern void X(codelet_r2hc_10)(planner *);
+extern void X(codelet_r2hc_11)(planner *);
+extern void X(codelet_r2hc_12)(planner *);
+extern void X(codelet_r2hc_13)(planner *);
+extern void X(codelet_r2hc_14)(planner *);
+extern void X(codelet_r2hc_15)(planner *);
+extern void X(codelet_r2hc_16)(planner *);
+extern void X(codelet_r2hc_32)(planner *);
+extern void X(codelet_mr2hc_32)(planner *);
+extern void X(codelet_mr2hc_64)(planner *);
+extern void X(codelet_mr2hc_128)(planner *);
+extern void X(codelet_hf_2)(planner *);
+extern void X(codelet_hf_3)(planner *);
+extern void X(codelet_hf_4)(planner *);
+extern void X(codelet_hf_5)(planner *);
+extern void X(codelet_hf_6)(planner *);
+extern void X(codelet_hf_7)(planner *);
+extern void X(codelet_hf_8)(planner *);
+extern void X(codelet_hf_9)(planner *);
+extern void X(codelet_hf_10)(planner *);
+extern void X(codelet_hf_12)(planner *);
+extern void X(codelet_hf_15)(planner *);
+extern void X(codelet_hf_16)(planner *);
+extern void X(codelet_hf_32)(planner *);
+extern void X(codelet_hf_64)(planner *);
+extern void X(codelet_hf2_4)(planner *);
+extern void X(codelet_hf2_8)(planner *);
+extern void X(codelet_hf2_16)(planner *);
+extern void X(codelet_hf2_32)(planner *);
+extern void X(codelet_hf2_64)(planner *);
+extern void X(codelet_r2hcII_2)(planner *);
+extern void X(codelet_r2hcII_3)(planner *);
+extern void X(codelet_r2hcII_4)(planner *);
+extern void X(codelet_r2hcII_5)(planner *);
+extern void X(codelet_r2hcII_6)(planner *);
+extern void X(codelet_r2hcII_7)(planner *);
+extern void X(codelet_r2hcII_8)(planner *);
+extern void X(codelet_r2hcII_9)(planner *);
+extern void X(codelet_r2hcII_10)(planner *);
+extern void X(codelet_r2hcII_12)(planner *);
+extern void X(codelet_r2hcII_15)(planner *);
+extern void X(codelet_r2hcII_16)(planner *);
+extern void X(codelet_r2hcII_32)(planner *);
+extern void X(codelet_mr2hcII_32)(planner *);
+extern void X(codelet_mr2hcII_64)(planner *);
+
+
+extern const solvtab X(solvtab_rdft_r2hc);
+const solvtab X(solvtab_rdft_r2hc) = {
+ SOLVTAB(X(codelet_r2hc_2)),
+ SOLVTAB(X(codelet_r2hc_3)),
+ SOLVTAB(X(codelet_r2hc_4)),
+ SOLVTAB(X(codelet_r2hc_5)),
+ SOLVTAB(X(codelet_r2hc_6)),
+ SOLVTAB(X(codelet_r2hc_7)),
+ SOLVTAB(X(codelet_r2hc_8)),
+ SOLVTAB(X(codelet_r2hc_9)),
+ SOLVTAB(X(codelet_r2hc_10)),
+ SOLVTAB(X(codelet_r2hc_11)),
+ SOLVTAB(X(codelet_r2hc_12)),
+ SOLVTAB(X(codelet_r2hc_13)),
+ SOLVTAB(X(codelet_r2hc_14)),
+ SOLVTAB(X(codelet_r2hc_15)),
+ SOLVTAB(X(codelet_r2hc_16)),
+ SOLVTAB(X(codelet_r2hc_32)),
+ SOLVTAB(X(codelet_mr2hc_32)),
+ SOLVTAB(X(codelet_mr2hc_64)),
+ SOLVTAB(X(codelet_mr2hc_128)),
+ SOLVTAB(X(codelet_hf_2)),
+ SOLVTAB(X(codelet_hf_3)),
+ SOLVTAB(X(codelet_hf_4)),
+ SOLVTAB(X(codelet_hf_5)),
+ SOLVTAB(X(codelet_hf_6)),
+ SOLVTAB(X(codelet_hf_7)),
+ SOLVTAB(X(codelet_hf_8)),
+ SOLVTAB(X(codelet_hf_9)),
+ SOLVTAB(X(codelet_hf_10)),
+ SOLVTAB(X(codelet_hf_12)),
+ SOLVTAB(X(codelet_hf_15)),
+ SOLVTAB(X(codelet_hf_16)),
+ SOLVTAB(X(codelet_hf_32)),
+ SOLVTAB(X(codelet_hf_64)),
+ SOLVTAB(X(codelet_hf2_4)),
+ SOLVTAB(X(codelet_hf2_8)),
+ SOLVTAB(X(codelet_hf2_16)),
+ SOLVTAB(X(codelet_hf2_32)),
+ SOLVTAB(X(codelet_hf2_64)),
+ SOLVTAB(X(codelet_r2hcII_2)),
+ SOLVTAB(X(codelet_r2hcII_3)),
+ SOLVTAB(X(codelet_r2hcII_4)),
+ SOLVTAB(X(codelet_r2hcII_5)),
+ SOLVTAB(X(codelet_r2hcII_6)),
+ SOLVTAB(X(codelet_r2hcII_7)),
+ SOLVTAB(X(codelet_r2hcII_8)),
+ SOLVTAB(X(codelet_r2hcII_9)),
+ SOLVTAB(X(codelet_r2hcII_10)),
+ SOLVTAB(X(codelet_r2hcII_12)),
+ SOLVTAB(X(codelet_r2hcII_15)),
+ SOLVTAB(X(codelet_r2hcII_16)),
+ SOLVTAB(X(codelet_r2hcII_32)),
+ SOLVTAB(X(codelet_mr2hcII_32)),
+ SOLVTAB(X(codelet_mr2hcII_64)),
+ SOLVTAB_END
+};