結果
| 問題 | No.2580 Hyperinflation |
| ユーザー |
 tko919
|
| 提出日時 | 2023-12-11 05:35:23 |
| 言語 | C++17 (gcc 12.3.0 + boost 1.83.0) |
| 結果 |
AC
|
| 実行時間 | 3,609 ms / 4,000 ms |
| コード長 | 30,379 bytes |
| コンパイル時間 | 4,660 ms |
| コンパイル使用メモリ | 260,044 KB |
| 実行使用メモリ | 6,824 KB |
| 最終ジャッジ日時 | 2024-12-16 11:11:31 |
| 合計ジャッジ時間 | 45,965 ms |
|
ジャッジサーバーID （参考情報） |
judge2 / judge1 |
（要ログイン）
テストケース
テストケース表示| 入力 | 結果 | 実行時間 実行使用メモリ |
|---|---|---|
| testcase_00 | AC | 2 ms
6,820 KB |
| testcase_01 | AC | 2 ms
6,816 KB |
| testcase_02 | AC | 2 ms
6,816 KB |
| testcase_03 | AC | 2 ms
6,820 KB |
| testcase_04 | AC | 2 ms
6,820 KB |
| testcase_05 | AC | 2 ms
6,816 KB |
| testcase_06 | AC | 2 ms
6,820 KB |
| testcase_07 | AC | 2 ms
6,820 KB |
| testcase_08 | AC | 2 ms
6,820 KB |
| testcase_09 | AC | 2 ms
6,816 KB |
| testcase_10 | AC | 2 ms
6,820 KB |
| testcase_11 | AC | 2 ms
6,824 KB |
| testcase_12 | AC | 2 ms
6,816 KB |
| testcase_13 | AC | 19 ms
6,816 KB |
| testcase_14 | AC | 72 ms
6,816 KB |
| testcase_15 | AC | 47 ms
6,820 KB |
| testcase_16 | AC | 14 ms
6,816 KB |
| testcase_17 | AC | 3 ms
6,816 KB |
| testcase_18 | AC | 750 ms
6,816 KB |
| testcase_19 | AC | 749 ms
6,816 KB |
| testcase_20 | AC | 752 ms
6,820 KB |
| testcase_21 | AC | 751 ms
6,816 KB |
| testcase_22 | AC | 755 ms
6,820 KB |
| testcase_23 | AC | 3,586 ms
6,816 KB |
| testcase_24 | AC | 3,609 ms
6,816 KB |
| testcase_25 | AC | 3,602 ms
6,816 KB |
| testcase_26 | AC | 3,594 ms
6,816 KB |
| testcase_27 | AC | 3,593 ms
6,820 KB |
| testcase_28 | AC | 3,523 ms
6,816 KB |
| testcase_29 | AC | 3,506 ms
6,816 KB |
| testcase_30 | AC | 3,512 ms
6,816 KB |
| testcase_31 | AC | 3,516 ms
6,820 KB |
| testcase_32 | AC | 1,939 ms
6,820 KB |
| testcase_33 | AC | 1,946 ms
6,816 KB |
ソースコード
#line 1 "library/Template/template.hpp"
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) sort(ALL(v)),(v).erase(unique(ALL(v)),(v).end())
#define SZ(v) (int)v.size()
#define MIN(v) *min_element(ALL(v))
#define MAX(v) *max_element(ALL(v))
#define LB(v,x) int(lower_bound(ALL(v),(x))-(v).begin())
#define UB(v,x) int(upper_bound(ALL(v),(x))-(v).begin())
using ll=long long int;
using ull=unsigned long long;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;
template<typename T>inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<typename T>inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<typename T,typename U>T ceil(T x,U y){assert(y!=0); if(y<0)x=-x,y=-y; return (x>0?(x+y-1)/y:x/y);}
template<typename T,typename U>T floor(T x,U y){assert(y!=0); if(y<0)x=-x,y=-y; return (x>0?x/y:(x-y+1)/y);}
template<typename T>int popcnt(T x){return __builtin_popcountll(x);}
template<typename T>int topbit(T x){return (x==0?-1:63-__builtin_clzll(x));}
template<typename T>int lowbit(T x){return (x==0?-1:__builtin_ctzll(x));}
#line 2 "library/Utility/fastio.hpp"
#include <unistd.h>
class FastIO{
static constexpr int L=1<<16;
char rdbuf[L];
int rdLeft=0,rdRight=0;
inline void reload(){
int len=rdRight-rdLeft;
memmove(rdbuf,rdbuf+rdLeft,len);
rdLeft=0,rdRight=len;
rdRight+=fread(rdbuf+len,1,L-len,stdin);
}
inline bool skip(){
for(;;){
while(rdLeft!=rdRight and rdbuf[rdLeft]<=' ')rdLeft++;
if(rdLeft==rdRight){
reload();
if(rdLeft==rdRight)return false;
}
else break;
}
return true;
}
template<typename T,enable_if_t<is_integral<T>::value,int> =0>inline bool _read(T& x){
if(!skip())return false;
if(rdLeft+20>=rdRight)reload();
bool neg=false;
if(rdbuf[rdLeft]=='-'){
neg=true;
rdLeft++;
}
x=0;
while(rdbuf[rdLeft]>='0' and rdLeft<rdRight){
x=x*10+(neg?-(rdbuf[rdLeft++]^48):(rdbuf[rdLeft++]^48));
}
return true;
}
inline bool _read(__int128_t& x){
if(!skip())return false;
if(rdLeft+40>=rdRight)reload();
bool neg=false;
if(rdbuf[rdLeft]=='-'){
neg=true;
rdLeft++;
}
x=0;
while(rdbuf[rdLeft]>='0' and rdLeft<rdRight){
x=x*10+(neg?-(rdbuf[rdLeft++]^48):(rdbuf[rdLeft++]^48));
}
return true;
}
inline bool _read(__uint128_t& x){
if(!skip())return false;
if(rdLeft+40>=rdRight)reload();
x=0;
while(rdbuf[rdLeft]>='0' and rdLeft<rdRight){
x=x*10+(rdbuf[rdLeft++]^48);
}
return true;
}
template<typename T,enable_if_t<is_floating_point<T>::value,int> =0>inline bool _read(T& x){
if(!skip())return false;
if(rdLeft+20>=rdRight)reload();
bool neg=false;
if(rdbuf[rdLeft]=='-'){
neg=true;
rdLeft++;
}
x=0;
while(rdbuf[rdLeft]>='0' and rdbuf[rdLeft]<='9' and rdLeft<rdRight){
x=x*10+(rdbuf[rdLeft++]^48);
}
if(rdbuf[rdLeft]!='.')return true;
rdLeft++;
T base=.1;
while(rdbuf[rdLeft]>='0' and rdbuf[rdLeft]<='9' and rdLeft<rdRight){
x+=base*(rdbuf[rdLeft++]^48);
base*=.1;
}
if(neg)x=-x;
return true;
}
inline bool _read(char& x){
if(!skip())return false;
if(rdLeft+1>=rdRight)reload();
x=rdbuf[rdLeft++];
return true;
}
inline bool _read(string& x){
if(!skip())return false;
for(;;){
int pos=rdLeft;
while(pos<rdRight and rdbuf[pos]>' ')pos++;
x.append(rdbuf+rdLeft,pos-rdLeft);
if(rdLeft==pos)break;
rdLeft=pos;
if(rdLeft==rdRight)reload();
else break;
}
return true;
}
template<typename T>inline bool _read(vector<T>& v){
for(auto& x:v){
if(!_read(x))return false;
}
return true;
}
char wtbuf[L],tmp[50];
int wtRight=0;
inline void flush(){
fwrite(wtbuf,1,wtRight,stdout);
wtRight=0;
}
inline void _write(const char& x){
if(wtRight>L-32)flush();
wtbuf[wtRight++]=x;
}
inline void _write(const string& x){
for(auto& c:x)_write(c);
}
template<typename T,enable_if_t<is_integral<T>::value,int> =0>inline void _write(T x){
if(wtRight>L-32)flush();
if(x==0){
_write('0');
return;
}
else if(x<0){
_write('-');
if (__builtin_expect(x == std::numeric_limits<T>::min(), 0)) {
switch (sizeof(x)) {
case 2: _write("32768"); return;
case 4: _write("2147483648"); return;
case 8: _write("9223372036854775808"); return;
}
}
x=-x;
}
int pos=0;
while(x!=0){
tmp[pos++]=char((x%10)|48);
x/=10;
}
rep(i,0,pos)wtbuf[wtRight+i]=tmp[pos-1-i];
wtRight+=pos;
}
inline void _write(__int128_t x){
if(wtRight>L-40)flush();
if(x==0){
_write('0');
return;
}
else if(x<0){
_write('-');
x=-x;
}
int pos=0;
while(x!=0){
tmp[pos++]=char((x%10)|48);
x/=10;
}
rep(i,0,pos)wtbuf[wtRight+i]=tmp[pos-1-i];
wtRight+=pos;
}
inline void _write(__uint128_t x){
if(wtRight>L-40)flush();
if(x==0){
_write('0');
return;
}
int pos=0;
while(x!=0){
tmp[pos++]=char((x%10)|48);
x/=10;
}
rep(i,0,pos)wtbuf[wtRight+i]=tmp[pos-1-i];
wtRight+=pos;
}
template<typename T>inline void _write(const vector<T>& v){
rep(i,0,v.size()){
if(i)_write(' ');
_write(v[i]);
}
}
public:
FastIO(){}
~FastIO(){flush();}
inline void read(){}
template <typename Head, typename... Tail>inline void read(Head& head,Tail&... tail){
assert(_read(head));
read(tail...);
}
template<bool ln=true,bool space=false>inline void write(){if(ln)_write('\n');}
template <bool ln=true,bool space=false,typename Head, typename... Tail>inline void write(const Head& head,const Tail&... tail){
if(space)_write(' ');
_write(head);
write<ln,true>(tail...);
}
};
/**
* @brief Fast IO
*/
#line 3 "sol.cpp"
#line 2 "library/Math/modint.hpp"
template<int mod=1000000007>struct fp {
int v;
static constexpr int get_mod(){return mod;}
int inv() const{
int tmp,a=v,b=mod,x=1,y=0;
while(b)tmp=a/b,a-=tmp*b,swap(a,b),x-=tmp*y,swap(x,y);
if(x<0){x+=mod;} return x;
}
fp(ll x=0){init(x%mod+mod);}
fp& init(ll x){v=(x<mod?x:x-mod); return *this;}
fp operator-()const{return fp()-*this;}
fp pow(ll t){assert(t>=0); fp res=1,b=*this; while(t){if(t&1)res*=b;b*=b;t>>=1;} return res;}
fp& operator+=(const fp& x){return init(v+x.v);}
fp& operator-=(const fp& x){return init(v+mod-x.v);}
fp& operator*=(const fp& x){v=ll(v)*x.v%mod; return *this;}
fp& operator/=(const fp& x){v=ll(v)*x.inv()%mod; return *this;}
fp operator+(const fp& x)const{return fp(*this)+=x;}
fp operator-(const fp& x)const{return fp(*this)-=x;}
fp operator*(const fp& x)const{return fp(*this)*=x;}
fp operator/(const fp& x)const{return fp(*this)/=x;}
bool operator==(const fp& x)const{return v==x.v;}
bool operator!=(const fp& x)const{return v!=x.v;}
friend istream& operator>>(istream& is,fp& x){return is>>x.v;}
friend ostream& operator<<(ostream& os,const fp& x){return os<<x.v;}
};
template<typename T>T Inv(ll n){
static const int md=T::get_mod();
static vector<T> buf({0,1});
assert(n>0);
n%=md;
while(SZ(buf)<=n){
int k=SZ(buf),q=(md+k-1)/k;
buf.push_back(buf[k*q-md]*q);
}
return buf[n];
}
template<typename T>T Fact(ll n,bool inv=0){
static const int md=T::get_mod();
static vector<T> buf({1,1}),ibuf({1,1});
assert(n>=0 and n<md);
while(SZ(buf)<=n){
buf.push_back(buf.back()*SZ(buf));
ibuf.push_back(ibuf.back()*Inv<T>(SZ(ibuf)));
}
return inv?ibuf[n]:buf[n];
}
template<typename T>T nPr(int n,int r,bool inv=0){if(n<0||n<r||r<0)return 0; return Fact<T>(n,inv)*Fact<T>(n-r,inv^1);}
template<typename T>T nCr(int n,int r,bool inv=0){if(n<0||n<r||r<0)return 0; return Fact<T>(n,inv)*Fact<T>(r,inv^1)*Fact<T>(n-r,inv^1);}
template<typename T>T nHr(int n,int r,bool inv=0){return nCr<T>(n+r-1,r,inv);}
/**
* @brief Modint
*/
#line 2 "library/Convolution/ntt.hpp"
template<typename T,unsigned p=3>struct NTT{
vector<T> rt,irt;
NTT(int lg=21){
unsigned m=T::get_mod()-1; T prt=p;
rt.resize(lg); irt.resize(lg);
rep(k,0,lg){
rt[k]=-prt.pow(m>>(k+2));
irt[k]=rt[k].inv();
}
}
void ntt(vector<T>& f,bool inv=0){
int n=f.size();
if(inv){
for(int m=1;m<n;m<<=1){ T w=1;
for(int s=0,t=0;s<n;s+=m*2){
for(int i=s,j=s+m;i<s+m;i++,j++){
auto x=f[i],y=f[j];
f[i]=x+y; f[j]=(x-y)*w;
} w*=irt[__builtin_ctz(++t)];
}
} T mul=T(n).inv(); rep(i,0,n)f[i]*=mul;
}else{
for(int m=n;m>>=1;){ T w=1;
for(int s=0,t=0;s<n;s+=m*2){
for(int i=s,j=s+m;i<s+m;i++,j++){
auto x=f[i],y=f[j]*w;
f[i]=x+y; f[j]=x-y;
} w*=rt[__builtin_ctz(++t)];
}
}
}
}
vector<T> mult(const vector<T>& a,const vector<T>& b,bool same=0){
if(a.empty() or b.empty())return vector<T>();
int n=a.size()+b.size()-1,m=1<<__lg(n*2-1);
vector<T> res(m); rep(i,0,a.size()){res[i]=a[i];} ntt(res);
if(same)rep(i,0,m)res[i]*=res[i];
else{
vector<T> c(m); rep(i,0,b.size())c[i]=b[i];
ntt(c); rep(i,0,m)res[i]*=c[i];
} ntt(res,1); res.resize(n); return res;
}
};
/**
* @brief Number Theoretic Transform
*/
#line 2 "library/FPS/fps.hpp"
template<typename T>struct Poly:vector<T>{
Poly(int n=0){this->assign(n,T());}
Poly(const initializer_list<T> f):vector<T>::vector(f){}
Poly(const vector<T>& f){this->assign(ALL(f));}
T eval(const T& x){
T res;
for(int i=this->size()-1;i>=0;i--)res*=x,res+=this->at(i);
return res;
}
Poly rev()const{Poly res=*this; reverse(ALL(res)); return res;}
void shrink(){while(!this->empty() and this->back()==0)this->pop_back();}
Poly operator>>(int sz)const{
if((int)this->size()<=sz)return {};
Poly ret(*this);
ret.erase(ret.begin(),ret.begin()+sz);
return ret;
}
Poly operator<<(int sz)const{
Poly ret(*this);
ret.insert(ret.begin(),sz,T(0));
return ret;
}
vector<T> mult(const vector<T>& a,const vector<T>& b,bool same=0)const{
if(a.empty() or b.empty())return vector<T>();
int n=a.size()+b.size()-1,m=1<<__lg(n*2-1);
vector<T> res(m);
rep(i,0,a.size())res[i]=a[i];
NTT(res,0);
if(same)rep(i,0,m)res[i]*=res[i];
else{
vector<T> c(m);
rep(i,0,b.size())c[i]=b[i];
NTT(c,0);
rep(i,0,m)res[i]*=c[i];
}
NTT(res,1);
res.resize(n);
return res;
}
Poly square()const{return Poly(mult(*this,*this,1));}
Poly operator-()const{return Poly()-*this;}
Poly operator+(const Poly& g)const{return Poly(*this)+=g;}
Poly operator+(const T& g)const{return Poly(*this)+=g;}
Poly operator-(const Poly& g)const{return Poly(*this)-=g;}
Poly operator-(const T& g)const{return Poly(*this)-=g;}
Poly operator*(const Poly& g)const{return Poly(*this)*=g;}
Poly operator*(const T& g)const{return Poly(*this)*=g;}
Poly operator/(const Poly& g)const{return Poly(*this)/=g;}
Poly operator/(const T& g)const{return Poly(*this)/=g;}
Poly operator%(const Poly& g)const{return Poly(*this)%=g;}
pair<Poly,Poly> divmod(const Poly& g)const{
Poly q=*this/g,r=*this-g*q;
r.shrink();
return {q,r};
}
Poly& operator+=(const Poly& g){
if(g.size()>this->size())this->resize(g.size());
rep(i,0,g.size()){(*this)[i]+=g[i];} return *this;
}
Poly& operator+=(const T& g){
if(this->empty())this->push_back(0);
(*this)[0]+=g; return *this;
}
Poly& operator-=(const Poly& g){
if(g.size()>this->size())this->resize(g.size());
rep(i,0,g.size()){(*this)[i]-=g[i];} return *this;
}
Poly& operator-=(const T& g){
if(this->empty())this->push_back(0);
(*this)[0]-=g; return *this;
}
Poly& operator*=(const Poly& g){
*this=mult(*this,g,0);
return *this;
}
Poly& operator*=(const T& g){
rep(i,0,this->size())(*this)[i]*=g;
return *this;
}
Poly& operator/=(const Poly& g){
if(g.size()>this->size()){
this->clear(); return *this;
}
Poly g2=g;
reverse(ALL(*this));
reverse(ALL(g2));
int n=this->size()-g2.size()+1;
this->resize(n); g2.resize(n);
*this*=g2.inv(); this->resize(n);
reverse(ALL(*this));
shrink();
return *this;
}
Poly& operator/=(const T& g){
rep(i,0,this->size())(*this)[i]/=g;
return *this;
}
Poly& operator%=(const Poly& g){*this-=*this/g*g; shrink(); return *this;}
Poly diff()const{
Poly res(this->size()-1);
rep(i,0,res.size())res[i]=(*this)[i+1]*(i+1);
return res;
}
Poly inte()const{
Poly res(this->size()+1);
for(int i=res.size()-1;i;i--)res[i]=(*this)[i-1]/i;
return res;
}
Poly log()const{
assert(this->front()==1); const int n=this->size();
Poly res=diff()*inv(); res=res.inte();
res.resize(n); return res;
}
Poly shift(const int& c)const{
const int n=this->size();
Poly res=*this,g(n); g[0]=1; rep(i,1,n)g[i]=g[i-1]*c/i;
vector<T> fact(n,1);
rep(i,0,n){
if(i)fact[i]=fact[i-1]*i;
res[i]*=fact[i];
}
res=res.rev();
res*=g;
res.resize(n);
res=res.rev();
rep(i,0,n)res[i]/=fact[i];
return res;
}
Poly inv()const{
const int n=this->size();
Poly res(1); res.front()=T(1)/this->front();
for(int k=1;k<n;k<<=1){
Poly f(k*2),g(k*2);
rep(i,0,min(n,k*2))f[i]=(*this)[i];
rep(i,0,k)g[i]=res[i];
NTT(f,0);
NTT(g,0);
rep(i,0,k*2)f[i]*=g[i];
NTT(f,1);
rep(i,0,k){f[i]=0; f[i+k]=-f[i+k];}
NTT(f,0);
rep(i,0,k*2)f[i]*=g[i];
NTT(f,1);
rep(i,0,k)f[i]=res[i];
swap(res,f);
} res.resize(n); return res;
}
Poly exp()const{
const int n=this->size();
if(n==1)return Poly({T(1)});
Poly b(2),c(1),z1,z2(2);
b[0]=c[0]=z2[0]=z2[1]=1; b[1]=(*this)[1];
for(int k=2;k<n;k<<=1){
Poly y=b;
y.resize(k*2);
NTT(y,0);
z1=z2;
Poly z(k);
rep(i,0,k)z[i]=y[i]*z1[i];
NTT(z,1);
rep(i,0,k>>1)z[i]=0;
NTT(z,0);
rep(i,0,k)z[i]*=-z1[i];
NTT(z,1);
c.insert(c.end(),z.begin()+(k>>1),z.end());
z2=c;
z2.resize(k*2);
NTT(z2,0);
Poly x=*this;
x.resize(k);
x=x.diff();x.resize(k);
NTT(x,0);
rep(i,0,k)x[i]*=y[i];
NTT(x,1);
Poly bb=b.diff();
rep(i,0,k-1)x[i]-=bb[i];
x.resize(k*2);
rep(i,0,k-1){x[k+i]=x[i]; x[i]=0;}
NTT(x,0);
rep(i,0,k*2)x[i]*=z2[i];
NTT(x,1);
x.pop_back();
x=x.inte();
rep(i,k,min(n,k*2))x[i]+=(*this)[i];
rep(i,0,k)x[i]=0;
NTT(x,0);
rep(i,0,k*2)x[i]*=y[i];
NTT(x,1);
b.insert(b.end(),x.begin()+k,x.end());
} b.resize(n); return b;
}
Poly pow(ll t){
if(t==0){
Poly res(this->size()); res[0]=1;
return res;
}
int n=this->size(),k=0; while(k<n and (*this)[k]==0)k++;
Poly res(n); if(__int128_t(t)*k>=n)return res;
n-=t*k; Poly g(n); T c=(*this)[k],ic=c.inv();
rep(i,0,n)g[i]=(*this)[i+k]*ic;
g=g.log(); for(auto& x:g)x*=t; g=g.exp();
c=c.pow(t); rep(i,0,n)res[i+t*k]=g[i]*c; return res;
}
void NTT(vector<T>& a,bool inv)const;
};
/**
* @brief Formal Power Series (NTT-friendly mod)
*/
#line 7 "sol.cpp"
using Fp=fp<998244353>;
NTT<Fp,3> ntt;
template<>void Poly<Fp>::NTT(vector<Fp>& v,bool inv)const{return ntt.ntt(v,inv);}
#line 2 "library/FPS/famous.hpp"
template<typename T>vector<T> Bernoulli(int n){
Poly<T> f(n+1);
rep(i,0,n+1)f[i]=Fact<T>(i+1,1);
f=f.inv();
rep(i,0,n+1)f[i]*=Fact<T>(i);
return f;
}
template<typename T>vector<T> Partition(int n){
Poly<T> f(n+1);
f[0]=1;
rep(k,1,n+1){
if(1LL*k*(3*k+1)/2<=n)f[1LL*k*(3*k+1)/2]+=(k&1?-1:1);
if(1LL*k*(3*k-1)/2<=n)f[1LL*k*(3*k-1)/2]+=(k&1?-1:1);
}
return f.inv();
}
template<typename T>vector<T> StirlingNumber1st(int n){
if(n==0)return Poly<T>({T(1)});
Poly<T> f({T(0),T(1)});
for(int LG=topbit(n)-1;LG>=0;LG--){
int m=n>>LG;
f*=f.shift(m>>1);
if(m&1)f=(f<<1)+f*T(m-1);
}
rep(i,0,n+1)if((n-i)&1)f[i]=-f[i];
return f;
}
template<typename T>vector<T> StirlingNumber2nd(int n){
if(n==0)return Poly<T>({T(1)});
Poly<T> f(n+1),g(n+1);
rep(i,0,n+1){
f[i]=Fp(i).pow(n)*Fact<T>(i,1);
g[i]=Fact<T>(i,1);
if(i&1)g[i]=-g[i];
}
f*=g;
f.resize(n+1);
return f;
}
template<typename T>vector<T> Bell(int n){
Poly<T> f(n+1);
if(n)f[1]=1;
rep(i,2,n+1)f[i]=f[i-1]/i;
f=f.exp();
T fac=1;
rep(i,2,n+1)fac*=i,f[i]*=fac;
return f;
}
/**
* @brief Famous Sequence
*/
#line 12 "sol.cpp"
template<typename T>Poly<T> PrefixSum(Poly<T>& f){
if(f.empty())return {};
int n=f.size();
auto ber=Bernoulli<T>(n-1);
if(n>=2)ber[1]=-ber[1];
Poly<T> base(n);
rep(i,0,n){
ber[i]*=Fact<T>(i,1);
if(i)base[i]=f[i]*Fact<T>(i);
}
reverse(ALL(ber));
base*=ber;
Poly<T> ret(n+1);
ret[0]=f[0],ret[1]=f[0];
rep(i,1,n+1){
ret[i]+=base[i+n-2]*Fact<T>(i,1);
}
return ret;
}
#line 2 "library/Convolution/fft.hpp"
namespace FFT{
struct C{
double x,y;
C(double _x=0,double _y=0):x(_x),y(_y){}
C operator~()const{return C(x,-y);}
C operator*(const C& c)const{return C(x*c.x-y*c.y,x*c.y+y*c.x);}
C operator+(const C& c)const{return C(x+c.x,y+c.y);}
C operator-(const C& c)const{return C(x-c.x,y-c.y);}
};
vector<vector<C>> w(1,vector<C>(1,1));
void init(int lg){
for(int d=1,m=1;d<=lg;d++,m<<=1)if(d>=(int)w.size()){
w.emplace_back(m);
const double th=M_PI/m;
for(int i=0;i<m;i++)w[d][i]=(i&1?C(cos(th*i),sin(th*i)):w[d-1][i>>1]);
}
}
void fft(vector<C>& f,bool inv){
const int n=f.size(); const int lg=__lg(n);
if(lg>=(int)w.size())init(lg);
if(inv){
for(int k=1;k<=lg;k++){
const int d=1<<(k-1);
for(int s=0;s<n;s+=2*d){
for(int i=s;i<s+d;i++){
C x=f[i],y=~w[k][i-s]*f[d+i];
f[i]=x+y; f[d+i]=x-y;
}
}
}
}
else{
for(int k=lg;k;k--){
const int d=1<<(k-1);
for(int s=0;s<n;s+=2*d){
for(int i=s;i<s+d;i++){
C x=f[i],y=f[d+i];
f[i]=x+y; f[d+i]=w[k][i-s]*(x-y);
}
}
}
}
}
template<typename T>vector<T> mult(const vector<T>& a,const vector<T>& b){
const int as=a.size(); const int bs=b.size();
if(!as or !bs)return {};
const int cs=as+bs-1; vector<T> c(cs);
if(max(as,bs)<16){
for(int i=0;i<as;i++)for(int j=0;j<bs;j++){
c[i+j]+=(int)a[i]*b[j];
}
return c;
}
const int n=1<<__lg(2*cs-1); vector<C> f(n);
for(int i=0;i<as;i++)f[i].x=a[i];
for(int i=0;i<bs;i++)f[i].y=b[i];
fft(f,0); static const C rad(0,-.25);
for(int i=0;i<n;i++){
int j=i?i^((1<<__lg(i))-1):0;
if(i>j)continue;
C x=f[i]+~f[j],y=f[i]-~f[j];
f[i]=x*y*rad; f[j]=~f[i];
}
fft(f,1); for(int i=0;i<cs;i++)c[i]=round(f[i].x/n);
return c;
}
template<typename T>vector<T> square(const vector<T>& a){
const int as=a.size(); if(!as)return {};
const int cs=as*2-1; vector<T> c(cs);
if(as<16){
for(int i=0;i<as;i++)for(int j=0;j<as;j++){
c[i+j]+=(int)a[i]*a[j];
}
return c;
}
const int n=1<<__lg(cs*2-1); vector<C> f(n);
for(int i=0;i<as;i++)f[i].x=a[i];
fft(f,0); for(int i=0;i<n;i++)f[i]=f[i]*f[i];
fft(f,1); for(int i=0;i<cs;i++)c[i]=round(f[i].x/n);
return c;
}
}
/**
* @brief Fast Fourier Transform
*/
#line 3 "library/Math/bigint.hpp"
template<int D>struct bigint{
static const int B=pow(10,D);
int sign=0; vector<ll> v;
static int get_D(){return D;}
static int get_B(){return B;}
bigint(ll x=0){
if(x<0)x*=-1,sign=1;
while(x){v.push_back(x%B); x/=B;}
}
bigint(string s){
if(s[0]=='-')s.erase(s.begin()),sign=1;
int add=0,cnt=0,base=1;
while(s.size()){
if(cnt==D){
v.push_back(add);
cnt=0; add=0; base=1;
}
add=(s.back()-'0')*base+add;
cnt++; base*=10; s.pop_back();
} if(add)v.push_back(add);
}
bigint operator-()const{bigint res=*this; res.sign^=1;return res;}
bigint abs()const{bigint res=*this; res.sign=0; return res;}
ll& operator[](const int i){return v[i];}
int size()const{return v.size();}
void norm(){
rep(i,0,v.size()-1){
if(v[i]>=0){v[i+1]+=v[i]/B; v[i]%=B;}
else{int c=(-v[i]+B-1)/B; v[i]+=c*B; v[i+1]-=c;}
}
while(!v.empty() and v.back()>=B){
int c=v.back()/B;
v.back()%=B; v.push_back(c);
}
while(!v.empty() and v.back()==0)v.pop_back();
}
string to_str()const{
string res;
if(v.empty())return "0";
if(sign)res+='-';
res+=to_string(v.back());
for(int i=v.size()-2;i>=0;i--){
string add; int w=v[i];
rep(_,0,D){
add+=('0'+(w%10)); w/=10;
} reverse(ALL(add)); res+=add;
} return res;
}
friend istream& operator>>(istream& is,bigint<D>& x){
string tmp; is>>tmp; x=bigint(tmp); return is;
}
friend ostream& operator<<(ostream& os,bigint<D> x){
os<<x.to_str(); return os;
}
bigint& operator<<=(const int& x){
if(!v.empty()){
vector<ll> add(x,0);
v.insert(v.begin(),ALL(add));
} return *this;
}
bigint& operator>>=(const int& x){
v=vector<ll>(v.begin()+min(x,(int)v.size()),v.end());
return *this;
}
bigint& operator+=(const bigint& x){
if(sign!=x.sign){*this-=(-x); return *this;}
if((int)v.size()<(int)x.size())v.resize(x.size(),0);
rep(i,0,x.size()){v[i]+=x.v[i];} norm(); return *this;
}
bigint& operator-=(const bigint& x){
if(sign!=x.sign){*this+=(-x); return *this;}
if(abs()<x.abs()){*this=x-(*this); sign^=1; return *this;}
rep(i,0,x.size()){v[i]-=x.v[i];} norm(); return *this;
}
bigint& operator*=(const bigint& x){
sign^=x.sign;
auto v1=FFT::mult(v,x.v);
v.assign(v1.size(),0);
rep(i,0,v1.size()){
ll val=v1[i];
for(int j=i;val;j++){
if(j==(int)v.size())v.push_back(0);
v[j]+=val%B; val/=B;
}
} norm(); return *this;
}
bigint& operator/=(const bigint& x){
bigint a=abs(),b=x.abs(); sign^=x.sign;
if(a<b)return *this=bigint();
if(b==bigint(1))return *this=a;
int d=a.size()-b.size()+1;
bigint inv(1LL*B*B/b.v.back()),pre;
int cur=2,bcur=1; pre=bigint(0);
while(inv!=pre or bcur<b.size()){
bcur=min(bcur<<1,b.size());
bigint c; c.v=vector<ll>(b.v.end()-bcur,b.v.end());
pre=inv; inv*=((bigint(2)<<(cur+bcur-1))-inv*c);
cur=min(cur<<1,d);
inv.v=vector<ll>(inv.v.end()-cur,inv.v.end());
}
inv.v=vector<ll>(inv.v.end()-d,inv.v.end());
bigint res=a*inv; res>>=(a.size());
bigint mul=res*b;
while(mul+b<=a){res+=bigint(1); mul+=b;}
v=res.v; return *this;
}
bigint& operator%=(const bigint& x){
bigint div=(*this)/x; (*this)-=div*x; return *this;
}
bigint square(){
bigint res=*this; res.sign=0;
auto v1=FFT::mult(v,v);
res.v.assign(v1.size(),0);
rep(i,0,v1.size()){
ll val=v1[i];
for(int j=i;val;j++){
if(j==(int)res.v.size())res.v.push_back(0);
res.v[j]+=val%B; val/=B;
}
} res.norm(); return res;
}
bigint mul(ll x){
bigint res=*this; if(x<0)res.sign^=1,x*=-1;
for(int i=res.v.size()-1;i>=0;i--)res.v[i]*=x;
res.norm(); return res;
}
bigint div(ll x){
bigint res=*this; if(x<0)res.sign^=1,x*=-1;
for(int i=res.v.size()-1;i>=0;i--){
if(res.v[i]%x!=0 and i!=0){res.v[i-1]+=B*(res.v[i]%x);} res.v[i]/=x;
} res.norm(); return res;
}
bigint operator<<(const int& x)const{return bigint(*this)<<=x;}
bigint operator>>(const int& x)const{return bigint(*this)>>=x;}
bigint operator+(const bigint& x)const{return bigint(*this)+=x;}
bigint operator-(const bigint& x)const{return bigint(*this)-=x;}
bigint operator*(const bigint& x)const{return bigint(*this)*=x;}
bigint operator/(const bigint& x)const{return bigint(*this)/=x;}
bigint operator%(const bigint& x)const{return bigint(*this)%=x;}
bool operator<(const bigint& x)const{
if(sign!=x.sign)return sign>x.sign;
if((int)v.size()!=(int)x.size()){
if(sign)return (int)x.size()<(int)v.size();
else return (int)v.size()<(int)x.size();
}
for(int i=v.size()-1;i>=0;i--)if(v[i]!=x.v[i]){
if(sign)return x.v[i]<v[i];
else return v[i]<x.v[i];
}
return false;
}
bool operator>(const bigint& x)const{return x<*this;}
bool operator<=(const bigint& x)const{return !(*this>x);}
bool operator>=(const bigint& x)const{return !(*this<x);}
bool operator==(const bigint& x)const{return !(*this<x) and !(*this>x);}
bool operator!=(const bigint& x)const{return !(*this==x);}
};
typedef bigint<4> Bigint;
struct Bigfloat{
Bigint v; int p=0;
Bigfloat(){}
Bigfloat(const ll& _v){v=Bigint(_v);}
Bigfloat(const Bigint& _v,int _p=0):v(_v),p(_p){}
void set(int _p){if(p<_p){v>>=(_p-p);} else{v<<=(p-_p);} p=_p;}
Bigint to_int()const{if(p<0)return v>>(-p); else return v<<p;}
Bigfloat& operator+=(const Bigfloat& x){
if(p>x.p)set(x.p),v+=x.v;
else v+=x.v<<(x.p-p);
return *this;
}
Bigfloat& operator-=(const Bigfloat& x){
if(p>x.p)set(x.p),v-=x.v;
else v-=x.v<<(x.p-p);
return *this;
}
Bigfloat square(){Bigfloat res=*this; res.p*=2; res.v=res.v.square(); return res;}
Bigfloat mul(ll x){Bigfloat res=*this; res.v=v.mul(x); return res;}
Bigfloat div(ll x){Bigfloat res=*this; res.v=v.div(x); return res;}
Bigfloat& operator*=(const Bigfloat& x){p+=x.p; v*=x.v; return *this;}
Bigfloat& operator/=(const Bigfloat& x){p-=x.p; v/=x.v; return *this;}
Bigfloat operator+(const Bigfloat& x)const{return Bigfloat(*this)+=x;}
Bigfloat operator-(const Bigfloat& x)const{return Bigfloat(*this)-=x;}
Bigfloat operator*(const Bigfloat& x)const{return Bigfloat(*this)*=x;}
Bigfloat operator/(const Bigfloat& x)const{return Bigfloat(*this)/=x;}
string to_str(){
string res=v.abs().to_str(); int d=Bigint::get_D();
if(p*d>0)res+=string(p*d,'0');
else if(-p*d>=1 and -p*d<(int)res.size()){
res=res.substr(0,(int)res.size()+p*d)+'.'+res.substr((int)res.size()+p*d);
}
else if(-p*d>=(int)res.size())res="0."+string(-p*d-(int)res.size(),'0')+res;
if(v.sign){res.insert(res.begin(),'-');} return res;
}
friend ostream& operator<<(ostream& os,Bigfloat x){
os<<x.to_str(); return os;
}
};
Bigfloat sqrt(ll n,int d){
Bigfloat res(Bigint((ll)sqrt(1LL*Bigint::get_B()*Bigint::get_B()/n)),-1),pre;
int cur=1;
while(pre.v!=res.v){
cur=min(cur<<1,d);
pre=res; Bigfloat add=Bigfloat(1)-res.square().mul(n);
add.set(-cur); res+=(res*add).div(2); res.set(-cur);
} return res.mul(n);
}
/**
* @brief Big Integer(Float)
*/
#line 34 "sol.cpp"
FastIO io;
int main(){
int n;
io.read(n);
vector<int> a(n-1);
io.read(a);
string s;
io.read(s);
Bigint M(s);
Poly<Fp> f({1});
rep(i,0,n-1){
Bigint q=M/a[i];
ll r=stoll((M-q*a[i]).to_str());
swap(M,q);
f=f.shift(r);
Fp base=1;
rep(j,0,f.size()){
f[j]*=base;
base*=a[i];
}
f=PrefixSum(f);
}
ll x=stoll((M%Fp::get_mod()).to_str());
Fp ret=f.eval(x);
io.write(ret.v);
return 0;
}