自学教程：C++ DVK函数代码示例

static void t1fv_10(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     DVK(KP618033988, +0.618033988749894848204586834365638117720309180);     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 18)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 18), MAKE_VOLATILE_STRIDE(10, rs)) {	       V Td, TA, T4, Ta, Tk, TE, Tp, TF, TB, T9, T1, T2, Tb;	       T1 = LD(&(x[0]), ms, &(x[0]));	       T2 = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));	       {		    V Tg, Tn, Ti, Tl;		    Tg = LD(&(x[WS(rs, 4)]), ms, &(x[0]));		    Tn = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));		    Ti = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));		    Tl = LD(&(x[WS(rs, 6)]), ms, &(x[0]));		    {			 V T6, T8, T5, Tc;			 T5 = LD(&(x[WS(rs, 2)]), ms, &(x[0]));			 Tc = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));			 {			      V T3, Th, To, Tj, Tm, T7;			      T7 = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));			      T3 = BYTWJ(&(W[TWVL * 8]), T2);			      Th = BYTWJ(&(W[TWVL * 6]), Tg);			      To = BYTWJ(&(W[0]), Tn);			      Tj = BYTWJ(&(W[TWVL * 16]), Ti);			      Tm = BYTWJ(&(W[TWVL * 10]), Tl);			      T6 = BYTWJ(&(W[TWVL * 2]), T5);			      Td = BYTWJ(&(W[TWVL * 4]), Tc);			      T8 = BYTWJ(&(W[TWVL * 12]), T7);			      TA = VADD(T1, T3);			      T4 = VSUB(T1, T3);			      Ta = LD(&(x[WS(rs, 8)]), ms, &(x[0]));			      Tk = VSUB(Th, Tj);			      TE = VADD(Th, Tj);			      Tp = VSUB(Tm, To);			      TF = VADD(Tm, To);			 }			 TB = VADD(T6, T8);			 T9 = VSUB(T6, T8);		    }	       }	       Tb = BYTWJ(&(W[TWVL * 14]), Ta);	       {		    V TL, TG, Tw, Tq, TC, Te;		    TL = VSUB(TE, TF);		    TG = VADD(TE, TF);		    Tw = VSUB(Tk, Tp);		    Tq = VADD(Tk, Tp);		    TC = VADD(Tb, Td);		    Te = VSUB(Tb, Td);		    {			 V TM, TD, Tv, Tf;			 TM = VSUB(TB, TC);			 TD = VADD(TB, TC);			 Tv = VSUB(T9, Te);			 Tf = VADD(T9, Te);			 {			      V TP, TN, TH, TJ, Tz, Tx, Tr, Tt, TI, Ts;			      TP = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), TL, TM));			      TN = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), TM, TL));			      TH = VADD(TD, TG);			      TJ = VSUB(TD, TG);			      Tz = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), Tv, Tw));			      Tx = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), Tw, Tv));			      Tr = VADD(Tf, Tq);			      Tt = VSUB(Tf, Tq);			      ST(&(x[0]), VADD(TA, TH), ms, &(x[0]));			      TI = VFNMS(LDK(KP250000000), TH, TA);			      ST(&(x[WS(rs, 5)]), VADD(T4, Tr), ms, &(x[WS(rs, 1)]));			      Ts = VFNMS(LDK(KP250000000), Tr, T4);			      {				   V TK, TO, Tu, Ty;				   TK = VFNMS(LDK(KP559016994), TJ, TI);				   TO = VFMA(LDK(KP559016994), TJ, TI);				   Tu = VFMA(LDK(KP559016994), Tt, Ts);				   Ty = VFNMS(LDK(KP559016994), Tt, Ts);				   ST(&(x[WS(rs, 8)]), VFNMSI(TN, TK), ms, &(x[0]));				   ST(&(x[WS(rs, 2)]), VFMAI(TN, TK), ms, &(x[0]));				   ST(&(x[WS(rs, 6)]), VFNMSI(TP, TO), ms, &(x[0]));				   ST(&(x[WS(rs, 4)]), VFMAI(TP, TO), ms, &(x[0]));				   ST(&(x[WS(rs, 9)]), VFMAI(Tx, Tu), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 1)]), VFNMSI(Tx, Tu), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 7)]), VFMAI(Tz, Ty), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 3)]), VFNMSI(Tz, Ty), ms, &(x[WS(rs, 1)]));			      }			 }		    }	       }	  }     }     VLEAVE();}

static void n2fv_10(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     DVK(KP618033988, +0.618033988749894848204586834365638117720309180);     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     INT i;     const R *xi;     R *xo;     xi = ri;     xo = ro;     for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {	  V Tb, Tr, T3, Ts, T6, Tw, Tg, Tt, T9, Tc, T1, T2;	  T1 = LD(&(xi[0]), ivs, &(xi[0]));	  T2 = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));	  {	       V T4, T5, Te, Tf, T7, T8;	       T4 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));	       T5 = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));	       Te = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));	       Tf = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));	       T7 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));	       T8 = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));	       Tb = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));	       Tr = VADD(T1, T2);	       T3 = VSUB(T1, T2);	       Ts = VADD(T4, T5);	       T6 = VSUB(T4, T5);	       Tw = VADD(Te, Tf);	       Tg = VSUB(Te, Tf);	       Tt = VADD(T7, T8);	       T9 = VSUB(T7, T8);	       Tc = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));	  }	  {	       V TD, Tu, Tm, Ta, Td, Tv;	       TD = VSUB(Ts, Tt);	       Tu = VADD(Ts, Tt);	       Tm = VSUB(T6, T9);	       Ta = VADD(T6, T9);	       Td = VSUB(Tb, Tc);	       Tv = VADD(Tb, Tc);	       {		    V TC, Tx, Tn, Th;		    TC = VSUB(Tv, Tw);		    Tx = VADD(Tv, Tw);		    Tn = VSUB(Td, Tg);		    Th = VADD(Td, Tg);		    {			 V Ty, TA, TE, TG, Ti, Tk, To, Tq;			 Ty = VADD(Tu, Tx);			 TA = VSUB(Tu, Tx);			 TE = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), TD, TC));			 TG = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), TC, TD));			 Ti = VADD(Ta, Th);			 Tk = VSUB(Ta, Th);			 To = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), Tn, Tm));			 Tq = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), Tm, Tn));			 {			      V Tz, TH, Tj, TI;			      Tz = VFNMS(LDK(KP250000000), Ty, Tr);			      TH = VADD(Tr, Ty);			      STM2(&(xo[0]), TH, ovs, &(xo[0]));			      Tj = VFNMS(LDK(KP250000000), Ti, T3);			      TI = VADD(T3, Ti);			      STM2(&(xo[10]), TI, ovs, &(xo[2]));			      {				   V TB, TF, Tl, Tp;				   TB = VFNMS(LDK(KP559016994), TA, Tz);				   TF = VFMA(LDK(KP559016994), TA, Tz);				   Tl = VFMA(LDK(KP559016994), Tk, Tj);				   Tp = VFNMS(LDK(KP559016994), Tk, Tj);				   {					V TJ, TK, TL, TM;					TJ = VFMAI(TG, TF);					STM2(&(xo[8]), TJ, ovs, &(xo[0]));					STN2(&(xo[8]), TJ, TI, ovs);					TK = VFNMSI(TG, TF);					STM2(&(xo[12]), TK, ovs, &(xo[0]));					TL = VFNMSI(TE, TB);					STM2(&(xo[16]), TL, ovs, &(xo[0]));					TM = VFMAI(TE, TB);					STM2(&(xo[4]), TM, ovs, &(xo[0]));					{					     V TN, TO, TP, TQ;					     TN = VFNMSI(Tq, Tp);					     STM2(&(xo[6]), TN, ovs, &(xo[2]));					     STN2(&(xo[4]), TM, TN, ovs);					     TO = VFMAI(Tq, Tp);					     STM2(&(xo[14]), TO, ovs, &(xo[2]));					     STN2(&(xo[12]), TK, TO, ovs);					     TP = VFMAI(To, Tl);					     STM2(&(xo[18]), TP, ovs, &(xo[2]));					     STN2(&(xo[16]), TL, TP, ovs);					     TQ = VFNMSI(To, Tl);					     STM2(&(xo[2]), TQ, ovs, &(xo[2]));					     STN2(&(xo[0]), TH, TQ, ovs);					}				   }			      }//.........这里部分代码省略.........

static void t1bv_12(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     {	  INT m;	  R *x;	  x = ii;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 22)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 22), MAKE_VOLATILE_STRIDE(12, rs)) {	       V TI, Ti, TA, T7, Tm, TE, Tw, Tk, Tf, TB, TU, TM;	       {		    V T9, TK, Tj, TL, Te;		    {			 V T1, T4, T2, Tp, Tt, Tr;			 T1 = LD(&(x[0]), ms, &(x[0]));			 T4 = LD(&(x[WS(rs, 8)]), ms, &(x[0]));			 T2 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));			 Tp = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));			 Tt = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));			 Tr = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));			 {			      V T5, T3, Tq, Tu, Ts, Td, Tb, T8, Tc, Ta;			      T8 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));			      Tc = LD(&(x[WS(rs, 2)]), ms, &(x[0]));			      Ta = LD(&(x[WS(rs, 10)]), ms, &(x[0]));			      T5 = BYTW(&(W[TWVL * 14]), T4);			      T3 = BYTW(&(W[TWVL * 6]), T2);			      Tq = BYTW(&(W[TWVL * 16]), Tp);			      Tu = BYTW(&(W[TWVL * 8]), Tt);			      Ts = BYTW(&(W[0]), Tr);			      T9 = BYTW(&(W[TWVL * 10]), T8);			      Td = BYTW(&(W[TWVL * 2]), Tc);			      Tb = BYTW(&(W[TWVL * 18]), Ta);			      {				   V Th, T6, Tl, Tv;				   Th = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));				   TK = VSUB(T3, T5);				   T6 = VADD(T3, T5);				   Tl = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));				   Tv = VADD(Ts, Tu);				   TI = VSUB(Tu, Ts);				   Tj = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));				   TL = VSUB(Tb, Td);				   Te = VADD(Tb, Td);				   Ti = BYTW(&(W[TWVL * 4]), Th);				   TA = VFNMS(LDK(KP500000000), T6, T1);				   T7 = VADD(T1, T6);				   Tm = BYTW(&(W[TWVL * 20]), Tl);				   TE = VFNMS(LDK(KP500000000), Tv, Tq);				   Tw = VADD(Tq, Tv);			      }			 }		    }		    Tk = BYTW(&(W[TWVL * 12]), Tj);		    Tf = VADD(T9, Te);		    TB = VFNMS(LDK(KP500000000), Te, T9);		    TU = VSUB(TK, TL);		    TM = VADD(TK, TL);	       }	       {		    V Tn, TH, TC, TQ, Ty, Tg;		    Tn = VADD(Tk, Tm);		    TH = VSUB(Tk, Tm);		    TC = VADD(TA, TB);		    TQ = VSUB(TA, TB);		    Ty = VADD(T7, Tf);		    Tg = VSUB(T7, Tf);		    {			 V To, TD, TJ, TR;			 To = VADD(Ti, Tn);			 TD = VFNMS(LDK(KP500000000), Tn, Ti);			 TJ = VSUB(TH, TI);			 TR = VADD(TH, TI);			 {			      V TP, TN, TW, TS, TO, TG, TX, TV;			      {				   V Tz, Tx, TF, TT;				   Tz = VADD(To, Tw);				   Tx = VSUB(To, Tw);				   TF = VADD(TD, TE);				   TT = VSUB(TD, TE);				   TP = VMUL(LDK(KP866025403), VADD(TM, TJ));				   TN = VMUL(LDK(KP866025403), VSUB(TJ, TM));				   TW = VFMA(LDK(KP866025403), TR, TQ);				   TS = VFNMS(LDK(KP866025403), TR, TQ);				   ST(&(x[WS(rs, 6)]), VSUB(Ty, Tz), ms, &(x[0]));				   ST(&(x[0]), VADD(Ty, Tz), ms, &(x[0]));				   ST(&(x[WS(rs, 9)]), VFMAI(Tx, Tg), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 3)]), VFNMSI(Tx, Tg), ms, &(x[WS(rs, 1)]));				   TO = VADD(TC, TF);				   TG = VSUB(TC, TF);				   TX = VFNMS(LDK(KP866025403), TU, TT);				   TV = VFMA(LDK(KP866025403), TU, TT);			      }			      ST(&(x[WS(rs, 8)]), VFNMSI(TP, TO), ms, &(x[0]));			      ST(&(x[WS(rs, 4)]), VFMAI(TP, TO), ms, &(x[0]));			      ST(&(x[WS(rs, 2)]), VFMAI(TN, TG), ms, &(x[0]));			      ST(&(x[WS(rs, 10)]), VFNMSI(TN, TG), ms, &(x[0]));			      ST(&(x[WS(rs, 5)]), VFMAI(TX, TW), ms, &(x[WS(rs, 1)]));			      ST(&(x[WS(rs, 7)]), VFNMSI(TX, TW), ms, &(x[WS(rs, 1)]));//.........这里部分代码省略.........

static void n1bv_7(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP900968867, +0.900968867902419126236102319507445051165919162);     DVK(KP692021471, +0.692021471630095869627814897002069140197260599);     DVK(KP801937735, +0.801937735804838252472204639014890102331838324);     DVK(KP974927912, +0.974927912181823607018131682993931217232785801);     DVK(KP356895867, +0.356895867892209443894399510021300583399127187);     DVK(KP554958132, +0.554958132087371191422194871006410481067288862);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ii;	  xo = io;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {	       V T1, T2, T3, T8, T9, T5, T6;	       T1 = LD(&(xi[0]), ivs, &(xi[0]));	       T2 = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));	       T3 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));	       T8 = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));	       T9 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));	       T5 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));	       T6 = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));	       {		    V Tg, T4, Te, Ta, Tf, T7;		    Tg = VSUB(T2, T3);		    T4 = VADD(T2, T3);		    Te = VSUB(T8, T9);		    Ta = VADD(T8, T9);		    Tf = VSUB(T5, T6);		    T7 = VADD(T5, T6);		    {			 V Tr, Tj, Tm, Th, To, Tb;			 Tr = VFMA(LDK(KP554958132), Te, Tg);			 Tj = VFNMS(LDK(KP356895867), T4, Ta);			 Tm = VFMA(LDK(KP554958132), Tf, Te);			 Th = VFNMS(LDK(KP554958132), Tg, Tf);			 ST(&(xo[0]), VADD(T1, VADD(T4, VADD(T7, Ta))), ovs, &(xo[0]));			 To = VFNMS(LDK(KP356895867), T7, T4);			 Tb = VFNMS(LDK(KP356895867), Ta, T7);			 {			      V Ts, Tk, Tn, Ti;			      Ts = VMUL(LDK(KP974927912), VFMA(LDK(KP801937735), Tr, Tf));			      Tk = VFNMS(LDK(KP692021471), Tj, T7);			      Tn = VMUL(LDK(KP974927912), VFNMS(LDK(KP801937735), Tm, Tg));			      Ti = VMUL(LDK(KP974927912), VFNMS(LDK(KP801937735), Th, Te));			      {				   V Tp, Tc, Tl, Tq, Td;				   Tp = VFNMS(LDK(KP692021471), To, Ta);				   Tc = VFNMS(LDK(KP692021471), Tb, T4);				   Tl = VFNMS(LDK(KP900968867), Tk, T1);				   Tq = VFNMS(LDK(KP900968867), Tp, T1);				   Td = VFNMS(LDK(KP900968867), Tc, T1);				   ST(&(xo[WS(os, 5)]), VFNMSI(Tn, Tl), ovs, &(xo[WS(os, 1)]));				   ST(&(xo[WS(os, 2)]), VFMAI(Tn, Tl), ovs, &(xo[0]));				   ST(&(xo[WS(os, 6)]), VFNMSI(Ts, Tq), ovs, &(xo[0]));				   ST(&(xo[WS(os, 1)]), VFMAI(Ts, Tq), ovs, &(xo[WS(os, 1)]));				   ST(&(xo[WS(os, 4)]), VFNMSI(Ti, Td), ovs, &(xo[0]));				   ST(&(xo[WS(os, 3)]), VFMAI(Ti, Td), ovs, &(xo[WS(os, 1)]));			      }			 }		    }	       }	  }     }     VLEAVE();}

static void t1fv_9(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP939692620, +0.939692620785908384054109277324731469936208134);     DVK(KP826351822, +0.826351822333069651148283373230685203999624323);     DVK(KP879385241, +0.879385241571816768108218554649462939872416269);     DVK(KP984807753, +0.984807753012208059366743024589523013670643252);     DVK(KP666666666, +0.666666666666666666666666666666666666666666667);     DVK(KP852868531, +0.852868531952443209628250963940074071936020296);     DVK(KP907603734, +0.907603734547952313649323976213898122064543220);     DVK(KP420276625, +0.420276625461206169731530603237061658838781920);     DVK(KP673648177, +0.673648177666930348851716626769314796000375677);     DVK(KP898197570, +0.898197570222573798468955502359086394667167570);     DVK(KP347296355, +0.347296355333860697703433253538629592000751354);     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     DVK(KP439692620, +0.439692620785908384054109277324731469936208134);     DVK(KP203604859, +0.203604859554852403062088995281827210665664861);     DVK(KP152703644, +0.152703644666139302296566746461370407999248646);     DVK(KP586256827, +0.586256827714544512072145703099641959914944179);     DVK(KP968908795, +0.968908795874236621082202410917456709164223497);     DVK(KP726681596, +0.726681596905677465811651808188092531873167623);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 16)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 16), MAKE_VOLATILE_STRIDE(9, rs)) {	       V T1, T3, T5, T9, Th, Tb, Td, Tj, Tl, TD, T6;	       T1 = LD(&(x[0]), ms, &(x[0]));	       {		    V T2, T4, T8, Tg;		    T2 = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));		    T4 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));		    T8 = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));		    Tg = LD(&(x[WS(rs, 2)]), ms, &(x[0]));		    {			 V Ta, Tc, Ti, Tk;			 Ta = LD(&(x[WS(rs, 4)]), ms, &(x[0]));			 Tc = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));			 Ti = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));			 Tk = LD(&(x[WS(rs, 8)]), ms, &(x[0]));			 T3 = BYTWJ(&(W[TWVL * 4]), T2);			 T5 = BYTWJ(&(W[TWVL * 10]), T4);			 T9 = BYTWJ(&(W[0]), T8);			 Th = BYTWJ(&(W[TWVL * 2]), Tg);			 Tb = BYTWJ(&(W[TWVL * 6]), Ta);			 Td = BYTWJ(&(W[TWVL * 12]), Tc);			 Tj = BYTWJ(&(W[TWVL * 8]), Ti);			 Tl = BYTWJ(&(W[TWVL * 14]), Tk);		    }	       }	       TD = VSUB(T5, T3);	       T6 = VADD(T3, T5);	       {		    V Tt, Te, Tu, Tm, Tr, T7;		    Tt = VSUB(Tb, Td);		    Te = VADD(Tb, Td);		    Tu = VSUB(Tl, Tj);		    Tm = VADD(Tj, Tl);		    Tr = VFNMS(LDK(KP500000000), T6, T1);		    T7 = VADD(T1, T6);		    {			 V Tv, Tf, Ts, Tn;			 Tv = VFNMS(LDK(KP500000000), Te, T9);			 Tf = VADD(T9, Te);			 Ts = VFNMS(LDK(KP500000000), Tm, Th);			 Tn = VADD(Th, Tm);			 {			      V TG, TK, Tw, TJ, TF, TA, To, Tq;			      TG = VFNMS(LDK(KP726681596), Tt, Tv);			      TK = VFMA(LDK(KP968908795), Tv, Tt);			      Tw = VFNMS(LDK(KP586256827), Tv, Tu);			      TJ = VFNMS(LDK(KP152703644), Tu, Ts);			      TF = VFMA(LDK(KP203604859), Ts, Tu);			      TA = VFNMS(LDK(KP439692620), Tt, Ts);			      To = VADD(Tf, Tn);			      Tq = VMUL(LDK(KP866025403), VSUB(Tn, Tf));			      {				   V TQ, TH, TL, TN, TB, Tp, Ty, TI, Tx;				   Tx = VFNMS(LDK(KP347296355), Tw, Tt);				   TQ = VFNMS(LDK(KP898197570), TG, TF);				   TH = VFMA(LDK(KP898197570), TG, TF);				   TL = VFMA(LDK(KP673648177), TK, TJ);				   TN = VFNMS(LDK(KP673648177), TK, TJ);				   TB = VFNMS(LDK(KP420276625), TA, Tu);				   ST(&(x[0]), VADD(T7, To), ms, &(x[0]));				   Tp = VFNMS(LDK(KP500000000), To, T7);				   Ty = VFNMS(LDK(KP907603734), Tx, Ts);				   TI = VFMA(LDK(KP852868531), TH, Tr);				   {					V TO, TR, TM, TC, Tz, TP, TS, TE;					TO = VFNMS(LDK(KP500000000), TH, TN);					TR = VFMA(LDK(KP666666666), TL, TQ);					TM = VMUL(LDK(KP984807753), VFNMS(LDK(KP879385241), TD, TL));					TC = VFNMS(LDK(KP826351822), TB, Tv);					ST(&(x[WS(rs, 6)]), VFNMSI(Tq, Tp), ms, &(x[0]));					ST(&(x[WS(rs, 3)]), VFMAI(Tq, Tp), ms, &(x[WS(rs, 1)]));					Tz = VFNMS(LDK(KP939692620), Ty, Tr);					TP = VFMA(LDK(KP852868531), TO, Tr);					TS = VMUL(LDK(KP866025403), VFMA(LDK(KP852868531), TR, TD));					ST(&(x[WS(rs, 8)]), VFMAI(TM, TI), ms, &(x[0]));//.........这里部分代码省略.........

static void m2fv_32_0(const R *xi, R *xo, stride is, int ivs, int ovs){     DVK(KP195090322, +0.195090322016128267848284868477022240927691618);     DVK(KP980785280, +0.980785280403230449126182236134239036973933731);     DVK(KP555570233, +0.555570233019602224742830813948532874374937191);     DVK(KP831469612, +0.831469612302545237078788377617905756738560812);     DVK(KP382683432, +0.382683432365089771728459984030398866761344562);     DVK(KP923879532, +0.923879532511286756128183189396788286822416626);     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     {	  V T1T, T1W, T2K, T2x, T16, T1A, Tb, T1p, TT, T1v, TY, T1w, T27, T2a, T2b;	  V T2H, T2O, TC, T1s, TH, T1t, T20, T23, T24, T2E, T2N, T2g, T2j, Tq, T1B;	  V T19, T1q, T2A, T2L;	  {	       V T3, T1R, T15, T1S, T6, T1U, T9, T1V, T12, Ta;	       {		    V T1, T2, T13, T14;		    T1 = LD(&(xi[0]), ivs, &(xi[0]));		    T2 = LD(&(xi[WS(is, 16)]), ivs, &(xi[0]));		    T3 = VSUB(T1, T2);		    T1R = VADD(T1, T2);		    T13 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));		    T14 = LD(&(xi[WS(is, 24)]), ivs, &(xi[0]));		    T15 = VSUB(T13, T14);		    T1S = VADD(T13, T14);	       }	       {		    V T4, T5, T7, T8;		    T4 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));		    T5 = LD(&(xi[WS(is, 20)]), ivs, &(xi[0]));		    T6 = VSUB(T4, T5);		    T1U = VADD(T4, T5);		    T7 = LD(&(xi[WS(is, 28)]), ivs, &(xi[0]));		    T8 = LD(&(xi[WS(is, 12)]), ivs, &(xi[0]));		    T9 = VSUB(T7, T8);		    T1V = VADD(T7, T8);	       }	       T1T = VADD(T1R, T1S);	       T1W = VADD(T1U, T1V);	       T2K = VSUB(T1V, T1U);	       T2x = VSUB(T1R, T1S);	       T12 = VMUL(LDK(KP707106781), VSUB(T9, T6));	       T16 = VSUB(T12, T15);	       T1A = VADD(T15, T12);	       Ta = VMUL(LDK(KP707106781), VADD(T6, T9));	       Tb = VADD(T3, Ta);	       T1p = VSUB(T3, Ta);	  }	  {	       V TL, T25, TX, T26, TO, T28, TR, T29;	       {		    V TJ, TK, TV, TW;		    TJ = LD(&(xi[WS(is, 31)]), ivs, &(xi[WS(is, 1)]));		    TK = LD(&(xi[WS(is, 15)]), ivs, &(xi[WS(is, 1)]));		    TL = VSUB(TJ, TK);		    T25 = VADD(TJ, TK);		    TV = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));		    TW = LD(&(xi[WS(is, 23)]), ivs, &(xi[WS(is, 1)]));		    TX = VSUB(TV, TW);		    T26 = VADD(TV, TW);	       }	       {		    V TM, TN, TP, TQ;		    TM = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));		    TN = LD(&(xi[WS(is, 19)]), ivs, &(xi[WS(is, 1)]));		    TO = VSUB(TM, TN);		    T28 = VADD(TM, TN);		    TP = LD(&(xi[WS(is, 27)]), ivs, &(xi[WS(is, 1)]));		    TQ = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));		    TR = VSUB(TP, TQ);		    T29 = VADD(TP, TQ);	       }	       {		    V TS, TU, T2F, T2G;		    TS = VMUL(LDK(KP707106781), VADD(TO, TR));		    TT = VADD(TL, TS);		    T1v = VSUB(TL, TS);		    TU = VMUL(LDK(KP707106781), VSUB(TR, TO));		    TY = VSUB(TU, TX);		    T1w = VADD(TX, TU);		    T27 = VADD(T25, T26);		    T2a = VADD(T28, T29);		    T2b = VSUB(T27, T2a);		    T2F = VSUB(T25, T26);		    T2G = VSUB(T29, T28);		    T2H = VFNMS(LDK(KP382683432), T2G, VMUL(LDK(KP923879532), T2F));		    T2O = VFMA(LDK(KP382683432), T2F, VMUL(LDK(KP923879532), T2G));	       }	  }	  {	       V Tu, T1Y, TG, T1Z, Tx, T21, TA, T22;	       {		    V Ts, Tt, TE, TF;		    Ts = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));		    Tt = LD(&(xi[WS(is, 17)]), ivs, &(xi[WS(is, 1)]));		    Tu = VSUB(Ts, Tt);		    T1Y = VADD(Ts, Tt);		    TE = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));		    TF = LD(&(xi[WS(is, 25)]), ivs, &(xi[WS(is, 1)]));		    TG = VSUB(TE, TF);//.........这里部分代码省略.........

static void t1fuv_7(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP900968867, +0.900968867902419126236102319507445051165919162);     DVK(KP222520933, +0.222520933956314404288902564496794759466355569);     DVK(KP623489801, +0.623489801858733530525004884004239810632274731);     DVK(KP781831482, +0.781831482468029808708444526674057750232334519);     DVK(KP974927912, +0.974927912181823607018131682993931217232785801);     DVK(KP433883739, +0.433883739117558120475768332848358754609990728);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 12)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 12), MAKE_VOLATILE_STRIDE(rs)) {	       V T1, Tg, Tj, T6, Ti, Tb, Tk, Tp, To;	       T1 = LD(&(x[0]), ms, &(x[0]));	       {		    V Td, Tf, Tc, Te;		    Tc = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));		    Td = BYTWJ(&(W[TWVL * 4]), Tc);		    Te = LD(&(x[WS(rs, 4)]), ms, &(x[0]));		    Tf = BYTWJ(&(W[TWVL * 6]), Te);		    Tg = VADD(Td, Tf);		    Tj = VSUB(Tf, Td);	       }	       {		    V T3, T5, T2, T4;		    T2 = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));		    T3 = BYTWJ(&(W[0]), T2);		    T4 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));		    T5 = BYTWJ(&(W[TWVL * 10]), T4);		    T6 = VADD(T3, T5);		    Ti = VSUB(T5, T3);	       }	       {		    V T8, Ta, T7, T9;		    T7 = LD(&(x[WS(rs, 2)]), ms, &(x[0]));		    T8 = BYTWJ(&(W[TWVL * 2]), T7);		    T9 = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));		    Ta = BYTWJ(&(W[TWVL * 8]), T9);		    Tb = VADD(T8, Ta);		    Tk = VSUB(Ta, T8);	       }	       ST(&(x[0]), VADD(T1, VADD(T6, VADD(Tb, Tg))), ms, &(x[0]));	       Tp = VBYI(VFMA(LDK(KP433883739), Ti, VFNMS(LDK(KP781831482), Tk, VMUL(LDK(KP974927912), Tj))));	       To = VFMA(LDK(KP623489801), Tb, VFNMS(LDK(KP222520933), Tg, VFNMS(LDK(KP900968867), T6, T1)));	       ST(&(x[WS(rs, 4)]), VSUB(To, Tp), ms, &(x[0]));	       ST(&(x[WS(rs, 3)]), VADD(To, Tp), ms, &(x[WS(rs, 1)]));	       {		    V Tl, Th, Tn, Tm;		    Tl = VBYI(VFNMS(LDK(KP781831482), Tj, VFNMS(LDK(KP433883739), Tk, VMUL(LDK(KP974927912), Ti))));		    Th = VFMA(LDK(KP623489801), Tg, VFNMS(LDK(KP900968867), Tb, VFNMS(LDK(KP222520933), T6, T1)));		    ST(&(x[WS(rs, 5)]), VSUB(Th, Tl), ms, &(x[WS(rs, 1)]));		    ST(&(x[WS(rs, 2)]), VADD(Th, Tl), ms, &(x[0]));		    Tn = VBYI(VFMA(LDK(KP781831482), Ti, VFMA(LDK(KP974927912), Tk, VMUL(LDK(KP433883739), Tj))));		    Tm = VFMA(LDK(KP623489801), T6, VFNMS(LDK(KP900968867), Tg, VFNMS(LDK(KP222520933), Tb, T1)));		    ST(&(x[WS(rs, 6)]), VSUB(Tm, Tn), ms, &(x[0]));		    ST(&(x[WS(rs, 1)]), VADD(Tm, Tn), ms, &(x[WS(rs, 1)]));	       }	  }     }     VLEAVE();}

static void n2fv_12(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ri;	  xo = ro;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(24, is), MAKE_VOLATILE_STRIDE(24, os)) {	       V T1, T6, Tk, Tn, Tc, Td, Tf, Tr, T4, Ts, T9, Tg, Te, Tl;	       {		    V T2, T3, T7, T8;		    T1 = LD(&(xi[0]), ivs, &(xi[0]));		    T6 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));		    T2 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));		    T3 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));		    T7 = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));		    T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));		    Tk = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));		    Tn = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));		    Tc = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));		    Td = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));		    Tf = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));		    Tr = VSUB(T3, T2);		    T4 = VADD(T2, T3);		    Ts = VSUB(T8, T7);		    T9 = VADD(T7, T8);		    Tg = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));	       }	       Te = VSUB(Tc, Td);	       Tl = VADD(Td, Tc);	       {		    V T5, TF, TB, Tt, Ta, TG, Th, To, Tm, TI;		    T5 = VFNMS(LDK(KP500000000), T4, T1);		    TF = VADD(T1, T4);		    TB = VADD(Tr, Ts);		    Tt = VSUB(Tr, Ts);		    Ta = VFNMS(LDK(KP500000000), T9, T6);		    TG = VADD(T6, T9);		    Th = VSUB(Tf, Tg);		    To = VADD(Tf, Tg);		    Tm = VFNMS(LDK(KP500000000), Tl, Tk);		    TI = VADD(Tk, Tl);		    {			 V TH, TL, Tb, Tx, TJ, Tp, Ti, TA;			 TH = VSUB(TF, TG);			 TL = VADD(TF, TG);			 Tb = VSUB(T5, Ta);			 Tx = VADD(T5, Ta);			 TJ = VADD(Tn, To);			 Tp = VFNMS(LDK(KP500000000), To, Tn);			 Ti = VADD(Te, Th);			 TA = VSUB(Te, Th);			 {			      V Tq, Ty, TK, TM;			      Tq = VSUB(Tm, Tp);			      Ty = VADD(Tm, Tp);			      TK = VSUB(TI, TJ);			      TM = VADD(TI, TJ);			      {				   V TC, TE, Tj, Tv;				   TC = VMUL(LDK(KP866025403), VSUB(TA, TB));				   TE = VMUL(LDK(KP866025403), VADD(TB, TA));				   Tj = VFMA(LDK(KP866025403), Ti, Tb);				   Tv = VFNMS(LDK(KP866025403), Ti, Tb);				   {					V Tz, TD, Tu, Tw;					Tz = VSUB(Tx, Ty);					TD = VADD(Tx, Ty);					Tu = VFNMS(LDK(KP866025403), Tt, Tq);					Tw = VFMA(LDK(KP866025403), Tt, Tq);					{					     V TN, TO, TP, TQ;					     TN = VADD(TL, TM);					     STM2(&(xo[0]), TN, ovs, &(xo[0]));					     TO = VSUB(TL, TM);					     STM2(&(xo[12]), TO, ovs, &(xo[0]));					     TP = VFMAI(TK, TH);					     STM2(&(xo[6]), TP, ovs, &(xo[2]));					     TQ = VFNMSI(TK, TH);					     STM2(&(xo[18]), TQ, ovs, &(xo[2]));					     {						  V TR, TS, TT, TU;						  TR = VFMAI(TE, TD);						  STM2(&(xo[8]), TR, ovs, &(xo[0]));						  TS = VFNMSI(TE, TD);						  STM2(&(xo[16]), TS, ovs, &(xo[0]));						  STN2(&(xo[16]), TS, TQ, ovs);						  TT = VFNMSI(TC, Tz);						  STM2(&(xo[20]), TT, ovs, &(xo[0]));						  TU = VFMAI(TC, Tz);						  STM2(&(xo[4]), TU, ovs, &(xo[0]));						  STN2(&(xo[4]), TU, TP, ovs);						  {						       V TV, TW, TX, TY;						       TV = VFNMSI(Tw, Tv);						       STM2(&(xo[10]), TV, ovs, &(xo[2]));						       STN2(&(xo[8]), TR, TV, ovs);//.........这里部分代码省略.........

static void n2bv_20(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP587785252, +0.587785252292473129168705954639072768597652438);     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ii;	  xo = io;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {	       V T3, T1y, TH, T1i, Ts, TL, TM, Tz, T13, T16, T1j, T1u, T1v, T1w, T1r;	       V T1s, T1t, T1a, T1d, T1k, Ti, Tk, TE, TI;	       {		    V T1, T2, T1g, TF, TG, T1h;		    T1 = LD(&(xi[0]), ivs, &(xi[0]));		    T2 = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));		    T1g = VADD(T1, T2);		    TF = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));		    TG = LD(&(xi[WS(is, 15)]), ivs, &(xi[WS(is, 1)]));		    T1h = VADD(TF, TG);		    T3 = VSUB(T1, T2);		    T1y = VADD(T1g, T1h);		    TH = VSUB(TF, TG);		    T1i = VSUB(T1g, T1h);	       }	       {		    V T6, T11, Tv, T19, Ty, T1c, T9, T14, Td, T18, To, T12, Tr, T15, Tg;		    V T1b;		    {			 V T4, T5, Tt, Tu;			 T4 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));			 T5 = LD(&(xi[WS(is, 14)]), ivs, &(xi[0]));			 T6 = VSUB(T4, T5);			 T11 = VADD(T4, T5);			 Tt = LD(&(xi[WS(is, 13)]), ivs, &(xi[WS(is, 1)]));			 Tu = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));			 Tv = VSUB(Tt, Tu);			 T19 = VADD(Tt, Tu);		    }		    {			 V Tw, Tx, T7, T8;			 Tw = LD(&(xi[WS(is, 17)]), ivs, &(xi[WS(is, 1)]));			 Tx = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));			 Ty = VSUB(Tw, Tx);			 T1c = VADD(Tw, Tx);			 T7 = LD(&(xi[WS(is, 16)]), ivs, &(xi[0]));			 T8 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));			 T9 = VSUB(T7, T8);			 T14 = VADD(T7, T8);		    }		    {			 V Tb, Tc, Tm, Tn;			 Tb = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));			 Tc = LD(&(xi[WS(is, 18)]), ivs, &(xi[0]));			 Td = VSUB(Tb, Tc);			 T18 = VADD(Tb, Tc);			 Tm = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));			 Tn = LD(&(xi[WS(is, 19)]), ivs, &(xi[WS(is, 1)]));			 To = VSUB(Tm, Tn);			 T12 = VADD(Tm, Tn);		    }		    {			 V Tp, Tq, Te, Tf;			 Tp = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));			 Tq = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));			 Tr = VSUB(Tp, Tq);			 T15 = VADD(Tp, Tq);			 Te = LD(&(xi[WS(is, 12)]), ivs, &(xi[0]));			 Tf = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));			 Tg = VSUB(Te, Tf);			 T1b = VADD(Te, Tf);		    }		    Ts = VSUB(To, Tr);		    TL = VSUB(T6, T9);		    TM = VSUB(Td, Tg);		    Tz = VSUB(Tv, Ty);		    T13 = VSUB(T11, T12);		    T16 = VSUB(T14, T15);		    T1j = VADD(T13, T16);		    T1u = VADD(T18, T19);		    T1v = VADD(T1b, T1c);		    T1w = VADD(T1u, T1v);		    T1r = VADD(T11, T12);		    T1s = VADD(T14, T15);		    T1t = VADD(T1r, T1s);		    T1a = VSUB(T18, T19);		    T1d = VSUB(T1b, T1c);		    T1k = VADD(T1a, T1d);		    {			 V Ta, Th, TC, TD;			 Ta = VADD(T6, T9);			 Th = VADD(Td, Tg);			 Ti = VADD(Ta, Th);			 Tk = VMUL(LDK(KP559016994), VSUB(Ta, Th));			 TC = VADD(To, Tr);			 TD = VADD(Tv, Ty);			 TE = VMUL(LDK(KP559016994), VSUB(TC, TD));//.........这里部分代码省略.........

static void t1fv_20(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     DVK(KP618033988, +0.618033988749894848204586834365638117720309180);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 38)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 38), MAKE_VOLATILE_STRIDE(20, rs)) {	       V T4, Tx, T1m, T1K, T1y, Tk, Tf, T16, T10, TT, T1O, T1w, T1L, T1p, T1M;	       V T1s, TZ, TI, T1x, Tp;	       {		    V T1, Tv, T2, Tt;		    T1 = LD(&(x[0]), ms, &(x[0]));		    Tv = LD(&(x[WS(rs, 15)]), ms, &(x[WS(rs, 1)]));		    T2 = LD(&(x[WS(rs, 10)]), ms, &(x[0]));		    Tt = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));		    {			 V T9, T1n, TN, T1v, TS, Te, T1q, T1u, TE, TG, Tm, T1o, TC, Tn, T1r;			 V TH, To;			 {			      V TP, TR, Ta, Tc;			      {				   V T5, T7, TJ, TL, T1k, T1l;				   T5 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));				   T7 = LD(&(x[WS(rs, 14)]), ms, &(x[0]));				   TJ = LD(&(x[WS(rs, 13)]), ms, &(x[WS(rs, 1)]));				   TL = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));				   {					V Tw, T3, Tu, T6, T8, TK, TM, TO, TQ;					TO = LD(&(x[WS(rs, 17)]), ms, &(x[WS(rs, 1)]));					Tw = BYTWJ(&(W[TWVL * 28]), Tv);					T3 = BYTWJ(&(W[TWVL * 18]), T2);					Tu = BYTWJ(&(W[TWVL * 8]), Tt);					T6 = BYTWJ(&(W[TWVL * 6]), T5);					T8 = BYTWJ(&(W[TWVL * 26]), T7);					TK = BYTWJ(&(W[TWVL * 24]), TJ);					TM = BYTWJ(&(W[TWVL * 4]), TL);					TP = BYTWJ(&(W[TWVL * 32]), TO);					TQ = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));					T4 = VSUB(T1, T3);					T1k = VADD(T1, T3);					Tx = VSUB(Tu, Tw);					T1l = VADD(Tu, Tw);					T9 = VSUB(T6, T8);					T1n = VADD(T6, T8);					TN = VSUB(TK, TM);					T1v = VADD(TK, TM);					TR = BYTWJ(&(W[TWVL * 12]), TQ);				   }				   Ta = LD(&(x[WS(rs, 16)]), ms, &(x[0]));				   T1m = VSUB(T1k, T1l);				   T1K = VADD(T1k, T1l);				   Tc = LD(&(x[WS(rs, 6)]), ms, &(x[0]));			      }			      {				   V Tb, TA, Td, Th, Tj, Tz, Tg, Ti, Ty;				   Tg = LD(&(x[WS(rs, 8)]), ms, &(x[0]));				   Ti = LD(&(x[WS(rs, 18)]), ms, &(x[0]));				   Ty = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));				   TS = VSUB(TP, TR);				   T1y = VADD(TP, TR);				   Tb = BYTWJ(&(W[TWVL * 30]), Ta);				   TA = LD(&(x[WS(rs, 19)]), ms, &(x[WS(rs, 1)]));				   Td = BYTWJ(&(W[TWVL * 10]), Tc);				   Th = BYTWJ(&(W[TWVL * 14]), Tg);				   Tj = BYTWJ(&(W[TWVL * 34]), Ti);				   Tz = BYTWJ(&(W[TWVL * 16]), Ty);				   {					V TD, TF, TB, Tl;					TD = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));					TF = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));					Tl = LD(&(x[WS(rs, 12)]), ms, &(x[0]));					TB = BYTWJ(&(W[TWVL * 36]), TA);					Te = VSUB(Tb, Td);					T1q = VADD(Tb, Td);					Tk = VSUB(Th, Tj);					T1u = VADD(Th, Tj);					TE = BYTWJ(&(W[0]), TD);					TG = BYTWJ(&(W[TWVL * 20]), TF);					Tm = BYTWJ(&(W[TWVL * 22]), Tl);					T1o = VADD(Tz, TB);					TC = VSUB(Tz, TB);					Tn = LD(&(x[WS(rs, 2)]), ms, &(x[0]));				   }			      }			 }			 Tf = VADD(T9, Te);			 T16 = VSUB(T9, Te);			 T10 = VSUB(TS, TN);			 TT = VADD(TN, TS);			 T1r = VADD(TE, TG);			 TH = VSUB(TE, TG);			 T1O = VADD(T1u, T1v);			 T1w = VSUB(T1u, T1v);			 To = BYTWJ(&(W[TWVL * 2]), Tn);			 T1L = VADD(T1n, T1o);			 T1p = VSUB(T1n, T1o);//.........这里部分代码省略.........

static void n1bv_10(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     DVK(KP587785252, +0.587785252292473129168705954639072768597652438);     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     INT i;     const R *xi;     R *xo;     xi = ii;     xo = io;     for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {	  V Tl, Ty, T7, Te, Tw, Tt, Tz, TA, TB, Tg, Th, Tm, Tj, Tk;	  Tj = LD(&(xi[0]), ivs, &(xi[0]));	  Tk = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));	  Tl = VSUB(Tj, Tk);	  Ty = VADD(Tj, Tk);	  {	       V T3, Tr, Td, Tv, T6, Ts, Ta, Tu;	       {		    V T1, T2, Tb, Tc;		    T1 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));		    T2 = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));		    T3 = VSUB(T1, T2);		    Tr = VADD(T1, T2);		    Tb = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));		    Tc = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));		    Td = VSUB(Tb, Tc);		    Tv = VADD(Tb, Tc);	       }	       {		    V T4, T5, T8, T9;		    T4 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));		    T5 = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));		    T6 = VSUB(T4, T5);		    Ts = VADD(T4, T5);		    T8 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));		    T9 = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));		    Ta = VSUB(T8, T9);		    Tu = VADD(T8, T9);	       }	       T7 = VSUB(T3, T6);	       Te = VSUB(Ta, Td);	       Tw = VSUB(Tu, Tv);	       Tt = VSUB(Tr, Ts);	       Tz = VADD(Tr, Ts);	       TA = VADD(Tu, Tv);	       TB = VADD(Tz, TA);	       Tg = VADD(T3, T6);	       Th = VADD(Ta, Td);	       Tm = VADD(Tg, Th);	  }	  ST(&(xo[WS(os, 5)]), VADD(Tl, Tm), ovs, &(xo[WS(os, 1)]));	  ST(&(xo[0]), VADD(Ty, TB), ovs, &(xo[0]));	  {	       V Tf, Tq, To, Tp, Ti, Tn;	       Tf = VBYI(VFMA(LDK(KP951056516), T7, VMUL(LDK(KP587785252), Te)));	       Tq = VBYI(VFNMS(LDK(KP951056516), Te, VMUL(LDK(KP587785252), T7)));	       Ti = VMUL(LDK(KP559016994), VSUB(Tg, Th));	       Tn = VFNMS(LDK(KP250000000), Tm, Tl);	       To = VADD(Ti, Tn);	       Tp = VSUB(Tn, Ti);	       ST(&(xo[WS(os, 1)]), VADD(Tf, To), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 7)]), VADD(Tq, Tp), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 9)]), VSUB(To, Tf), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 3)]), VSUB(Tp, Tq), ovs, &(xo[WS(os, 1)]));	  }	  {	       V Tx, TG, TE, TF, TC, TD;	       Tx = VBYI(VFNMS(LDK(KP951056516), Tw, VMUL(LDK(KP587785252), Tt)));	       TG = VBYI(VFMA(LDK(KP951056516), Tt, VMUL(LDK(KP587785252), Tw)));	       TC = VFNMS(LDK(KP250000000), TB, Ty);	       TD = VMUL(LDK(KP559016994), VSUB(Tz, TA));	       TE = VSUB(TC, TD);	       TF = VADD(TD, TC);	       ST(&(xo[WS(os, 2)]), VADD(Tx, TE), ovs, &(xo[0]));	       ST(&(xo[WS(os, 6)]), VADD(TG, TF), ovs, &(xo[0]));	       ST(&(xo[WS(os, 8)]), VSUB(TE, Tx), ovs, &(xo[0]));	       ST(&(xo[WS(os, 4)]), VSUB(TF, TG), ovs, &(xo[0]));	  }     }}

static void t3fv_10(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP559016994, +0.559016994374947424102293417182819058860154590);     DVK(KP618033988, +0.618033988749894848204586834365638117720309180);     DVK(KP951056516, +0.951056516295153572116439333379382143405698634);     DVK(KP250000000, +0.250000000000000000000000000000000000000000000);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 6)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 6), MAKE_VOLATILE_STRIDE(10, rs)) {	       V T2, T3, T4, Ta, T5, T6, Tt, Td, Th;	       T2 = LDW(&(W[0]));	       T3 = LDW(&(W[TWVL * 2]));	       T4 = VZMUL(T2, T3);	       Ta = VZMULJ(T2, T3);	       T5 = LDW(&(W[TWVL * 4]));	       T6 = VZMULJ(T4, T5);	       Tt = VZMULJ(T3, T5);	       Td = VZMULJ(Ta, T5);	       Th = VZMULJ(T2, T5);	       {		    V T9, TJ, Ts, Ty, Tz, TN, TO, TP, Tg, Tm, Tn, TK, TL, TM, T1;		    V T8, T7;		    T1 = LD(&(x[0]), ms, &(x[0]));		    T7 = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));		    T8 = VZMULJ(T6, T7);		    T9 = VSUB(T1, T8);		    TJ = VADD(T1, T8);		    {			 V Tp, Tx, Tr, Tv;			 {			      V To, Tw, Tq, Tu;			      To = LD(&(x[WS(rs, 4)]), ms, &(x[0]));			      Tp = VZMULJ(T4, To);			      Tw = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));			      Tx = VZMULJ(T2, Tw);			      Tq = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));			      Tr = VZMULJ(T5, Tq);			      Tu = LD(&(x[WS(rs, 6)]), ms, &(x[0]));			      Tv = VZMULJ(Tt, Tu);			 }			 Ts = VSUB(Tp, Tr);			 Ty = VSUB(Tv, Tx);			 Tz = VADD(Ts, Ty);			 TN = VADD(Tp, Tr);			 TO = VADD(Tv, Tx);			 TP = VADD(TN, TO);		    }		    {			 V Tc, Tl, Tf, Tj;			 {			      V Tb, Tk, Te, Ti;			      Tb = LD(&(x[WS(rs, 2)]), ms, &(x[0]));			      Tc = VZMULJ(Ta, Tb);			      Tk = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));			      Tl = VZMULJ(T3, Tk);			      Te = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));			      Tf = VZMULJ(Td, Te);			      Ti = LD(&(x[WS(rs, 8)]), ms, &(x[0]));			      Tj = VZMULJ(Th, Ti);			 }			 Tg = VSUB(Tc, Tf);			 Tm = VSUB(Tj, Tl);			 Tn = VADD(Tg, Tm);			 TK = VADD(Tc, Tf);			 TL = VADD(Tj, Tl);			 TM = VADD(TK, TL);		    }		    {			 V TC, TA, TB, TG, TI, TE, TF, TH, TD;			 TC = VSUB(Tn, Tz);			 TA = VADD(Tn, Tz);			 TB = VFNMS(LDK(KP250000000), TA, T9);			 TE = VSUB(Tg, Tm);			 TF = VSUB(Ts, Ty);			 TG = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), TF, TE));			 TI = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), TE, TF));			 ST(&(x[WS(rs, 5)]), VADD(T9, TA), ms, &(x[WS(rs, 1)]));			 TH = VFNMS(LDK(KP559016994), TC, TB);			 ST(&(x[WS(rs, 3)]), VFNMSI(TI, TH), ms, &(x[WS(rs, 1)]));			 ST(&(x[WS(rs, 7)]), VFMAI(TI, TH), ms, &(x[WS(rs, 1)]));			 TD = VFMA(LDK(KP559016994), TC, TB);			 ST(&(x[WS(rs, 1)]), VFNMSI(TG, TD), ms, &(x[WS(rs, 1)]));			 ST(&(x[WS(rs, 9)]), VFMAI(TG, TD), ms, &(x[WS(rs, 1)]));		    }		    {			 V TS, TQ, TR, TW, TY, TU, TV, TX, TT;			 TS = VSUB(TM, TP);			 TQ = VADD(TM, TP);			 TR = VFNMS(LDK(KP250000000), TQ, TJ);			 TU = VSUB(TN, TO);			 TV = VSUB(TK, TL);			 TW = VMUL(LDK(KP951056516), VFNMS(LDK(KP618033988), TV, TU));			 TY = VMUL(LDK(KP951056516), VFMA(LDK(KP618033988), TU, TV));			 ST(&(x[0]), VADD(TJ, TQ), ms, &(x[0]));			 TX = VFMA(LDK(KP559016994), TS, TR);			 ST(&(x[WS(rs, 4)]), VFMAI(TY, TX), ms, &(x[0]));			 ST(&(x[WS(rs, 6)]), VFNMSI(TY, TX), ms, &(x[0]));			 TT = VFNMS(LDK(KP559016994), TS, TR);//.........这里部分代码省略.........

static void n2fv_8(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ri;	  xo = ro;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(is), MAKE_VOLATILE_STRIDE(os)) {	       V T1, T2, Tc, Td, T4, T5, T7, T8;	       T1 = LD(&(xi[0]), ivs, &(xi[0]));	       T2 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));	       Tc = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));	       Td = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));	       T4 = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));	       T5 = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));	       T7 = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));	       T8 = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));	       {		    V T3, Tj, Te, Tk, T6, Tm, T9, Tn, Tp, Tl;		    T3 = VSUB(T1, T2);		    Tj = VADD(T1, T2);		    Te = VSUB(Tc, Td);		    Tk = VADD(Tc, Td);		    T6 = VSUB(T4, T5);		    Tm = VADD(T4, T5);		    T9 = VSUB(T7, T8);		    Tn = VADD(T7, T8);		    Tp = VSUB(Tj, Tk);		    Tl = VADD(Tj, Tk);		    {			 V Tq, To, Ta, Tf;			 Tq = VSUB(Tn, Tm);			 To = VADD(Tm, Tn);			 Ta = VADD(T6, T9);			 Tf = VSUB(T9, T6);			 {			      V Tr, Ts, Tt, Tu, Tg, Ti, Tb, Th;			      Tr = VADD(Tl, To);			      STM2(&(xo[0]), Tr, ovs, &(xo[0]));			      Ts = VSUB(Tl, To);			      STM2(&(xo[8]), Ts, ovs, &(xo[0]));			      Tt = VFMAI(Tq, Tp);			      STM2(&(xo[4]), Tt, ovs, &(xo[0]));			      Tu = VFNMSI(Tq, Tp);			      STM2(&(xo[12]), Tu, ovs, &(xo[0]));			      Tg = VFNMS(LDK(KP707106781), Tf, Te);			      Ti = VFMA(LDK(KP707106781), Tf, Te);			      Tb = VFMA(LDK(KP707106781), Ta, T3);			      Th = VFNMS(LDK(KP707106781), Ta, T3);			      {				   V Tv, Tw, Tx, Ty;				   Tv = VFMAI(Ti, Th);				   STM2(&(xo[6]), Tv, ovs, &(xo[2]));				   STN2(&(xo[4]), Tt, Tv, ovs);				   Tw = VFNMSI(Ti, Th);				   STM2(&(xo[10]), Tw, ovs, &(xo[2]));				   STN2(&(xo[8]), Ts, Tw, ovs);				   Tx = VFMAI(Tg, Tb);				   STM2(&(xo[14]), Tx, ovs, &(xo[2]));				   STN2(&(xo[12]), Tu, Tx, ovs);				   Ty = VFNMSI(Tg, Tb);				   STM2(&(xo[2]), Ty, ovs, &(xo[2]));				   STN2(&(xo[0]), Tr, Ty, ovs);			      }			 }		    }	       }	  }     }     VLEAVE();}

static void n1bv_8(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ii;	  xo = io;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(16, is), MAKE_VOLATILE_STRIDE(16, os)) {	       V Ta, Tk, Te, Tj, T7, Tn, Tf, Tm;	       {		    V T8, T9, Tc, Td;		    T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));		    T9 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));		    Ta = VSUB(T8, T9);		    Tk = VADD(T8, T9);		    Tc = LD(&(xi[0]), ivs, &(xi[0]));		    Td = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));		    Te = VSUB(Tc, Td);		    Tj = VADD(Tc, Td);		    {			 V T1, T2, T3, T4, T5, T6;			 T1 = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));			 T2 = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));			 T3 = VSUB(T1, T2);			 T4 = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));			 T5 = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));			 T6 = VSUB(T4, T5);			 T7 = VMUL(LDK(KP707106781), VSUB(T3, T6));			 Tn = VADD(T4, T5);			 Tf = VMUL(LDK(KP707106781), VADD(T3, T6));			 Tm = VADD(T1, T2);		    }	       }	       {		    V Tb, Tg, Tp, Tq;		    Tb = VBYI(VSUB(T7, Ta));		    Tg = VSUB(Te, Tf);		    ST(&(xo[WS(os, 3)]), VADD(Tb, Tg), ovs, &(xo[WS(os, 1)]));		    ST(&(xo[WS(os, 5)]), VSUB(Tg, Tb), ovs, &(xo[WS(os, 1)]));		    Tp = VADD(Tj, Tk);		    Tq = VADD(Tm, Tn);		    ST(&(xo[WS(os, 4)]), VSUB(Tp, Tq), ovs, &(xo[0]));		    ST(&(xo[0]), VADD(Tp, Tq), ovs, &(xo[0]));	       }	       {		    V Th, Ti, Tl, To;		    Th = VBYI(VADD(Ta, T7));		    Ti = VADD(Te, Tf);		    ST(&(xo[WS(os, 1)]), VADD(Th, Ti), ovs, &(xo[WS(os, 1)]));		    ST(&(xo[WS(os, 7)]), VSUB(Ti, Th), ovs, &(xo[WS(os, 1)]));		    Tl = VSUB(Tj, Tk);		    To = VBYI(VSUB(Tm, Tn));		    ST(&(xo[WS(os, 6)]), VSUB(Tl, To), ovs, &(xo[0]));		    ST(&(xo[WS(os, 2)]), VADD(Tl, To), ovs, &(xo[0]));	       }	  }     }     VLEAVE();}

static void hc2cbdftv_8(R *Rp, R *Ip, R *Rm, R *Im, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     INT m;     for (m = mb, W = W + ((mb - 1) * ((TWVL / VL) * 14)); m < me; m = m + VL, Rp = Rp + (VL * ms), Ip = Ip + (VL * ms), Rm = Rm - (VL * ms), Im = Im - (VL * ms), W = W + (TWVL * 14), MAKE_VOLATILE_STRIDE(rs)) {	  V T5, Tj, Tq, TI, Te, Tk, Tt, TJ, T2, Tg, T4, Ti, T3, Th, To;	  V Tp, T6, Tc, T8, Tb, T7, Ta, T9, Td, Tr, Ts, TP, Tu, Tm, TO;	  V Tn, Tf, Tl, T1, TN, Tv, TR, Tw, TQ, TC, TK, TA, TG, TB, TH;	  V Ty, Tz, Tx, TF, TD, TM, TE, TL;	  T2 = LD(&(Rp[0]), ms, &(Rp[0]));	  Tg = LD(&(Rp[WS(rs, 2)]), ms, &(Rp[0]));	  T3 = LD(&(Rm[WS(rs, 3)]), -ms, &(Rm[WS(rs, 1)]));	  T4 = VCONJ(T3);	  Th = LD(&(Rm[WS(rs, 1)]), -ms, &(Rm[WS(rs, 1)]));	  Ti = VCONJ(Th);	  T5 = VSUB(T2, T4);	  Tj = VSUB(Tg, Ti);	  To = VADD(T2, T4);	  Tp = VADD(Tg, Ti);	  Tq = VSUB(To, Tp);	  TI = VADD(To, Tp);	  T6 = LD(&(Rp[WS(rs, 1)]), ms, &(Rp[WS(rs, 1)]));	  Tc = LD(&(Rp[WS(rs, 3)]), ms, &(Rp[WS(rs, 1)]));	  T7 = LD(&(Rm[WS(rs, 2)]), -ms, &(Rm[0]));	  T8 = VCONJ(T7);	  Ta = LD(&(Rm[0]), -ms, &(Rm[0]));	  Tb = VCONJ(Ta);	  T9 = VSUB(T6, T8);	  Td = VSUB(Tb, Tc);	  Te = VMUL(LDK(KP707106781), VADD(T9, Td));	  Tk = VMUL(LDK(KP707106781), VSUB(T9, Td));	  Tr = VADD(T6, T8);	  Ts = VADD(Tb, Tc);	  Tt = VBYI(VSUB(Tr, Ts));	  TJ = VADD(Tr, Ts);	  TP = VADD(TI, TJ);	  Tn = LDW(&(W[TWVL * 10]));	  Tu = VZMUL(Tn, VSUB(Tq, Tt));	  Tf = VADD(T5, Te);	  Tl = VBYI(VADD(Tj, Tk));	  T1 = LDW(&(W[TWVL * 12]));	  Tm = VZMULI(T1, VSUB(Tf, Tl));	  TN = LDW(&(W[0]));	  TO = VZMULI(TN, VADD(Tl, Tf));	  Tv = VADD(Tm, Tu);	  ST(&(Rp[WS(rs, 3)]), Tv, ms, &(Rp[WS(rs, 1)]));	  TR = VCONJ(VSUB(TP, TO));	  ST(&(Rm[0]), TR, -ms, &(Rm[0]));	  Tw = VCONJ(VSUB(Tu, Tm));	  ST(&(Rm[WS(rs, 3)]), Tw, -ms, &(Rm[WS(rs, 1)]));	  TQ = VADD(TO, TP);	  ST(&(Rp[0]), TQ, ms, &(Rp[0]));	  TB = LDW(&(W[TWVL * 2]));	  TC = VZMUL(TB, VADD(Tq, Tt));	  TH = LDW(&(W[TWVL * 6]));	  TK = VZMUL(TH, VSUB(TI, TJ));	  Ty = VBYI(VSUB(Tk, Tj));	  Tz = VSUB(T5, Te);	  Tx = LDW(&(W[TWVL * 4]));	  TA = VZMULI(Tx, VADD(Ty, Tz));	  TF = LDW(&(W[TWVL * 8]));	  TG = VZMULI(TF, VSUB(Tz, Ty));	  TD = VADD(TA, TC);	  ST(&(Rp[WS(rs, 1)]), TD, ms, &(Rp[WS(rs, 1)]));	  TM = VCONJ(VSUB(TK, TG));	  ST(&(Rm[WS(rs, 2)]), TM, -ms, &(Rm[0]));	  TE = VCONJ(VSUB(TC, TA));	  ST(&(Rm[WS(rs, 1)]), TE, -ms, &(Rm[WS(rs, 1)]));	  TL = VADD(TG, TK);	  ST(&(Rp[WS(rs, 2)]), TL, ms, &(Rp[0]));     }}

static void n1bv_12(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, int v, int ivs, int ovs){     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     int i;     const R *xi;     R *xo;     xi = ii;     xo = io;     BEGIN_SIMD();     for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs)) {	  V T5, Ta, TG, TF, Ty, Tm, Ti, Tp, TJ, TI, Tx, Ts;	  {	       V T1, T6, T4, Tk, T9, Tl;	       T1 = LD(&(xi[0]), ivs, &(xi[0]));	       T6 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));	       {		    V T2, T3, T7, T8;		    T2 = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));		    T3 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));		    T4 = VADD(T2, T3);		    Tk = VSUB(T2, T3);		    T7 = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));		    T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));		    T9 = VADD(T7, T8);		    Tl = VSUB(T7, T8);	       }	       T5 = VFNMS(LDK(KP500000000), T4, T1);	       Ta = VFNMS(LDK(KP500000000), T9, T6);	       TG = VADD(T6, T9);	       TF = VADD(T1, T4);	       Ty = VADD(Tk, Tl);	       Tm = VMUL(LDK(KP866025403), VSUB(Tk, Tl));	  }	  {	       V Tn, Tq, Te, To, Th, Tr;	       Tn = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));	       Tq = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));	       {		    V Tc, Td, Tf, Tg;		    Tc = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));		    Td = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));		    Te = VSUB(Tc, Td);		    To = VADD(Tc, Td);		    Tf = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));		    Tg = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));		    Th = VSUB(Tf, Tg);		    Tr = VADD(Tf, Tg);	       }	       Ti = VMUL(LDK(KP866025403), VSUB(Te, Th));	       Tp = VFNMS(LDK(KP500000000), To, Tn);	       TJ = VADD(Tq, Tr);	       TI = VADD(Tn, To);	       Tx = VADD(Te, Th);	       Ts = VFNMS(LDK(KP500000000), Tr, Tq);	  }	  {	       V TH, TK, TL, TM;	       TH = VSUB(TF, TG);	       TK = VBYI(VSUB(TI, TJ));	       ST(&(xo[WS(os, 3)]), VSUB(TH, TK), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 9)]), VADD(TH, TK), ovs, &(xo[WS(os, 1)]));	       TL = VADD(TF, TG);	       TM = VADD(TI, TJ);	       ST(&(xo[WS(os, 6)]), VSUB(TL, TM), ovs, &(xo[0]));	       ST(&(xo[0]), VADD(TL, TM), ovs, &(xo[0]));	  }	  {	       V Tj, Tv, Tu, Tw, Tb, Tt;	       Tb = VSUB(T5, Ta);	       Tj = VSUB(Tb, Ti);	       Tv = VADD(Tb, Ti);	       Tt = VSUB(Tp, Ts);	       Tu = VBYI(VADD(Tm, Tt));	       Tw = VBYI(VSUB(Tt, Tm));	       ST(&(xo[WS(os, 11)]), VSUB(Tj, Tu), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 5)]), VADD(Tv, Tw), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 1)]), VADD(Tj, Tu), ovs, &(xo[WS(os, 1)]));	       ST(&(xo[WS(os, 7)]), VSUB(Tv, Tw), ovs, &(xo[WS(os, 1)]));	  }	  {	       V Tz, TD, TC, TE, TA, TB;	       Tz = VBYI(VMUL(LDK(KP866025403), VSUB(Tx, Ty)));	       TD = VBYI(VMUL(LDK(KP866025403), VADD(Ty, Tx)));	       TA = VADD(T5, Ta);	       TB = VADD(Tp, Ts);	       TC = VSUB(TA, TB);	       TE = VADD(TA, TB);	       ST(&(xo[WS(os, 2)]), VADD(Tz, TC), ovs, &(xo[0]));	       ST(&(xo[WS(os, 8)]), VSUB(TE, TD), ovs, &(xo[0]));	       ST(&(xo[WS(os, 10)]), VSUB(TC, Tz), ovs, &(xo[0]));	       ST(&(xo[WS(os, 4)]), VADD(TD, TE), ovs, &(xo[0]));	  }     }     END_SIMD();}

static void t2fv_16(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP923879532, +0.923879532511286756128183189396788286822416626);     DVK(KP382683432, +0.382683432365089771728459984030398866761344562);     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 30)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 30), MAKE_VOLATILE_STRIDE(16, rs)) {	       V TJ, T10, TD, T11, T1b, T1c, Ty, TK, T16, T17, T18, Tb, TN, T13, T14;	       V T15, Tm, TM, TG, TI, TH;	       TG = LD(&(x[0]), ms, &(x[0]));	       TH = LD(&(x[WS(rs, 8)]), ms, &(x[0]));	       TI = BYTWJ(&(W[TWVL * 14]), TH);	       TJ = VSUB(TG, TI);	       T10 = VADD(TG, TI);	       {		    V TA, TC, Tz, TB;		    Tz = LD(&(x[WS(rs, 4)]), ms, &(x[0]));		    TA = BYTWJ(&(W[TWVL * 6]), Tz);		    TB = LD(&(x[WS(rs, 12)]), ms, &(x[0]));		    TC = BYTWJ(&(W[TWVL * 22]), TB);		    TD = VSUB(TA, TC);		    T11 = VADD(TA, TC);	       }	       {		    V Tp, Tw, Tr, Tu, Ts, Tx;		    {			 V To, Tv, Tq, Tt;			 To = LD(&(x[WS(rs, 14)]), ms, &(x[0]));			 Tp = BYTWJ(&(W[TWVL * 26]), To);			 Tv = LD(&(x[WS(rs, 10)]), ms, &(x[0]));			 Tw = BYTWJ(&(W[TWVL * 18]), Tv);			 Tq = LD(&(x[WS(rs, 6)]), ms, &(x[0]));			 Tr = BYTWJ(&(W[TWVL * 10]), Tq);			 Tt = LD(&(x[WS(rs, 2)]), ms, &(x[0]));			 Tu = BYTWJ(&(W[TWVL * 2]), Tt);		    }		    T1b = VADD(Tp, Tr);		    T1c = VADD(Tu, Tw);		    Ts = VSUB(Tp, Tr);		    Tx = VSUB(Tu, Tw);		    Ty = VMUL(LDK(KP707106781), VSUB(Ts, Tx));		    TK = VMUL(LDK(KP707106781), VADD(Tx, Ts));	       }	       {		    V T2, T9, T4, T7, T5, Ta;		    {			 V T1, T8, T3, T6;			 T1 = LD(&(x[WS(rs, 15)]), ms, &(x[WS(rs, 1)]));			 T2 = BYTWJ(&(W[TWVL * 28]), T1);			 T8 = LD(&(x[WS(rs, 11)]), ms, &(x[WS(rs, 1)]));			 T9 = BYTWJ(&(W[TWVL * 20]), T8);			 T3 = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));			 T4 = BYTWJ(&(W[TWVL * 12]), T3);			 T6 = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));			 T7 = BYTWJ(&(W[TWVL * 4]), T6);		    }		    T16 = VADD(T2, T4);		    T17 = VADD(T7, T9);		    T18 = VSUB(T16, T17);		    T5 = VSUB(T2, T4);		    Ta = VSUB(T7, T9);		    Tb = VFNMS(LDK(KP923879532), Ta, VMUL(LDK(KP382683432), T5));		    TN = VFMA(LDK(KP923879532), T5, VMUL(LDK(KP382683432), Ta));	       }	       {		    V Td, Tk, Tf, Ti, Tg, Tl;		    {			 V Tc, Tj, Te, Th;			 Tc = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));			 Td = BYTWJ(&(W[0]), Tc);			 Tj = LD(&(x[WS(rs, 13)]), ms, &(x[WS(rs, 1)]));			 Tk = BYTWJ(&(W[TWVL * 24]), Tj);			 Te = LD(&(x[WS(rs, 9)]), ms, &(x[WS(rs, 1)]));			 Tf = BYTWJ(&(W[TWVL * 16]), Te);			 Th = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));			 Ti = BYTWJ(&(W[TWVL * 8]), Th);		    }		    T13 = VADD(Td, Tf);		    T14 = VADD(Ti, Tk);		    T15 = VSUB(T13, T14);		    Tg = VSUB(Td, Tf);		    Tl = VSUB(Ti, Tk);		    Tm = VFMA(LDK(KP382683432), Tg, VMUL(LDK(KP923879532), Tl));		    TM = VFNMS(LDK(KP382683432), Tl, VMUL(LDK(KP923879532), Tg));	       }	       {		    V T1a, T1g, T1f, T1h;		    {			 V T12, T19, T1d, T1e;			 T12 = VSUB(T10, T11);			 T19 = VMUL(LDK(KP707106781), VADD(T15, T18));			 T1a = VADD(T12, T19);			 T1g = VSUB(T12, T19);			 T1d = VSUB(T1b, T1c);			 T1e = VMUL(LDK(KP707106781), VSUB(T18, T15));			 T1f = VBYI(VADD(T1d, T1e));			 T1h = VBYI(VSUB(T1e, T1d));//.........这里部分代码省略.........

static void t1fuv_8(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP707106781, +0.707106781186547524400844362104849039284835938);     {	  INT m;	  R *x;	  x = ri;	  for (m = mb, W = W + (mb * ((TWVL / VL) * 14)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 14), MAKE_VOLATILE_STRIDE(rs)) {	       V T1, T2, Th, Tj, T5, T7, Ta, Tc;	       T1 = LD(&(x[0]), ms, &(x[0]));	       T2 = LD(&(x[WS(rs, 4)]), ms, &(x[0]));	       Th = LD(&(x[WS(rs, 2)]), ms, &(x[0]));	       Tj = LD(&(x[WS(rs, 6)]), ms, &(x[0]));	       T5 = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));	       T7 = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));	       Ta = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));	       Tc = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));	       {		    V T3, Ti, Tk, T6, T8, Tb, Td;		    T3 = BYTWJ(&(W[TWVL * 6]), T2);		    Ti = BYTWJ(&(W[TWVL * 2]), Th);		    Tk = BYTWJ(&(W[TWVL * 10]), Tj);		    T6 = BYTWJ(&(W[0]), T5);		    T8 = BYTWJ(&(W[TWVL * 8]), T7);		    Tb = BYTWJ(&(W[TWVL * 12]), Ta);		    Td = BYTWJ(&(W[TWVL * 4]), Tc);		    {			 V Tq, T4, Tr, Tl, Tt, T9, Tu, Te, Tw, Ts;			 Tq = VADD(T1, T3);			 T4 = VSUB(T1, T3);			 Tr = VADD(Ti, Tk);			 Tl = VSUB(Ti, Tk);			 Tt = VADD(T6, T8);			 T9 = VSUB(T6, T8);			 Tu = VADD(Tb, Td);			 Te = VSUB(Tb, Td);			 Tw = VSUB(Tq, Tr);			 Ts = VADD(Tq, Tr);			 {			      V Tx, Tv, Tm, Tf;			      Tx = VSUB(Tu, Tt);			      Tv = VADD(Tt, Tu);			      Tm = VSUB(Te, T9);			      Tf = VADD(T9, Te);			      {				   V Tp, Tn, To, Tg;				   ST(&(x[WS(rs, 2)]), VFMAI(Tx, Tw), ms, &(x[0]));				   ST(&(x[WS(rs, 6)]), VFNMSI(Tx, Tw), ms, &(x[0]));				   ST(&(x[0]), VADD(Ts, Tv), ms, &(x[0]));				   ST(&(x[WS(rs, 4)]), VSUB(Ts, Tv), ms, &(x[0]));				   Tp = VFMA(LDK(KP707106781), Tm, Tl);				   Tn = VFNMS(LDK(KP707106781), Tm, Tl);				   To = VFNMS(LDK(KP707106781), Tf, T4);				   Tg = VFMA(LDK(KP707106781), Tf, T4);				   ST(&(x[WS(rs, 5)]), VFNMSI(Tp, To), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 3)]), VFMAI(Tp, To), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 7)]), VFMAI(Tn, Tg), ms, &(x[WS(rs, 1)]));				   ST(&(x[WS(rs, 1)]), VFNMSI(Tn, Tg), ms, &(x[WS(rs, 1)]));			      }			 }		    }	       }	  }     }     VLEAVE();}

static void n1fv_13(const R *ri, const R *ii, R *ro, R *io, stride is, stride os, INT v, INT ivs, INT ovs){     DVK(KP2_000000000, +2.000000000000000000000000000000000000000000000);     DVK(KP083333333, +0.083333333333333333333333333333333333333333333);     DVK(KP075902986, +0.075902986037193865983102897245103540356428373);     DVK(KP251768516, +0.251768516431883313623436926934233488546674281);     DVK(KP132983124, +0.132983124607418643793760531921092974399165133);     DVK(KP258260390, +0.258260390311744861420450644284508567852516811);     DVK(KP1_732050807, +1.732050807568877293527446341505872366942805254);     DVK(KP300238635, +0.300238635966332641462884626667381504676006424);     DVK(KP011599105, +0.011599105605768290721655456654083252189827041);     DVK(KP156891391, +0.156891391051584611046832726756003269660212636);     DVK(KP256247671, +0.256247671582936600958684654061725059144125175);     DVK(KP174138601, +0.174138601152135905005660794929264742616964676);     DVK(KP575140729, +0.575140729474003121368385547455453388461001608);     DVK(KP503537032, +0.503537032863766627246873853868466977093348562);     DVK(KP113854479, +0.113854479055790798974654345867655310534642560);     DVK(KP265966249, +0.265966249214837287587521063842185948798330267);     DVK(KP387390585, +0.387390585467617292130675966426762851778775217);     DVK(KP300462606, +0.300462606288665774426601772289207995520941381);     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     {	  INT i;	  const R *xi;	  R *xo;	  xi = ri;	  xo = ro;	  for (i = v; i > 0; i = i - VL, xi = xi + (VL * ivs), xo = xo + (VL * ovs), MAKE_VOLATILE_STRIDE(26, is), MAKE_VOLATILE_STRIDE(26, os)) {	       V TW, Tb, Tm, Tu, TC, TR, TX, TK, TU, Tz, TB, TN, TT;	       TW = LD(&(xi[0]), ivs, &(xi[0]));	       {		    V T3, TH, Tl, Tw, Tp, Tg, Tv, To, T6, Tr, T9, Ts, Ta, TI, T1;		    V T2, Tq, Tt;		    T1 = LD(&(xi[WS(is, 8)]), ivs, &(xi[0]));		    T2 = LD(&(xi[WS(is, 5)]), ivs, &(xi[WS(is, 1)]));		    T3 = VSUB(T1, T2);		    TH = VADD(T1, T2);		    {			 V Th, Ti, Tj, Tk;			 Th = LD(&(xi[WS(is, 12)]), ivs, &(xi[0]));			 Ti = LD(&(xi[WS(is, 10)]), ivs, &(xi[0]));			 Tj = LD(&(xi[WS(is, 4)]), ivs, &(xi[0]));			 Tk = VADD(Ti, Tj);			 Tl = VADD(Th, Tk);			 Tw = VSUB(Ti, Tj);			 Tp = VFNMS(LDK(KP500000000), Tk, Th);		    }		    {			 V Tc, Td, Te, Tf;			 Tc = LD(&(xi[WS(is, 1)]), ivs, &(xi[WS(is, 1)]));			 Td = LD(&(xi[WS(is, 3)]), ivs, &(xi[WS(is, 1)]));			 Te = LD(&(xi[WS(is, 9)]), ivs, &(xi[WS(is, 1)]));			 Tf = VADD(Td, Te);			 Tg = VADD(Tc, Tf);			 Tv = VSUB(Td, Te);			 To = VFNMS(LDK(KP500000000), Tf, Tc);		    }		    {			 V T4, T5, T7, T8;			 T4 = LD(&(xi[WS(is, 11)]), ivs, &(xi[WS(is, 1)]));			 T5 = LD(&(xi[WS(is, 6)]), ivs, &(xi[0]));			 T6 = VSUB(T4, T5);			 Tr = VADD(T4, T5);			 T7 = LD(&(xi[WS(is, 7)]), ivs, &(xi[WS(is, 1)]));			 T8 = LD(&(xi[WS(is, 2)]), ivs, &(xi[0]));			 T9 = VSUB(T7, T8);			 Ts = VADD(T7, T8);		    }		    Ta = VADD(T6, T9);		    TI = VADD(Tr, Ts);		    Tb = VADD(T3, Ta);		    Tm = VSUB(Tg, Tl);		    Tq = VSUB(To, Tp);		    Tt = VMUL(LDK(KP866025403), VSUB(Tr, Ts));		    Tu = VADD(Tq, Tt);		    TC = VSUB(Tq, Tt);		    {			 V TP, TQ, TG, TJ;			 TP = VADD(Tg, Tl);			 TQ = VADD(TH, TI);			 TR = VMUL(LDK(KP300462606), VSUB(TP, TQ));			 TX = VADD(TP, TQ);			 TG = VADD(To, Tp);			 TJ = VFNMS(LDK(KP500000000), TI, TH);			 TK = VSUB(TG, TJ);			 TU = VADD(TG, TJ);		    }		    {			 V Tx, Ty, TL, TM;			 Tx = VMUL(LDK(KP866025403), VSUB(Tv, Tw));			 Ty = VFNMS(LDK(KP500000000), Ta, T3);			 Tz = VSUB(Tx, Ty);			 TB = VADD(Tx, Ty);			 TL = VADD(Tv, Tw);			 TM = VSUB(T6, T9);			 TN = VSUB(TL, TM);			 TT = VADD(TL, TM);		    }	       }//.........这里部分代码省略.........

static void t1buv_9(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms){     DVK(KP939692620, +0.939692620785908384054109277324731469936208134);     DVK(KP296198132, +0.296198132726023843175338011893050938967728390);     DVK(KP852868531, +0.852868531952443209628250963940074071936020296);     DVK(KP173648177, +0.173648177666930348851716626769314796000375677);     DVK(KP556670399, +0.556670399226419366452912952047023132968291906);     DVK(KP766044443, +0.766044443118978035202392650555416673935832457);     DVK(KP642787609, +0.642787609686539326322643409907263432907559884);     DVK(KP663413948, +0.663413948168938396205421319635891297216863310);     DVK(KP150383733, +0.150383733180435296639271897612501926072238258);     DVK(KP342020143, +0.342020143325668733044099614682259580763083368);     DVK(KP813797681, +0.813797681349373692844693217248393223289101568);     DVK(KP984807753, +0.984807753012208059366743024589523013670643252);     DVK(KP500000000, +0.500000000000000000000000000000000000000000000);     DVK(KP866025403, +0.866025403784438646763723170752936183471402627);     INT m;     R *x;     x = ii;     for (m = mb, W = W + (mb * ((TWVL / VL) * 16)); m < me; m = m + VL, x = x + (VL * ms), W = W + (TWVL * 16), MAKE_VOLATILE_STRIDE(rs)) {	  V T1, T6, Tu, Tg, Tf, TD, Tq, Tp, TE;	  T1 = LD(&(x[0]), ms, &(x[0]));	  {	       V T3, T5, T2, T4;	       T2 = LD(&(x[WS(rs, 3)]), ms, &(x[WS(rs, 1)]));	       T3 = BYTW(&(W[TWVL * 4]), T2);	       T4 = LD(&(x[WS(rs, 6)]), ms, &(x[0]));	       T5 = BYTW(&(W[TWVL * 10]), T4);	       T6 = VADD(T3, T5);	       Tu = VMUL(LDK(KP866025403), VSUB(T3, T5));	  }	  {	       V T9, Td, Tb, T8, Tc, Ta, Te;	       T8 = LD(&(x[WS(rs, 1)]), ms, &(x[WS(rs, 1)]));	       T9 = BYTW(&(W[0]), T8);	       Tc = LD(&(x[WS(rs, 7)]), ms, &(x[WS(rs, 1)]));	       Td = BYTW(&(W[TWVL * 12]), Tc);	       Ta = LD(&(x[WS(rs, 4)]), ms, &(x[0]));	       Tb = BYTW(&(W[TWVL * 6]), Ta);	       Tg = VSUB(Tb, Td);	       Te = VADD(Tb, Td);	       Tf = VFNMS(LDK(KP500000000), Te, T9);	       TD = VADD(T9, Te);	  }	  {	       V Tj, Tn, Tl, Ti, Tm, Tk, To;	       Ti = LD(&(x[WS(rs, 2)]), ms, &(x[0]));	       Tj = BYTW(&(W[TWVL * 2]), Ti);	       Tm = LD(&(x[WS(rs, 8)]), ms, &(x[0]));	       Tn = BYTW(&(W[TWVL * 14]), Tm);	       Tk = LD(&(x[WS(rs, 5)]), ms, &(x[WS(rs, 1)]));	       Tl = BYTW(&(W[TWVL * 8]), Tk);	       Tq = VSUB(Tl, Tn);	       To = VADD(Tl, Tn);	       Tp = VFNMS(LDK(KP500000000), To, Tj);	       TE = VADD(Tj, To);	  }	  {	       V TF, TG, TH, TI;	       TF = VBYI(VMUL(LDK(KP866025403), VSUB(TD, TE)));	       TG = VADD(T1, T6);	       TH = VADD(TD, TE);	       TI = VFNMS(LDK(KP500000000), TH, TG);	       ST(&(x[WS(rs, 3)]), VADD(TF, TI), ms, &(x[WS(rs, 1)]));	       ST(&(x[0]), VADD(TG, TH), ms, &(x[0]));	       ST(&(x[WS(rs, 6)]), VSUB(TI, TF), ms, &(x[0]));	  }	  {	       V TC, Tv, Tw, Tx, Th, Tr, Ts, T7, TB;	       TC = VBYI(VSUB(VFMA(LDK(KP984807753), Tf, VFMA(LDK(KP813797681), Tq, VFNMS(LDK(KP150383733), Tg, VMUL(LDK(KP342020143), Tp)))), Tu));	       Tv = VFMA(LDK(KP663413948), Tg, VMUL(LDK(KP642787609), Tf));	       Tw = VFMA(LDK(KP150383733), Tq, VMUL(LDK(KP984807753), Tp));	       Tx = VADD(Tv, Tw);	       Th = VFNMS(LDK(KP556670399), Tg, VMUL(LDK(KP766044443), Tf));	       Tr = VFNMS(LDK(KP852868531), Tq, VMUL(LDK(KP173648177), Tp));	       Ts = VADD(Th, Tr);	       T7 = VFNMS(LDK(KP500000000), T6, T1);	       TB = VFMA(LDK(KP852868531), Tg, VFMA(LDK(KP173648177), Tf, VFMA(LDK(KP296198132), Tq, VFNMS(LDK(KP939692620), Tp, T7))));	       ST(&(x[WS(rs, 7)]), VSUB(TB, TC), ms, &(x[WS(rs, 1)]));	       ST(&(x[WS(rs, 2)]), VADD(TB, TC), ms, &(x[0]));	       {		    V Tt, Ty, Tz, TA;		    Tt = VADD(T7, Ts);		    Ty = VBYI(VADD(Tu, Tx));		    ST(&(x[WS(rs, 8)]), VSUB(Tt, Ty), ms, &(x[0]));		    ST(&(x[WS(rs, 1)]), VADD(Tt, Ty), ms, &(x[WS(rs, 1)]));		    Tz = VBYI(VADD(Tu, VFNMS(LDK(KP500000000), Tx, VMUL(LDK(KP866025403), VSUB(Th, Tr)))));		    TA = VFMA(LDK(KP866025403), VSUB(Tw, Tv), VFNMS(LDK(KP500000000), Ts, T7));		    ST(&(x[WS(rs, 4)]), VADD(Tz, TA), ms, &(x[0]));		    ST(&(x[WS(rs, 5)]), VSUB(TA, Tz), ms, &(x[WS(rs, 1)]));	       }	  }     }}