/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T> 
using ordered_set = tree<T, null_type,less<T>, rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k)  returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {
    os << "[ ";
    for(auto v : V) os << v << " ";
    return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
    os << "{ ";
    for(auto s:S) os<<s<<" ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
    return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, unordered_map<L,R> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream &os, gp_hash_table<L,R,chash> M) {
    os << "{ ";
    for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
    return os<<"}";
}

#define TRACE
#ifdef TRACE
    #define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
    template <typename Arg1>
    void __f(const char* name, Arg1&& arg1){
        cerr << name << " : " << arg1 << endl;
    }
    template <typename Arg1, typename... Args>
    void __f(const char* names, Arg1&& arg1, Args&&... args){
        const char* comma = strchr(names + 1, ',');
        cerr.write(names, comma - names) << " : " << arg1<<" | ";
        __f(comma+1, args...);
    }
#else
    #define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){
    uniform_int_distribution<int64_t> generator(l,r);
    return generator(rng);
}
inline int64_t random_long(){
    uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
    return generator(rng);
}


/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int,int> pii;

#define ll long long
#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod = 998244353;
template<const int MOD>
struct modular_int{
	int x;
	static vector<int> inverse_list ;
	const static int inverse_limit;
	modular_int(){
		x = 0;
	}
	template<typename T>  
	modular_int(const T z){
		x = (z%MOD);
		if (x < 0) x += MOD; 	
	}
	modular_int(const modular_int<MOD>* z){
		x = z->x;
	}
	modular_int(const modular_int<MOD>& z){
		x = z.x;
	}
	modular_int operator - (const modular_int<MOD>& m) const{
		modular_int<MOD> U;
		U.x = x - m.x;
		if (U.x < 0) U.x += MOD;
		return U;
	}
	modular_int operator + (const modular_int<MOD>& m) const{
		modular_int<MOD> U;
		U.x = x + m.x;
		if (U.x >= MOD) U.x -= MOD;
		return U;
	}
	modular_int& operator -= (const modular_int<MOD>& m){
		x -= m.x;
		if (x < 0) x += MOD;
		return *this;
	}	
	modular_int& operator += (const modular_int<MOD>& m){
		x += m.x;
		if (x >= MOD) x -= MOD;
		return *this;
	}	
	modular_int operator * (const modular_int<MOD>& m) const{
		modular_int<MOD> U;
		U.x = (x* 1ull * m.x) %MOD;
		return U;
	}
	modular_int& operator *= (const modular_int<MOD>& m){
		x = (x * 1ull * m.x)%MOD;
		return *this;
	}
	template<typename T>
	friend modular_int operator + (const T &l, const modular_int<MOD>& p){
		return (modular_int<MOD>(l) + p);
	}
	template<typename T>
	friend modular_int operator - (const T &l, const modular_int<MOD>& p){
		return (modular_int<MOD>(l) - p);
	}
	template<typename T>
	friend modular_int operator * (const T &l, const modular_int<MOD>& p){
		return (modular_int<MOD>(l) * p);
	}
	template<typename T>
	friend modular_int operator / (const T &l, const modular_int<MOD>& p){
		return (modular_int<MOD>(l) / p);
	}

	int value() const{
		return x;
	}

	template<typename T>
	modular_int operator ^ (T power) const{
		modular_int<MOD> ans;
		ans.x = 1;
		modular_int<MOD> curr(this);
		// Prime Mods
		if (power >= MOD){
			power %= (MOD - 1);
		}

		while( power > 0){
			if (power&1){
				ans *= curr;
			}
			power >>= 1;
			if (power) curr *= curr;

		}
		return ans;
	}

	template<typename T>
	modular_int pow(T x){
		return (*this)^x;
	}

	
	pair<long long,long long> gcd(const int a, const int b) const {
		if (b==0) return {1,0}; 
		pair<long long,long long> c = gcd(b , a%b);
		return { c.second , c.first - (a/b)*c.second}; 
	}

	inline void init_inverse_list() const {
		
		vector<int>& dp = modular_int<MOD>::inverse_list;
		dp.resize(modular_int<MOD>::inverse_limit + 1);
		int n = modular_int<MOD>::inverse_limit;
		dp[0] = 1;
		if (n > 1) dp[1] = 1;
		for(int i = 2; i <= n; ++i){
			dp[i] = (dp[MOD%i] * 1ull *(MOD - MOD/i))%MOD;
		}
	
	}
	modular_int<MOD> get_inv() const {
		if (modular_int<MOD>::inverse_list.size() < modular_int<MOD>::inverse_limit + 1) init_inverse_list();

		if (this->x <= modular_int<MOD>::inverse_limit){
			return modular_int<MOD>::inverse_list[this->x];
		}


		pair<long long,long long> G = gcd(this->x,MOD);

		return modular_int<MOD>(G.first);
	}
	modular_int operator / (const modular_int<MOD>& m) const{
		modular_int<MOD> U(this);
		U *= m.get_inv();
		return U;
	}
	modular_int& operator /= (const modular_int<MOD>& m){
		(*this) *= m.get_inv();
		return *this;
	}


	bool operator==(const modular_int<MOD>& m) const{
		return x == m.x;
	}
	template<typename T>
	bool operator == (const T& x) const{
		return x== (modular_int<MOD>(x)).x;
	}
	template<typename T>
	friend bool operator == (const T& x, const modular_int<MOD>& m) {
		return (modular_int<MOD>(x)).x == m.x;
	}

	friend istream& operator >> (istream& is, modular_int<MOD>& p){
		int64_t val;
		is >> val;
		p.x = (val%MOD);
		if (p.x < 0) p.x += MOD;
		return is;
	}
	friend ostream& operator << (ostream& os, const modular_int<MOD>& p) {return os<<p.x;}



};


using mint = modular_int<mod>;
template<const int MOD>
vector<int> modular_int<MOD>::inverse_list ;
template<const int MOD>
const int modular_int<MOD>::inverse_limit = -1;
// template<>   //-> useful if computing inverse fact = i_f[i-1] / i;
// const int modular_int<mod>::inverse_limit = 100000;

/*/-----------------------------Code begins----------------------------------/*/

const int N = 305;

mint dp[N][N][N];
bool vis2[N][N][N];
bool vis[N][N][N];

int cnt0[N],cnt1[N];
string s;
int num_states = 0;

struct node{
	int len,c0,c1;
	bool operator < (const node& x) const{
		return len < x.len;
	}

};
vector<node> tot[N];

void recur(int len,int c0,int c1){
	assert(len >= 0 && c0 >= 0 && c1 >= 0);
	if (vis[len][c0][c1]){
		return;
	}
	vis[len][c0][c1] = true;
	++num_states;
	tot[len + c0 + c1].push_back({len,c0,c1});
	if (len == 0) {
		if (c0 > 0 && c0 + c1 > 2){
			recur(len,c0-1,c1);
		}
		if (c1 > 0 && c0 + c1 > 2){
			recur(len,c0,c1-1);
		}
		return;
	}
	if (len == 1){
		if (c0 + c1 > 0){
			recur(0,c0,c1);
			if (c0 > 0){
				recur(1,c0-1,c1);
			}
			if (c1 > 0){
				recur(1,c0,c1-1);
			}
		}

		return;
	}
	recur(len - 1 ,c0,c1);

	recur(len - 2, c0, c1);
	if (s[len - 1] == '0'){
		recur(len-2,c0+1,c1);
		if (c1 > 0) recur(len - 1,c0+1,c1-1);
	}
	else{
		recur(len-2,c0,c1+1);
		if (c0 > 0) recur(len - 1,c0-1,c1+1);
	}

	if (s[len-2] == '0'){
		recur(len-2,c0+1,c1);
	}
	else{
		recur(len-2,c0,c1+1);
	}
}


mint ways(int len,int c0,int c1){
	assert(len >= 0 && c0 >= 0 && c1 >= 0);
	if (vis2[len][c0][c1]){
		return dp[len][c0][c1];
	}
	vis2[len][c0][c1] = true;
	mint& ans = dp[len][c0][c1];
	if (c0 == 0 && c1 == 0){
		ans = 1;
		return ans;
	}
	if (len == 0){
		ans = 0;
		if (c0 > 0) ans += ways(len,c0-1,c1);
		if (c1 > 0) ans += ways(len,c0,c1-1);

		return ans;
	}

	if (s[len - 1] == '0'){
		ans = ways(len - 1, c0, c1);
		if (c1 > 0) ans += ways(len,c0,c1-1);
	}
	else{
		ans = ways(len - 1, c0, c1);
		if (c0 > 0) ans += ways(len,c0-1,c1);	
	}
	return ans;

}


// void brute(string s,set<string>& S){
// 	if (s.size() == 0) return;

// 	S.insert(s);
// 	int n = s.size();
// 	if (s.size() == 1) return;

// 	for(int i = 0;i<n-1;++i){
// 		string t;
// 		string u;
// 		int dif = 0;
// 		for(int j = 0; j<n-1;++j){
// 			if (j == i){
// 				t += s[n-1];
// 				u += s[n-2]; 
// 				++dif;
// 			}
// 			else{
// 				t += s[j - dif];
// 				u += s[j - dif];
// 			}
// 		}
// 		brute(t,S);
// 		brute(u,S);
// 	}



// }


void solve(){
    cin>>s;
    reverse(all(s));

    // set<string> U;
    // brute(s,U);



    map<int,int> cnt_len;

    // for(auto e:U){
    	// ++cnt_len[e.size()];
    // }
    recur(s.size(),0,0);

    int val = 0;

    cnt0[0] = 0;
    cnt1[0] = 0;
    for(int i = 1;i<=s.size(); ++i){
    	cnt0[i] = cnt0[i-1];
    	cnt1[i] = cnt1[i-1];

    	if (s[i-1] == '0') ++cnt0[i];
    	else ++cnt1[i];
    }

    mint ans = 0;

    // for(auto e:U){
    // 	if (e.size() == 4){
    // 		trace(e);
    // 	}
    // }

    for(int i = 1;  i<=s.size(); ++i){
    	val += tot[i].size();
    	set<pair<int,int>> vis;
    	sort(all(tot[i]));
    	mint cans = 0;
    	for(auto e:tot[i]){
    		int len = e.len, cur0 = e.c0, cur1 = e.c1;

    		pair<int,int> cnt = {cur0 + cnt0[len],cur1 + cnt1[len]};
    		if (vis.count(cnt)) continue;
    		vis.insert(cnt);
    		// trace(len,cur0,cur1,ways(len,cur0,cur1));

    		ans += ways(len,cur0,cur1);

    		cans += ways(len,cur0,cur1);

    	}



    }
    cout<<ans<<endl;
}
int main(){
    // Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered set
    // Or use gp_hash_table<X,null_type>
    ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
    cout<<fixed<<setprecision(25);
    cerr<<fixed<<setprecision(10);
    auto start = std::chrono::high_resolution_clock::now();
    int t=1;
    // cin>>t;
    while(t--) {
        solve();
    }
    auto stop = std::chrono::high_resolution_clock::now(); 
    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start); 
    
    // cerr << "Time taken : " << ((long double)duration.count())/((long double) 1e9) <<"s "<< endl;     
}






Measured memory_bytes: 145720