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
import java.util.List;
import java.util.Scanner;
import java.io.OutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author @zhendeaini6001
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		Scanner in = new Scanner(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}
}

class StringUtils {
	public static int[] prefixFunction(CharSequence s) {
        int l = s.length();
        int[] p = new int[l];
        p[0] = 0;
        int k = 0;
        for (int i = 1; i < l; i++) {
                while ((k > 0) && (s.charAt(k) != s.charAt(i)))
                        k = p[k - 1];
                if (s.charAt(k) == s.charAt(i))
                        k++;
                p[i] = k;
        }
        return p;
	}
	public static int[] zAlgorithm(CharSequence s) {
        int length = s.length();
        int[] z = new int[length];
        z[0] = 0;

        int left = 0, right = 0;
        for (int i = 1; i < length; i++) {
                if (i > right) {
                        int j;
                        //noinspection StatementWithEmptyBody
                        for (j = 0; i + j < length && s.charAt(i + j) == s.charAt(j); j++) ;
                        z[i] = j;
                        left = i;
                        right = i + j - 1;
                } else if (z[i - left] < right - i + 1)
                        z[i] = z[i - left];
                else {
                        int j;
                        //noinspection StatementWithEmptyBody
                        for (j = 1; right + j < length && s.charAt(right + j) == s.charAt(right - i + j); j++) ;
                        z[i] = right - i + j;
                        left = i;
                        right = right + j - 1;
                }
        }
        return z;
	}
}

class TaskD {
	public void solve(int testNumber, Scanner in, PrintWriter out) {
        String input = in.next();
        char c = input.charAt(input.length() - 1);
        List<Integer> tail = new ArrayList<Integer>();
        for (int i = 1; i < input.length() - 1; ++i){
            if (input.charAt(i) == c){
                tail.add(i);
            }
        }
        int[] suffix = StringUtils.prefixFunction(input);
        int[] prefix = StringUtils.zAlgorithm(input);
        int input_length = input.length();
        int max = 0;

        for (int i = tail.size() - 1; i >= 0; --i){
            int length = suffix[tail.get(i)];
            //if (length > max && length == prefix[input_length - length] && length + head.get(i) != input_length){
            //    max = length;
            //}
            //if (length != tail.get(i) ){
                if (length > max && (length == prefix[input_length - length]) ){
                    max = length;
                }
            //}
        }
        if (max > 0)    {
            out.println(input.substring(0, max));
        }else{
            out.println("Just a legend");
        }
        return;
	}
}

