Problem: Asterix, Obelix and their temporary buddies Suffix and Prefix has finally found the Harmony temple. However, its doors were firmly locked and even Obelix had no luck opening them.

A little later they found a string s, carved on a rock below the temple's gates. Asterix supposed that that's the password that opens the temple and read the string aloud. However, nothing happened. Then Asterix supposed that a password is some substring t of the string s.

Prefix supposed that the substring t is the beginning of the string s; Suffix supposed that the substring t should be the end of the string s; and Obelix supposed that t should be located somewhere inside the string s, that is, t is neither its beginning, nor its end.

Asterix chose the substring t so as to please all his companions. Besides, from all acceptable variants Asterix chose the longest one (as Asterix loves long strings). When Asterix read the substring t aloud, the temple doors opened. 

You know the string s. Find the substring t or determine that such substring does not exist and all that's been written above is just a nice legend.

Input

You are given the string s whose length can vary from 1 to 106 (inclusive), consisting of small Latin letters.

Output

Print the string t. If a suitable t string does not exist, then print "Just a legend" without the quotes.

Examples

Input

fixprefixsuffix


Output

fix

Input

abcdabc


Output

Just a legend

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
  cerr << '{';
  __print(x.first);
  cerr << ',';
  __print(x.second);
  cerr << '}';
}
template <typename T>
void __print(const T& x) {
  int f = 0;
  cerr << '{';
  for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
  cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v)) cerr << ", ";
  _print(v...);
}
const int MOD = 1e9 + 7;
const int p = 31;
vector<int> hash_values;
inline int add(int a, int b) {
  a += b;
  while (a >= MOD) a -= MOD;
  while (a < 0) a += MOD;
  return a;
}
inline void add_self(int& a, int b) { a = add(a, b); }
inline int sub(int a, int b) { return add(a, -b); }
inline int mul(int a, int b) { return (a * 1LL * b) % MOD; }
inline void mul_self(int& a, int b) { a = mul(a, b); }
int power(int a, int b) {
  int ans = 1;
  while (b) {
    if (b & 1) mul_self(ans, a);
    mul_self(a, a);
    b >>= 1;
  }
  return ans;
}
int inverse(int a) { return power(a, MOD - 2); }
void compute_hash(const string& s) {
  const int n = s.size();
  int also = p;
  for (int i = 0; i < n; i++) {
    hash_values[i] = mul(also, s[i] - 'a' + 1);
    if (i) add_self(hash_values[i], hash_values[i - 1]);
    mul_self(also, p);
  }
}
inline int hash_value(int l, int r) {
  if (l > r) return 0;
  if (l == 0) return hash_values[r];
  return mul(sub(hash_values[r], hash_values[l - 1]), inverse(power(p, l)));
}
bool check(string& s, int len) {
  int prefix = hash_value(0, len - 1);
  const int n = s.size();
  for (int i = 1; i + len - 1 < n - 1; i++) {
    if (prefix == hash_value(i, i + len - 1)) return true;
  }
  return false;
}
void solve() {
  string s;
  cin >> s;
  string that = "Just a legend";
  int n = s.size();
  hash_values.resize(n + 1);
  compute_hash(s);
  vector<int> allPossibleLength;
  for (int i = 0; i < n; i++) {
    int prefix = hash_value(0, i);
    int suffix = hash_value(n - i - 1, n - 1);
    if (prefix == suffix) {
      allPossibleLength.emplace_back(i + 1);
    }
  }
  sort(allPossibleLength.begin(), allPossibleLength.end());
  int low = 0;
  int high = allPossibleLength.size() - 1;
  int middle, ans = -1;
  while (low <= high) {
    middle = (low + high) / 2;
    if (check(s, allPossibleLength[middle])) {
      ans = allPossibleLength[middle];
      low = middle + 1;
    } else
      high = middle - 1;
  }
  cout << (ans == -1 ? that : s.substr(0, ans)) << "\n";
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  solve();
}