#include<bits/stdc++.h>
#include<atcoder/all>
using namespace std;
namespace my{
using ml=atcoder::modint998244353;
auto&operator>>(istream&i,ml&x){int t;i>>t;x=t;return i;}
auto&operator<<(ostream&o,const ml&x){return o<<(int)x.val();}
#define eb emplace_back
#define LL(...) ll __VA_ARGS__;lin(__VA_ARGS__)
#define FO(n) for(ll ij=n;ij-->0;)
#define FOR(i,...) for(auto[i,i##stop,i##step]=range(0,__VA_ARGS__);i<i##stop;i+=i##step)
#define fo(i,...) FO##__VA_OPT__(R)(i __VA_OPT__(,__VA_ARGS__))
#define fe(a,i,...) for(auto&&__VA_OPT__([)i __VA_OPT__(,__VA_ARGS__]):a)
#define single_testcase void solve();}int main(){my::io();my::solve();}namespace my{
void io(){cin.tie(nullptr)->sync_with_stdio(0);cout<<fixed<<setprecision(15);}
using ll=long long;
using ull=unsigned long long;
using ulll=__uint128_t;
using lll=__int128_t;
istream&operator>>(istream&i,ulll&x){ull t;i>>t;x=t;return i;}
ostream&operator<<(ostream&o,const ulll&x){return(x<10?o:o<<x/10)<<ll(x%10);}
istream&operator>>(istream&i,lll&x){ll t;i>>t;x=t;return i;}
ostream&operator<<(ostream&o,const lll&x){return o<<string(x<0,'-')<<ulll(x>0?x:-x);}
constexpr auto range(bool s,auto...a){array<ll,3>r{0,0,1};ll I=0;((r[I++]=a),...);if(!s&&I==1)swap(r[0],r[1]);r[0]-=s;if(s)r[2]*=-1;return r;}
constexpr char newline=10;
constexpr char space=32;
lll pow(lll x,ll n){assert(n>=0);lll r=1;while(n)n&1?r*=x:r,x*=x,n>>=1;return r;}

auto&rev(auto&a){ranges::reverse(a);return a;}

template<ll k>auto pack_kth(const auto&...a){return get<k>(make_tuple(a...));}
template<class T,ll n>auto pack_slice(const auto&...a){return[&]<size_t...I>(index_sequence<I...>){return array<T,n>{get<I>(forward_as_tuple(a...))...};}(make_index_sequence<n>{});}

template<class V>concept vectorial=is_base_of_v<vector<typename V::value_type>,V>;
template<class T>struct vec_attr{using core_type=T;static constexpr int rank=0;};
template<vectorial V>struct vec_attr<V>{using core_type=typename vec_attr<typename V::value_type>::core_type;static constexpr int rank=vec_attr<typename V::value_type>::rank+1;};
template<class T>using core_t=vec_attr<T>::core_type;
template<class V>istream&operator>>(istream&i,vector<V>&v){fe(v,e)i>>e;return i;}
template<class V>ostream&operator<<(ostream&o,const vector<V>&v){fe(v,e)o<<e<<string(&e!=&v.back(),vectorial<V>?newline:space);return o;}

template<class V>struct vec;
template<ll rank,class T>struct tensor_helper{using type=vec<typename tensor_helper<rank-1,T>::type>;};
template<class T>struct tensor_helper<0,T>{using type=T;};
template<ll rank,class T>using tensor=typename tensor_helper<rank,T>::type;

template<class V>struct vec:vector<V>{
  using vector<V>::vector;
  vec(const vector<V>&v){vector<V>::operator=(v);}

  template<class...A>requires(sizeof...(A)>=3)vec(A...a){const ll n=sizeof...(a)-1;auto t=pack_slice<ll,n>(a...);ll s[n];fo(i,n)s[i]=t[i];*this=make_vec(s,pack_kth<n>(a...));}
  template<class T,ll n,ll i=0>static auto make_vec(const ll(&s)[n],T x){if constexpr(i==n-1)return vec<T>(s[i],x);else{auto X=make_vec<T,n,i+1>(s,x);return vec<decltype(X)>(s[i],X);}}

  vec&operator^=(const vec&u){this->insert(this->end(),u.begin(),u.end());return*this;}
  vec operator^(const vec&u)const{return vec{*this}^=u;}
  vec&operator+=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]+=u[i];return v;}
  vec&operator-=(const vec&u){vec&v=*this;assert(v.size()==u.size());fo(i,v.size())v[i]-=u[i];return v;}
  vec operator+(const vec&u)const{return vec{*this}+=u;}
  vec operator-(const vec&u)const{return vec{*this}-=u;}
  vec&operator++(){fe(*this,e)++e;return*this;}
  vec&operator--(){fe(*this,e)--e;return*this;}
  vec operator-()const{vec v=*this;fe(v,e)e=-e;return v;}

  vec&operator%=(auto M){vec&v=*this;fe(v,e)e%=M;return v;}
  vec operator%(auto M)const{return vec{*this}%=M;}

  ll size()const{return vector<V>::size();}

  void emplace_front(const V&x={}){this->emplace(this->begin(),x);}

  auto rev()const{vec v=*this;ranges::reverse(v);return v;}

  auto&segment_imos(ll a,ll b,core_t<V>x){
    if(a<size())(*this)[a]+=x;
    if(b<size())(*this)[b]-=x;
    return*this;
  }
};
template<class...A>requires(sizeof...(A)>=2)vec(A...a)->vec<tensor<sizeof...(a)-2,remove_reference_t<decltype(get<sizeof...(a)-1>(declval<tuple<A...>>()))>>>;
vec(ll)->vec<ll>;

void lin(auto&...a){(cin>>...>>a);}
auto sinen(const string&b="a"){string s;lin(s);vec<ll>r;fe(s,e)r.eb(b.size()==1?e-b[0]:b.find_first_of(e));return r;}
auto sinen(ll n,const string&b="a"){vec<vec<ll>>r;fo(n)r.eb(sinen(b));return r;}

void pp(auto&&...a){ll n=sizeof...(a);((cout<<a<<string(--n>0,space)),...);cout<<newline;}
single_testcase
void solve(){
  LL(N);
  auto s=sinen("0");
  rev(s);
  s.emplace_front();

  ml ans=0;
  fo(B,N){ // ビットごとの寄与を考える．
    vec dp(2,N+1,ml{}); // dp[j][i]:下からi個まで区切り方を決めていて，B桁目(0-indexed)のビットが立っているかの真偽値がjであるような区切り方の方法数．
    dp[0].segment_imos(0,1,1);

    // dp[i][j]の状態から新たに，
    // 長さB+1以上の連続部分列を切り出す：B桁目のビットが立っているかの真偽値njはnj=s[i+1+B]|jになる．
    // 長さB以下の連続部分列を切り出す：B桁目のビットが立っているかの真偽値はjのまま．新しい連続部分列はその真偽値に影響しないので．
    fo(i,N){
      fo(j,2){
        if(i+1+B<=N){
          ll nj=s[i+1+B]|j;
          dp[j].segment_imos(i+1,i+1+B,dp[j][i]); // 長さB+1以上
          dp[nj].segment_imos(i+1+B,N+1,dp[j][i]); // 長さB以下
        }else{
          dp[j].segment_imos(i+1,N+1,dp[j][i]); // 最大でも長さB以下しか切り出せない．
        }
      }

      fo(j,2)dp[j][i+1]+=dp[j][i];
    }

    ans+=dp[1][N]*ml{2}.pow(B);
  }

  pp(ans);
}}