#include <bits/stdc++.h>
#define mp(x, y) std::make_pair(x, y)
#define mt std::make_tuple
#define eb emplace_back
#define pb pop_back
#define fi first
#define se second
#define all(s) s.begin(), s.end()
#define file(name)                 \
  freopen(name ".in", "r", stdin); \
  freopen(name ".out", "w", stdout);
#define fs(x) std::fixed << std::setprecision(x)
#define lowbit(x) (x & -x)
#define il inline
#define Avada_Kedavra return 0
#define _IOS                        \
  std::ios::sync_with_stdio(false); \
  std::cin.tie(nullptr), std::cout.tie(nullptr)
#define RANDOM_SEED std::chrono::steady_clock::now().time_since_epoch().count()
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define multitask            \
  int _; io.read(_);         \
  while (_--)

namespace TYPEDEF {

using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using i128 = __int128;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using vi = std::vector<int>;
using vll = std::vector<ll>;
using vull = std::vector<ull>;
using vpii = std::vector<pii>;
using vpll = std::vector<pll>;
using si = std::stack<int>;
using sll = std::stack<ll>;
using sull = std::stack<ull>;
using spii = std::stack<pii>;
using spll = std::stack<pll>;
using qi = std::queue<int>;
using qll = std::queue<ll>;
using qull = std::queue<ull>;
using qpii = std::queue<pii>;
using qpll = std::queue<pll>;
using siset = std::set<int>;
using sllset = std::set<ll>;

}

using namespace TYPEDEF;

struct IO {
  #define MAXSIZE (1 << 20)
  #define isdigit(x) (x >= '0' && x <= '9')
  char buf[MAXSIZE], *p1, *p2;
  char pbuf[MAXSIZE], *pp;
#ifndef ONLINE_JUDGE  // 调试，可显示字符
#else
  IO() : p1(buf), p2(buf), pp(pbuf) {}

  ~IO() { fwrite(pbuf, 1, pp - pbuf, stdout); }
#endif
  char gc() {
#ifndef ONLINE_JUDGE  // 调试，可显示字符
    return getchar();
#endif
    if (p1 == p2) p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin);
    return p1 == p2 ? ' ' : *p1++;
  }

  bool blank(char ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t'; }

  template <typename T>
  il void read(T &x) {
    double tmp = 1;
    bool sign = 0;
    x = 0;
    char ch = gc();
    for (; !isdigit(ch); ch = gc())
      if (ch == '-') sign = 1;
    for (; isdigit(ch); ch = gc()) x = x * 10 + (ch - '0');
    if (ch == '.')
      for (ch = gc(); isdigit(ch); ch = gc())
        tmp /= 10.0, x += tmp * (ch - '0');
    if (sign) x = -x;
  }

  il void read(char *s) {
    char ch = gc();
    for (; blank(ch); ch = gc());
    for (; !blank(ch); ch = gc()) *s++ = ch;
    *s = 0;
  }

  il void read(char &c) { for (c = gc(); blank(c); c = gc()); }

  il void read(std::string &s) {
    char ch = gc();
    for (; blank(ch); ch = gc());
    for (; !blank(ch); ch = gc()) s += ch;
  }

  template<typename T, typename... Args> il void read(T &x, Args&... args) {
    read(x), read(args...);
  }

  il void push(const char &c) {
#ifndef ONLINE_JUDGE  // 调试，可显示字符
    putchar(c);
#else
    if (pp - pbuf == MAXSIZE) fwrite(pbuf, 1, MAXSIZE, stdout), pp = pbuf;
    *pp++ = c;
#endif
  }

  template <typename T> il void write(T x) {
    if (x < 0) x = -x, push('-');  // 负数输出
    static int sta[40];
    int top = 0;
    do { sta[top++] = x % 10, x /= 10; } while (x);
    while (top) push(sta[--top] + '0');
  }

  il void write (double x, int k = 6) {
    if (x < 0) x = -x, push('-');  // 负数输出
    static int sta[40];
    int n = pow(10, k), top = 0;
    ll nx = (ll)x, y = ll(x * n) % n;
    write(nx, '.');
    for (int i = 0; i < k; i++) sta[++top] = y % 10, y /= 10;
    while (top) push(sta[top--] + '0');
  }

  il void write(char *s) { while (*s) push(*s++); }

  il void write(const char *s) { while (*s) push(*s++); }

  il void write(char c) { push(c); }

  il void write(std::string s) { for (int c : s) push(c); }

  template <typename T> il void write(T x, char lastChar) {
    write(x), push(lastChar);
  }

  template<typename T, typename... Args> il void write(T x, Args... args) {
    write(x), write(args...);
  }
} io;

/*============================DEBUG_AREA============================*/

namespace DDDEBUG {

using std::cerr;

#ifndef ONLINE_JUDGE
#define debug(x) \
  cerr << "In Line " << __LINE__ << ": " << #x << " = " << x << std::endl
#define look_time cerr << clock() * 1e3 / CLOCKS_PER_SEC << " ms\n"
#define look_memory cerr << fabs(&med - &mst) / 1024.0 / 1024.0 << " mb\n"
#else
#define debug(...) 42
#define look_time 42
#define look_memory 42
#endif

}

using namespace DDDEBUG;

/*================================END================================*/

/*===============================ALGOS===============================*/

namespace basic_algorithm {
using std::min;
using std::max;
using std::swap;
template <typename T> il T abs(T a) { return a >= 0 ? a : -a; }
template <typename T> il T gcd(T a, T b) {
  while (b) a %= b, swap(a, b);
  return a;
}
template <typename T> il T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <typename T> il void chmin(T &a, T b) { if (a > b) a = b; }
template <typename T> il void chmax(T &a, T b) { if (a < b) a = b; }
}  // namespace basic_algorithm

using namespace basic_algorithm;

/*================================END================================*/

constexpr int N = 1e5 + 5;
constexpr int mod = 1e9 + 7;
constexpr int inf = 0x3f3f3f3f;
constexpr ll infll = 0x3f3f3f3f3f3f3f3fll;

std::mt19937 rng(RANDOM_SEED);

bool mst;

char s[N];
int n, fail[N];

bool med;

signed main() {
  io.read(s + 1);
  n = strlen(s + 1);
  int j = 0;
  for (int i = 2; i <= n; ++i) {
    while (j && s[i] != s[j + 1]) j = fail[j];
    if (s[i] == s[j + 1]) ++j;
    fail[i] = j;
  }
  for (int i = 1; i <= n; ++i) io.write(fail[i], ' ');
  Avada_Kedavra;
}

/*
all the things you do
the words you say
will all come back to you
*/