代码

// Radix-8 DIF forward + DIT inverse (no bitrev), AVX2 Montgomery. v16
#pragma GCC target("avx2")
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <immintrin.h>
#include <sys/auxv.h>
typedef unsigned long long u64; typedef unsigned int u32;
const u32 MOD=998244353u,NINV=998244351u,R2=932051910u,G=3u;
const u32 IM=911660635u, IINV=MOD-911660635u;
const int MAXN=1<<18;
alignas(32) static u32 a[MAXN],b[MAXN];
alignas(32) static u32 tw[8][MAXN/4];
alignas(32) static u32 twi[8][MAXN/4];
static inline u32 modpow(u32 base,u64 e){u64 r=1,bb=base%MOD;for(;e;e>>=1){if(e&1)r=r*bb%MOD;bb=bb*bb%MOD;}return (u32)r;}
static inline u32 mont_s(u32 a,u32 b){u64 t=(u64)a*b;u32 m=(u32)t*NINV;u32 u=(u32)((t+(u64)m*MOD)>>32);if(u>=MOD)u-=MOD;return u;}
static inline u32 add_s(u32 a,u32 b){u32 s=a+b; return s>=MOD? s-MOD:s;}
static inline u32 sub_s(u32 a,u32 b){u32 d=a-b; return (int)d<0? d+MOD:d;}

static inline __m256i mont8(__m256i x,__m256i y,const __m256i&ninv,const __m256i&modv,const __m256i&modm1,const __m256i&shuf){
    __m256i t_lo=_mm256_mullo_epi32(x,y);
    __m256i m=_mm256_mullo_epi32(t_lo,ninv);
    __m256i pe=_mm256_mul_epu32(x,y);
    __m256i po=_mm256_mul_epu32(_mm256_srli_epi64(x,32),_mm256_srli_epi64(y,32));
    __m256i me=_mm256_mul_epu32(m,modv);
    __m256i mo=_mm256_mul_epu32(_mm256_srli_epi64(m,32),modv);
    __m256i ue=_mm256_srli_epi64(_mm256_add_epi64(pe,me),32);
    __m256i uo=_mm256_srli_epi64(_mm256_add_epi64(po,mo),32);
    __m256i e=_mm256_shuffle_epi8(ue,shuf);
    __m256i o=_mm256_shuffle_epi8(uo,shuf);
    __m256i u=_mm256_unpacklo_epi32(e,o);
    u=_mm256_min_epu32(u,_mm256_sub_epi32(u,modv));
    return u;
}
static inline __m256i addm(__m256i a,__m256i b,const __m256i&modv){__m256i s=_mm256_add_epi32(a,b);return _mm256_min_epu32(s,_mm256_sub_epi32(s,modv));}
static inline __m256i subm(__m256i a,__m256i b,const __m256i&modv){__m256i d=_mm256_sub_epi32(a,b);return _mm256_min_epu32(d,_mm256_add_epi32(d,modv));}

// forward DIF radix-8
#pragma GCC optimize("O3,unroll-loops")
static void dif8(u32*x,int n,const u32*T1,const u32*T2,const u32*T3,const u32*T4,const u32*T5,const u32*T6,const u32*T7,u32 Z1,u32 Z3,u32 Iv){
    const __m256i ninv=_mm256_set1_epi32(NINV),modv=_mm256_set1_epi32(MOD),modm1=_mm256_set1_epi32(MOD-1);
    const __m256i shuf=_mm256_setr_epi8(0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0, 0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0);
    const __m256i z1=_mm256_set1_epi32(Z1),z3=_mm256_set1_epi32(Z3),iv=_mm256_set1_epi32(Iv);
    for(int len=n;len>8;len>>=3){int s=len>>3;
        for(int i=0;i<n;i+=len){u32*y=x+i;int p=0;
            for(;p+8<=s;p+=8){
                __m256i x0=_mm256_loadu_si256((__m256i*)(y+p));
                __m256i x1=_mm256_loadu_si256((__m256i*)(y+p+s));
                __m256i x2=_mm256_loadu_si256((__m256i*)(y+p+2*s));
                __m256i x3=_mm256_loadu_si256((__m256i*)(y+p+3*s));
                __m256i x4=_mm256_loadu_si256((__m256i*)(y+p+4*s));
                __m256i x5=_mm256_loadu_si256((__m256i*)(y+p+5*s));
                __m256i x6=_mm256_loadu_si256((__m256i*)(y+p+6*s));
                __m256i x7=_mm256_loadu_si256((__m256i*)(y+p+7*s));
                __m256i d0=addm(x0,x4,modv),d1=addm(x1,x5,modv),d2=addm(x2,x6,modv),d3=addm(x3,x7,modv);
                __m256i e0=subm(x0,x4,modv);
                __m256i e1=mont8(subm(x1,x5,modv),z1,ninv,modv,modm1,shuf);
                __m256i e2=mont8(subm(x2,x6,modv),iv,ninv,modv,modm1,shuf);
                __m256i e3=mont8(subm(x3,x7,modv),z3,ninv,modv,modm1,shuf);
                __m256i s02=addm(d0,d2,modv),t02=subm(d0,d2,modv);
                __m256i s13=addm(d1,d3,modv),t13=mont8(subm(d1,d3,modv),iv,ninv,modv,modm1,shuf);
                __m256i D0=addm(s02,s13,modv),D2=subm(s02,s13,modv);
                __m256i D1=addm(t02,t13,modv),D3=subm(t02,t13,modv);
                __m256i u02=addm(e0,e2,modv),v02=subm(e0,e2,modv);
                __m256i u13=addm(e1,e3,modv),v13=mont8(subm(e1,e3,modv),iv,ninv,modv,modm1,shuf);
                __m256i E0=addm(u02,u13,modv),E2=subm(u02,u13,modv);
                __m256i E1=addm(v02,v13,modv),E3=subm(v02,v13,modv);
                __m256i w1=_mm256_loadu_si256((__m256i*)(T1+p));
                __m256i w2=_mm256_loadu_si256((__m256i*)(T2+p));
                __m256i w3=_mm256_loadu_si256((__m256i*)(T3+p));
                __m256i w4=_mm256_loadu_si256((__m256i*)(T4+p));
                __m256i w5=_mm256_loadu_si256((__m256i*)(T5+p));
                __m256i w6=_mm256_loadu_si256((__m256i*)(T6+p));
                __m256i w7=_mm256_loadu_si256((__m256i*)(T7+p));
                _mm256_storeu_si256((__m256i*)(y+p),D0);
                _mm256_storeu_si256((__m256i*)(y+p+s),mont8(E0,w1,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+2*s),mont8(D1,w2,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+3*s),mont8(E1,w3,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+4*s),mont8(D2,w4,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+5*s),mont8(E2,w5,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+6*s),mont8(D3,w6,ninv,modv,modm1,shuf));
                _mm256_storeu_si256((__m256i*)(y+p+7*s),mont8(E3,w7,ninv,modv,modm1,shuf));
            }
            for(;p<s;p++){
                u32 x0=y[p],x1=y[p+s],x2=y[p+2*s],x3=y[p+3*s],x4=y[p+4*s],x5=y[p+5*s],x6=y[p+6*s],x7=y[p+7*s];
                u32 d0=add_s(x0,x4),d1=add_s(x1,x5),d2=add_s(x2,x6),d3=add_s(x3,x7);
                u32 e0=sub_s(x0,x4),e1=mont_s(sub_s(x1,x5),Z1),e2=mont_s(sub_s(x2,x6),Iv),e3=mont_s(sub_s(x3,x7),Z3);
                u32 s02=add_s(d0,d2),t02=sub_s(d0,d2);
                u32 s13=add_s(d1,d3),t13=mont_s(sub_s(d1,d3),Iv);
                u32 D0=add_s(s02,s13),D2=sub_s(s02,s13);
                u32 D1=add_s(t02,t13),D3=sub_s(t02,t13);
                u32 u02=add_s(e0,e2),v02=sub_s(e0,e2);
                u32 u13=add_s(e1,e3),v13=mont_s(sub_s(e1,e3),Iv);
                u32 E0=add_s(u02,u13),E2=sub_s(u02,u13);
                u32 E1=add_s(v02,v13),E3=sub_s(v02,v13);
                y[p]=D0;
                y[p+s]=mont_s(E0,T1[p]);
                y[p+2*s]=mont_s(D1,T2[p]);
                y[p+3*s]=mont_s(E1,T3[p]);
                y[p+4*s]=mont_s(D2,T4[p]);
                y[p+5*s]=mont_s(E2,T5[p]);
                y[p+6*s]=mont_s(D3,T6[p]);
                y[p+7*s]=mont_s(E3,T7[p]);
            }
        }
        T1+=s;T2+=s;T3+=s;T4+=s;T5+=s;T6+=s;T7+=s;
    }
    for(int i=0;i+8<=n;i+=8){u32*Y=x+i;
        u32 x0=Y[0],x1=Y[1],x2=Y[2],x3=Y[3],x4=Y[4],x5=Y[5],x6=Y[6],x7=Y[7];
        u32 d0=add_s(x0,x4),d1=add_s(x1,x5),d2=add_s(x2,x6),d3=add_s(x3,x7);
        u32 e0=sub_s(x0,x4),e1=mont_s(sub_s(x1,x5),Z1),e2=mont_s(sub_s(x2,x6),Iv),e3=mont_s(sub_s(x3,x7),Z3);
        u32 s02=add_s(d0,d2),t02=sub_s(d0,d2),s13=add_s(d1,d3),t13=mont_s(sub_s(d1,d3),Iv);
        u32 D0=add_s(s02,s13),D2=sub_s(s02,s13),D1=add_s(t02,t13),D3=sub_s(t02,t13);
        u32 u02=add_s(e0,e2),v02=sub_s(e0,e2),u13=add_s(e1,e3),v13=mont_s(sub_s(e1,e3),Iv);
        u32 E0=add_s(u02,u13),E2=sub_s(u02,u13),E1=add_s(v02,v13),E3=sub_s(v02,v13);
        Y[0]=D0;Y[1]=E0;Y[2]=D1;Y[3]=E1;Y[4]=D2;Y[5]=E2;Y[6]=D3;Y[7]=E3;
    }
}
// inverse DIT radix-8
#pragma GCC optimize("O3,unroll-loops")
static void dit8(u32*x,int n,const u32*T1,const u32*T2,const u32*T3,const u32*T4,const u32*T5,const u32*T6,const u32*T7,u32 Z1,u32 Z3,u32 Iv){
    const __m256i ninv=_mm256_set1_epi32(NINV),modv=_mm256_set1_epi32(MOD),modm1=_mm256_set1_epi32(MOD-1);
    const __m256i shuf=_mm256_setr_epi8(0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0, 0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0);
    const __m256i z1=_mm256_set1_epi32(Z1),z3=_mm256_set1_epi32(Z3),iv=_mm256_set1_epi32(Iv);
    for(int i=0;i+8<=n;i+=8){u32*Y=x+i;
        u32 x0=Y[0],x1=Y[1],x2=Y[2],x3=Y[3],x4=Y[4],x5=Y[5],x6=Y[6],x7=Y[7];
        u32 d0=add_s(x0,x4),d1=add_s(x1,x5),d2=add_s(x2,x6),d3=add_s(x3,x7);
        u32 e0=sub_s(x0,x4),e1=mont_s(sub_s(x1,x5),Z1),e2=mont_s(sub_s(x2,x6),Iv),e3=mont_s(sub_s(x3,x7),Z3);
        u32 s02=add_s(d0,d2),t02=sub_s(d0,d2),s13=add_s(d1,d3),t13=mont_s(sub_s(d1,d3),Iv);
        u32 D0=add_s(s02,s13),D2=sub_s(s02,s13),D1=add_s(t02,t13),D3=sub_s(t02,t13);
        u32 u02=add_s(e0,e2),v02=sub_s(e0,e2),u13=add_s(e1,e3),v13=mont_s(sub_s(e1,e3),Iv);
        u32 E0=add_s(u02,u13),E2=sub_s(u02,u13),E1=add_s(v02,v13),E3=sub_s(v02,v13);
        Y[0]=D0;Y[1]=E0;Y[2]=D1;Y[3]=E1;Y[4]=D2;Y[5]=E2;Y[6]=D3;Y[7]=E3;
    }
    T1+=1;T2+=1;T3+=1;T4+=1;T5+=1;T6+=1;T7+=1;
    for(int len=64;len<=n;len<<=3){int s=len>>3;
        for(int i=0;i<n;i+=len){u32*y=x+i;int p=0;
            for(;p+8<=s;p+=8){
                __m256i x0=_mm256_loadu_si256((__m256i*)(y+p));
                __m256i x1=mont8(_mm256_loadu_si256((__m256i*)(y+p+s)),_mm256_loadu_si256((__m256i*)(T1+p)),ninv,modv,modm1,shuf);
                __m256i x2=mont8(_mm256_loadu_si256((__m256i*)(y+p+2*s)),_mm256_loadu_si256((__m256i*)(T2+p)),ninv,modv,modm1,shuf);
                __m256i x3=mont8(_mm256_loadu_si256((__m256i*)(y+p+3*s)),_mm256_loadu_si256((__m256i*)(T3+p)),ninv,modv,modm1,shuf);
                __m256i x4=mont8(_mm256_loadu_si256((__m256i*)(y+p+4*s)),_mm256_loadu_si256((__m256i*)(T4+p)),ninv,modv,modm1,shuf);
                __m256i x5=mont8(_mm256_loadu_si256((__m256i*)(y+p+5*s)),_mm256_loadu_si256((__m256i*)(T5+p)),ninv,modv,modm1,shuf);
                __m256i x6=mont8(_mm256_loadu_si256((__m256i*)(y+p+6*s)),_mm256_loadu_si256((__m256i*)(T6+p)),ninv,modv,modm1,shuf);
                __m256i x7=mont8(_mm256_loadu_si256((__m256i*)(y+p+7*s)),_mm256_loadu_si256((__m256i*)(T7+p)),ninv,modv,modm1,shuf);
                __m256i d0=addm(x0,x4,modv),d1=addm(x1,x5,modv),d2=addm(x2,x6,modv),d3=addm(x3,x7,modv);
                __m256i e0=subm(x0,x4,modv);
                __m256i e1=mont8(subm(x1,x5,modv),z1,ninv,modv,modm1,shuf);
                __m256i e2=mont8(subm(x2,x6,modv),iv,ninv,modv,modm1,shuf);
                __m256i e3=mont8(subm(x3,x7,modv),z3,ninv,modv,modm1,shuf);
                __m256i s02=addm(d0,d2,modv),t02=subm(d0,d2,modv);
                __m256i s13=addm(d1,d3,modv),t13=mont8(subm(d1,d3,modv),iv,ninv,modv,modm1,shuf);
                __m256i D0=addm(s02,s13,modv),D2=subm(s02,s13,modv);
                __m256i D1=addm(t02,t13,modv),D3=subm(t02,t13,modv);
                __m256i u02=addm(e0,e2,modv),v02=subm(e0,e2,modv);
                __m256i u13=addm(e1,e3,modv),v13=mont8(subm(e1,e3,modv),iv,ninv,modv,modm1,shuf);
                __m256i E0=addm(u02,u13,modv),E2=subm(u02,u13,modv);
                __m256i E1=addm(v02,v13,modv),E3=subm(v02,v13,modv);
                _mm256_storeu_si256((__m256i*)(y+p),D0);
                _mm256_storeu_si256((__m256i*)(y+p+s),E0);
                _mm256_storeu_si256((__m256i*)(y+p+2*s),D1);
                _mm256_storeu_si256((__m256i*)(y+p+3*s),E1);
                _mm256_storeu_si256((__m256i*)(y+p+4*s),D2);
                _mm256_storeu_si256((__m256i*)(y+p+5*s),E2);
                _mm256_storeu_si256((__m256i*)(y+p+6*s),D3);
                _mm256_storeu_si256((__m256i*)(y+p+7*s),E3);
            }
            for(;p<s;p++){
                u32 x0=y[p],x1=mont_s(y[p+s],T1[p]),x2=mont_s(y[p+2*s],T2[p]),x3=mont_s(y[p+3*s],T3[p]);
                u32 x4=mont_s(y[p+4*s],T4[p]),x5=mont_s(y[p+5*s],T5[p]),x6=mont_s(y[p+6*s],T6[p]),x7=mont_s(y[p+7*s],T7[p]);
                u32 d0=add_s(x0,x4),d1=add_s(x1,x5),d2=add_s(x2,x6),d3=add_s(x3,x7);
                u32 e0=sub_s(x0,x4),e1=mont_s(sub_s(x1,x5),Z1),e2=mont_s(sub_s(x2,x6),Iv),e3=mont_s(sub_s(x3,x7),Z3);
                u32 s02=add_s(d0,d2),t02=sub_s(d0,d2);
                u32 s13=add_s(d1,d3),t13=mont_s(sub_s(d1,d3),Iv);
                u32 D0=add_s(s02,s13),D2=sub_s(s02,s13);
                u32 D1=add_s(t02,t13),D3=sub_s(t02,t13);
                u32 u02=add_s(e0,e2),v02=sub_s(e0,e2);
                u32 u13=add_s(e1,e3),v13=mont_s(sub_s(e1,e3),Iv);
                u32 E0=add_s(u02,u13),E2=sub_s(u02,u13);
                u32 E1=add_s(v02,v13),E3=sub_s(v02,v13);
                y[p]=D0;y[p+s]=E0;y[p+2*s]=D1;y[p+3*s]=E1;y[p+4*s]=D2;y[p+5*s]=E2;y[p+6*s]=D3;y[p+7*s]=E3;
            }
        }
        T1+=s;T2+=s;T3+=s;T4+=s;T5+=s;T6+=s;T7+=s;
    }
}

struct DuckInfo {
  unsigned long long abi_version;
  const char *stdin_ptr; unsigned long long stdin_size;
  char *stdout_ptr; unsigned long long stdout_limit; unsigned long long stdout_size;
  char *stderr_ptr; unsigned long long stderr_limit; unsigned long long stderr_size;
  const char *IB_ptr; unsigned long long IB_limit;
  char *OB_ptr; unsigned long long OB_limit;
  unsigned long long tsc_frequency;
} __attribute__((packed));

static const char* D2 = "00010203040506070809101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899";
static char D4[10000*4];
static inline char* putint_p(char* p,int x){
    if(x<10000){const char* s=D4+x*4;
        if(x<10){*p++=s[3];}else if(x<100){*p++=s[2];*p++=s[3];}else if(x<1000){*p++=s[1];*p++=s[2];*p++=s[3];}else{*p++=s[0];*p++=s[1];*p++=s[2];*p++=s[3];}
        return p;}
    int hi=x/10000,lo=x%10000;const char* sl=D4+lo*4;const char* sh=D4+hi*4;
    if(hi<10){*p++=sh[3];}else if(hi<100){*p++=sh[2];*p++=sh[3];}else{*p++=sh[1];*p++=sh[2];*p++=sh[3];}
    *p++=sl[0];*p++=sl[1];*p++=sl[2];*p++=sl[3];
    return p;}

int main(){
    DuckInfo* D=(DuckInfo*)getauxval(0x6b637564);
    for(int i=0;i<10000;i++){D4[i*4]='0'+(i/1000)%10;D4[i*4+1]='0'+(i/100)%10;D4[i*4+2]='0'+(i/10)%10;D4[i*4+3]='0'+i%10;}
    const char* in=D?D->stdin_ptr:(const char*)0;
    const char* ie=in+D->stdin_size;
    int n=0; while(in<ie&&*in>='0'&&*in<='9'){n=n*10+(*in-'0');in++;}
    while(in<ie&&(*in<'0'||*in>'9'))in++;
    int m=0; while(in<ie&&*in>='0'&&*in<='9'){m=m*10+(*in-'0');in++;}
    int na=n+1, nb=m+1;
    int size=1; while(size<na+nb-1)size<<=1;
    {int s=size,lg=0;while(s>1){s>>=1;lg++;}while(lg%3)size<<=1,lg++;} // pad to power of 8
    u32 ninv_scale=modpow((u32)size,MOD-2);
    u32 md[10], mda[10];
    for(int i=0;i<10;i++){md[i]=mont_s((u32)i,R2); mda[i]=(u32)(((u64)i*ninv_scale)%MOD);}
    while(in<ie&&(*in<'0'||*in>'9'))in++;
    for(int i=0;i<na;i++){a[i]=mda[*in-'0'];in+=2;}
    for(int i=0;i<nb;i++){b[i]=md[*in-'0'];in+=2;}
    u32 w=modpow(G,(MOD-1)/(u32)size), iw=modpow(w,MOD-2);
    u32 Z1=mont_s(modpow(w,(u32)(size/8)),R2), Z3=mont_s(modpow(w,3u*(u32)(size/8)),R2), Iv=mont_s(IM,R2);
    u32 Z1i=mont_s(modpow(iw,(u32)(size/8)),R2), Z3i=mont_s(modpow(iw,3u*(u32)(size/8)),R2), Ivi=mont_s(IINV,R2);
    // forward twiddles (vectorized derivation)
    {const __m256i ninv=_mm256_set1_epi32(NINV),modv=_mm256_set1_epi32(MOD),modm1=_mm256_set1_epi32(MOD-1);
     const __m256i shuf=_mm256_setr_epi8(0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0, 0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0);
     u32*p1=tw[1],*p2=tw[2],*p3=tw[3],*p4=tw[4],*p5=tw[5],*p6=tw[6],*p7=tw[7];
     for(int len=size;len>=8;len>>=3){int s=len>>3,step=size/len;
       u32 ws=modpow(w,(u64)step); u32 wm=mont_s(ws,R2);
       p1[0]=mont_s(1,R2);
       for(int p=1;p<s;p++) p1[p]=mont_s(p1[p-1],wm);
       for(int p=0;p<s;p+=8){
         __m256i t1=_mm256_loadu_si256((__m256i*)(p1+p));
         __m256i t2=mont8(t1,t1,ninv,modv,modm1,shuf);
         __m256i t3=mont8(t2,t1,ninv,modv,modm1,shuf);
         __m256i t4=mont8(t3,t1,ninv,modv,modm1,shuf);
         __m256i t5=mont8(t4,t1,ninv,modv,modm1,shuf);
         __m256i t6=mont8(t5,t1,ninv,modv,modm1,shuf);
         __m256i t7=mont8(t6,t1,ninv,modv,modm1,shuf);
         _mm256_storeu_si256((__m256i*)(p2+p),t2); _mm256_storeu_si256((__m256i*)(p3+p),t3);
         _mm256_storeu_si256((__m256i*)(p4+p),t4); _mm256_storeu_si256((__m256i*)(p5+p),t5);
         _mm256_storeu_si256((__m256i*)(p6+p),t6); _mm256_storeu_si256((__m256i*)(p7+p),t7);}
       p1+=s;p2+=s;p3+=s;p4+=s;p5+=s;p6+=s;p7+=s;}}
    // inverse twiddles (vectorized derivation)
    {const __m256i ninv=_mm256_set1_epi32(NINV),modv=_mm256_set1_epi32(MOD),modm1=_mm256_set1_epi32(MOD-1);
     const __m256i shuf=_mm256_setr_epi8(0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0, 0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0);
     u32*p1=twi[1],*p2=twi[2],*p3=twi[3],*p4=twi[4],*p5=twi[5],*p6=twi[6],*p7=twi[7];
     for(int len=8;len<=size;len<<=3){int s=len>>3,step=size/len;
       u32 ws=modpow(iw,(u64)step); u32 wm=mont_s(ws,R2);
       p1[0]=mont_s(1,R2);
       for(int p=1;p<s;p++) p1[p]=mont_s(p1[p-1],wm);
       for(int p=0;p<s;p+=8){
         __m256i t1=_mm256_loadu_si256((__m256i*)(p1+p));
         __m256i t2=mont8(t1,t1,ninv,modv,modm1,shuf);
         __m256i t3=mont8(t2,t1,ninv,modv,modm1,shuf);
         __m256i t4=mont8(t3,t1,ninv,modv,modm1,shuf);
         __m256i t5=mont8(t4,t1,ninv,modv,modm1,shuf);
         __m256i t6=mont8(t5,t1,ninv,modv,modm1,shuf);
         __m256i t7=mont8(t6,t1,ninv,modv,modm1,shuf);
         _mm256_storeu_si256((__m256i*)(p2+p),t2); _mm256_storeu_si256((__m256i*)(p3+p),t3);
         _mm256_storeu_si256((__m256i*)(p4+p),t4); _mm256_storeu_si256((__m256i*)(p5+p),t5);
         _mm256_storeu_si256((__m256i*)(p6+p),t6); _mm256_storeu_si256((__m256i*)(p7+p),t7);}
       p1+=s;p2+=s;p3+=s;p4+=s;p5+=s;p6+=s;p7+=s;}}
    dif8(a,size,tw[1],tw[2],tw[3],tw[4],tw[5],tw[6],tw[7],Z1,Z3,Iv);
    dif8(b,size,tw[1],tw[2],tw[3],tw[4],tw[5],tw[6],tw[7],Z1,Z3,Iv);
    {const __m256i ninv=_mm256_set1_epi32(NINV),modv=_mm256_set1_epi32(MOD),modm1=_mm256_set1_epi32(MOD-1);
     const __m256i shuf=_mm256_setr_epi8(0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0, 0,1,2,3,8,9,10,11,0,0,0,0,0,0,0,0);
     for(int i=0;i<size;i+=8){__m256i x=_mm256_loadu_si256((__m256i*)(a+i));__m256i y=_mm256_loadu_si256((__m256i*)(b+i));_mm256_storeu_si256((__m256i*)(a+i),mont8(x,y,ninv,modv,modm1,shuf));}}
    dit8(a,size,twi[1],twi[2],twi[3],twi[4],twi[5],twi[6],twi[7],Z1i,Z3i,Ivi);
    char* out=D->stdout_ptr;
    int outn=n+m+1;
    for(int i=0;i<outn;i++){if(i)*out++=' ';out=putint_p(out,(int)a[i]);}
    *out++='\n';
    D->stdout_size=out-D->stdout_ptr;
    asm volatile("mov $60,%eax; xor %edi,%edi; syscall");
    return 0;
}

评测结果