#include "bits/stdc++.h"
constexpr int __FREAD__ = 131072;
constexpr char __FIN__[] = "";
constexpr char __FOUT__[] = "";
constexpr bool MTS = false;
constexpr bool SPC_MTS = false;
#define _LOAD_4(a, b, c, d, ...) d
#define _ALL_0(arg) begin(arg), end(arg)
#define _ALL_1(arg, l) (begin(arg) + (l)), end(arg)
#define _ALL_2(arg, l, r) (begin(arg) + (l)), (begin(arg) + (r) + 1)
#define ALL(...) _LOAD_4(__VA_ARGS__, _ALL_2, _ALL_1, _ALL_0)(__VA_ARGS__)

// :/

using namespace std;
using tp = long long int;
[[maybe_unused]] constexpr tp ZERO = 0, ONE = 1, INF = -1ull >> 2;
int WITHERING(int);
void MIST(int, char*[]);

template <typename _Ty> class _Lambda_t { _Ty lexp;public:template<typename __Ty
>_Lambda_t(__Ty&&lexp):lexp(static_cast<__Ty&&>(lexp)){}template<typename...__Ty
>decltype(auto)operator()(__Ty&&...args){return lexp(std::ref(*this),static_cast
<__Ty&&>(args)...); } }; template <typename _Ty> decltype (auto) lexp(_Ty&&l_exp
) {return _Lambda_t<typename std::decay<_Ty>::type>(static_cast<_Ty&&>(l_exp));}
struct SPLITMIX { static uint64_t splitmix(uint64_t x){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 o =
chrono::steady_clock::now().time_since_epoch().count(); return splitmix(x+o);}};
template <typename _Ty> auto vcc(_Ty init, size_t s) { return std::vector<_Ty>(s
, init); } template <typename _Ty, typename... __Ty> auto vcc(_Ty init, size_t s
, __Ty... o) {auto ret=vcc(init,o...);return std::vector<decltype(ret)>(s,ret);}
template <typename _Ty1, typename _Ty2> bool ckmax(_Ty1& a, const _Ty2& b) { if(
a < b) { a = b; return true; } return false; } template <typename _Ty1, typename
_Ty2> bool ckmin(_Ty1& a, const _Ty2& b){if(b<a){a=b;return true;}return false;}
void RAW(char&x){if(__FREAD__!=0){static char buf[__FREAD__];static char*s=buf,*
e=buf;if(s==e){s=buf;e=buf+fread(buf,1,__FREAD__,stdin);if(s==e){x=EOF;return;}}
x = *s++; } else x = getchar(); } void bin(char& c){for(RAW(c);c==' '||c == '\n'
|| c == '\r'; RAW(c)); } void bin(std::string& x) { char c; for(RAW(c);c==' '||c
== '\n' || c == '\r'; RAW(c)); x = c; for (RAW(c); c!=' '&&c!='\n'&&c!='\r';RAW(
c)) x.push_back(c); } template <typename Ty> void bin(Ty& x) { bool sign = false
;char c; for (RAW(c); c < '0' || c > '9'; RAW(c)) if (c == '-') sign = true; for
(x = 0; '0' <= c && c <= '9'; RAW(c)) x = x * 10 + (c & 15); if (sign) x = -x; }
template <typename...> using bin_void_t =void;template<typename T,typename=void>
struct bin_it :std::false_type{};template<typename T>struct bin_it<T,bin_void_t<
typename std::iterator_traits<T>::iterator_category>>:std::true_type{};template<
typename T>struct bin_it<T*,void>:std::true_type{};template<typename T,typename=
typename std::enable_if<bin_it<T>::value>::type>void bin(T s,T e){while(s!=e)bin
(*s++);}template<typename...>struct bin_or:std::false_type{};template<typename T
, typename... O> struct bin_or<T,O...>:std::conditional<T::value,std::true_type,
bin_or<O...>>::type {}; template <typename... T>typename std::enable_if<!bin_or<
bin_it<typename std::decay<T>::type>...>::value, void>::type bin(T& ...x) {void(
(int[]) { 0, (bin(&x, &x + 1), 0) ... }); } tp bin() { tp x; bin(x); return x; }
int main(int argc, char* argv[]) { int t = 0, _t = 1; if(MTS&&!SPC_MTS) bin(_t);
MIST(argc, argv); while(t<_t||SPC_MTS){if(WITHERING(++t)!=0)return 0;}return 0;}
#ifdef XCODE
#define bg(...){cout<<"["<<__LINE__<<'@'<<++_LT[__LINE__]<<':';BG(__VA_ARGS__);}
size_t _LT[21777]; template<typename _Type>void BG(const _Type&_cur){cout<<' '<<
_cur << ']' <<" <<:"<<std::endl;}template<typename _Type,typename... _Other>void
BG(const _Type& _cur, const _Other& ..._other) {cout<< ' '<<_cur;BG(_other...);}
#else
#define bg(...)
#endif

// :/

namespace lib {  // LIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIBLIB
template <typename S, auto op, auto e> class Light_Segtree {size_t length, size,
log; vector<S> data; void update(size_t k) { data[k]=op(data[2*k],data[2*k+1]);}
public: Light_Segtree():Light_Segtree(0){}Light_Segtree(size_t n):Light_Segtree(
std::vector<S>(n, e())){}Light_Segtree(const std::vector<S>&v):length(v.size()),
size(1), log(63) { while (size < length) size *= 2; size_t x = size &-size; if (
x & 0x00000000FFFFFFFF) log -= 32; if (x & 0x0000FFFF0000FFFF) log -= 16; if (x&
0x00FF00FF00FF00FF)log-=8;if(x&0x0F0F0F0F0F0F0F0F)log-=4;if(x&0x3333333333333333
) log -= 2; if (x&0x5555555555555555)log-=1;data=std::vector<S>(2*size,e());for(
size_t i=0;i<length;++i)data[size+i]=v[i];for(size_t i=size-1;i>=1;--i)update(i)
;}void set(size_t p,S x){data[p+=size]=x;for(size_t i=1;i<=log;++i)update(p>>i);
}S get(size_t p){return data[p+size];}S prod(size_t l,size_t r){if(r<l)return e(
);l+=size;r+=size+1;S sml=e(),smr=e();while(l<r){if(l&1)sml=op(sml,data[l++]);if
(r & 1) smr=op(data[--r],smr);l/=2;r/=2;}return op(sml,smr);}S all_prod(){return
data[1];}template<bool(*g)(S)>size_t max_right(size_t l){return max_right(l,[](S
x) { return g(x); } );}template<typename G>size_t max_right(size_t l,G g){if(l==
length)return length;l+=size;S sm=e();do{while(l%2==0)l/=2;if(!g(op(sm,data[l]))
){while(l<size){l*=2;if(g(op(sm,data[l])))sm=op(sm,data[l++]);}return l-size;}sm
= op(sm, data[l++]);}while((l&-l)!=l);return length;}template<bool(*g)(S)>size_t
min_left(size_t r){return min_left(r,[](S x){return g(x);});}template<typename G
>size_t min_left(size_t r,G g){if(r==0)return 0;r+=size;S sm=e();do{r--;while(r>
1 && r % 2 == 1) r /= 2; if (!g(op(data[r], sm))) { while (r < size) { r = 2 * r
+ 1; if (g(op(data[r], sm))) sm = op(data[r--], sm); } return r + 1 - size; } sm
= op(data[r], sm); } while ((r & -r) != r); return 0;}};template<typename S,auto
op, auto e, typename F, auto mapping, auto composition, auto id> class Segtree {
size_t length, size, log; vector<S> data; vector<F> tag; void update(size_t k) {
data[k]=op(data[2*k],data[2*k+1]);}void all_apply(size_t k,F f){data[k]=mapping(
f,data[k]);if(k<size)tag[k]=composition(f,tag[k]);}void push(size_t k){all_apply
(2 *k,tag[k]);all_apply(2*k+1,tag[k]);tag[k]=id();}public:Segtree():Segtree(0){}
Segtree(size_t n):Segtree(std::vector<S>(n,e())){}Segtree(const std::vector<S>&v
):length(v.size()),size(1),log(63){while(size<length)size*=2;size_t x=size&-size
;if(x & 0x00000000FFFFFFFF) log -= 32; if (x & 0x0000FFFF0000FFFF) log -= 16; if
(x & 0x00FF00FF00FF00FF) log -= 8; if (x & 0x0F0F0F0F0F0F0F0F) log -= 4; if (x &
0x3333333333333333) log-=2;if(x&0x5555555555555555)log-=1;data=std::vector<S>(2*
size,e());tag=std::vector<F>(size,id());for(size_t i=0;i<length;++i)data[size+i]
=v[i];for(size_t i=size-1;i>=1;--i)update(i);}void set(size_t p,S x){p+=size;for
(size_t i=log;i>=1;--i)push(p>>i);data[p]=x;for(size_t i=1;i<=log;++i)update(p>>
i);}S get(size_t p){p+=size;for(size_t i=log;i>=1;--i)push(p>>i);return data[p];
}S prod(size_t l,size_t r){if(r<l)return e();l+=size;r+=size+1;for(size_t i=log;
i>=1;--i){if(((l>>i)<<i)!=l)push(l>>i);if(((r>>i)<<i)!=r)push((r-1)>>i);}S sml=e
(),smr=e();while(l<r){if(l&1)sml=op(sml,data[l++]);if(r&1)smr=op(data[--r],smr);
l/=2;r/=2;}return op(sml,smr);}S all_prod(){return data[1];}void apply(size_t p,
F f){p+=size;for(size_t i=log;i>=1;--i)push(p>>i);data[p]=mapping(f,data[p]);for
(size_t i = 1;i<=log;++i)update(p>>i);}void apply(size_t l,size_t r,F f){if(r<l)
return;l+=size;r+=size+1;for(size_t i=log;i>=1;--i){if(((l>>i)<<i)!=l)push(l>>i)
;if(((r>>i)<<i)!=r)push((r-1)>>i);}size_t _l=l,_r=r;while(l<r){if(l&1)all_apply(
l++, f);if(r&1)all_apply(--r,f);l/=2;r/=2;}l=_l;r=_r;for(size_t i=1;i<=log;++i){
if (((l >> i)<<i)!=l)update(l>>i);if(((r>>i)<<i)!=r)update((r-1)>>i);}}template<
bool(*g)(S)>size_t max_right(size_t l){return max_right(l,[](S x){return g(x);})
;}template<typename G>size_t max_right(size_t l,G g){if(l==length)return length;
l+=size;for(size_t i=log;i>=1;--i)push(l>>i);S sm=e();do{while(l%2==0)l/=2;if(!g
(op(sm,data[l]))){while(l<size){push(l);l*=2;if(g(op(sm,data[l])))sm=op(sm,data[
l++]); } return l - size; }sm=op(sm,data[l++]);}while((l&-l)!=l);return length;}
template<bool(*g)(S)>size_t min_left(size_t r) {return min_left(r,[](S x){return
g(x); }); } template <typename G> size_t min_left(size_t r, G g) {if(r==0)return
0; r += size; for (size_t i = log; i >= 1; --i) push((r - 1) >> i); S sm =e();do
{ r--; while (r > 1 && r % 2 == 1) r /= 2; if (!g(op(data[r], sm))) { while (r <
size) { push(r); r = 2 * r + 1; if (g(op(data[r], sm))) sm = op(data[r--], sm);}
return r + 1 - size; } sm = op(data[r], sm); } while((r & -r) != r);return 0;}};
}  // LIB::SEGMENT_TREE LIB::SEGMENT_TREE LIB::SEGMENT_TREE LIB::SEGMENT_TREE LI

// :/

struct STRUGGLE {
   STRUGGLE() {
      if (strlen(__FIN__) != 0) freopen(__FIN__, "r", stdin);
      if (strlen(__FOUT__) != 0) freopen(__FOUT__, "w", stdout);
   }
   
   ~STRUGGLE() {
   }
} STRUGGLE;

int WITHERING([[maybe_unused]] int TEST_NUMBER) {
   constexpr tp base = 2121212101;
   constexpr tp mod = 2121212147;
   string s, t; bin(s, t);
   tp n = s.size();
   vector<tp> hs(n + 1);
   vector<tp> pw(n + 1);
   s = ' ' + s; t = ' ' + t;
   for (tp i = 1; i <= n; ++i) hs[i] = (hs[i - 1] * base + s[i]) % mod;
   pw[0] = 1;
   for (tp i = 1; i <= n; ++i) pw[i] = pw[i - 1] * base % mod;
   auto conn = [&](tp h1, tp h2, tp len) { return (h1 * pw[len] + h2) % mod; };
   auto hsh = lexp([&](auto $, tp l, tp r, tp p) -> tp {
      if (l <= p && p <= r) {
         if (l == p && r == p) return t[p];
         if (l == p) return conn(t[p], $(l + 1, r, p), r - l);
         if (r == p) return ($(l, r - 1, p) * base + t[p]) % mod;
         tp q = $(l, p - 1, p) * base + t[p];
         return conn(q % mod, $(p + 1, r, p), r - p);
      }
      tp q = (hs[r] - hs[l - 1] * pw[r - l + 1]) % mod;
      return q < 0 ? q + mod : q;
   });
   auto op = [&](tp l, tp r) { return l | r; };
   auto e = []() { return ZERO; };
   auto comp = [&](tp a, tp b) {
      if (a == -1) return b;
      return a;
   };
   auto id = []() { return -ONE; };
   lib::Segtree<tp, op, e, tp, comp, comp, id> o(n + 1);
   tp mx = 0;
   for (tp i = 1; i < n; ++i) {
      if (hsh(1, i, 0) == hsh(n - i + 1, n, 0)) {
         o.apply(i + 1, n - i, i);
         mx = i;
         continue;
      }
      tp l = 1, r = i, tar = 0;
      while (l <= r) {
         tp mid = (l + r) >> 1;
         if (hsh(1, mid, 0) == hsh(n - i + 1, n - i + mid, 0)) {
            tar = mid;
            l = mid + 1;
         } else r = mid - 1;
      }
      ++tar;
      if (t[tar] == s[n - i + tar] && hsh(tar + 1, i, tar) == hsh(n - i + tar + 1, n, tar)) {
         o.set(tar, i);
      }
      if (s[tar] == t[n - i + tar] && hsh(tar + 1, i, n - i + tar) == hsh(n - i + tar + 1, n, n - i + tar)) {
         o.set(n - i + tar, i);
      }
   }
   for (tp i = 1; i <= n; ++i) {
      if (s[i] == t[i]) cout << max(mx, o.get(i)) << '\n';
      else cout << o.get(i) << '\n';
   }
   return 0;
}

void MIST([[maybe_unused]] int argc, [[maybe_unused]] char* argv[]) {
}

// :\ */