import java.util.ArrayList;
import java.util.Collections;

public class Euler803 {
    static final long A = 25214903917L;
    static final long C = 11L;
    static final long MOD = 1L << 48;
    static final long MASK = MOD - 1L;

    static long mulMod(long x, long y) {
        long x0 = x & 0xFFFFFFL;
        long x1 = (x >>> 24) & 0xFFFFFFL;
        long y0 = y & 0xFFFFFFL;
        long y1 = (y >>> 24) & 0xFFFFFFL;

        long p0 = x0 * y0;
        long p1 = x1 * y0 + x0 * y1;

        return (p0 + (p1 << 24)) & MASK;
    }

    static long powMod(long a, long e) {
        long r = 1L;
        while (e > 0) {
            if ((e & 1L) == 1L) {
                r = mulMod(r, a);
            }
            a = mulMod(a, a);
            e >>= 1L;
        }
        return r;
    }

    static long invOdd(long a) {
        long x = 1L;
        for (int i = 0; i < 6; ++i) {
            long ax = mulMod(a, x);
            long twoMinusAx = (2L + MOD - ax) & MASK;
            x = mulMod(x, twoMinusAx);
        }
        return x;
    }

    static long nextState(long a) {
        return (mulMod(A, a) + C) & MASK;
    }

    static int valueToCode(long state) {
        return (int) ((state >>> 16) % 52L);
    }

    static int charCode(char ch) {
        if (ch >= 'a' && ch <= 'z') {
            return ch - 'a';
        }
        return ch - 'A' + 26;
    }

    static ArrayList<Integer> patternCodes(String s) {
        ArrayList<Integer> out = new ArrayList<>();
        for (char ch : s.toCharArray()) {
            out.add(charCode(ch));
        }
        return out;
    }

    static ArrayList<Long> statesStartingWith(String pattern) {
        ArrayList<Integer> t = patternCodes(pattern);
        int n = t.size();
        ArrayList<Integer> reqMod4 = new ArrayList<>(n - 1);
        for (int i = 0; i + 1 < n; ++i) {
            reqMod4.add((t.get(i + 1) - t.get(i) + 4) & 3);
        }

        ArrayList<Integer> low16Candidates = new ArrayList<>();
        for (int low0 = 0; low0 < (1 << 16); ++low0) {
            long low = low0;
            boolean ok = true;
            for (int i = 0; i + 1 < n; ++i) {
                long x = A * low + C;
                int carry = (int) (x >>> 16);
                if ((carry & 3) != reqMod4.get(i)) {
                    ok = false;
                    break;
                }
                low = x & 0xFFFFL;
            }
            if (ok) {
                low16Candidates.add(low0);
            }
        }

        ArrayList<Long> states = new ArrayList<>();
        for (int low0 : low16Candidates) {
            int[] carries = new int[n - 1];
            long low = low0;
            for (int i = 0; i + 1 < n; ++i) {
                long x = A * low + C;
                carries[i] = (int) (x >>> 16);
                low = x & 0xFFFFL;
            }

            for (long m = 0;; ++m) {
                long q0_64 = t.get(0) + 52L * m;
                if (q0_64 > 0xFFFFFFFFL) {
                    break;
                }

                int q = (int) q0_64;
                boolean ok = true;
                for (int i = 0; i + 1 < n; ++i) {
                    q = (int) A * q + carries[i];
                    if (Integer.remainderUnsigned(q, 52) != t.get(i + 1)) {
                        ok = false;
                        break;
                    }
                }

                if (ok) {
                    states.add((q0_64 << 16) | (long) low0);
                }
            }
        }

        Collections.sort(states);
        ArrayList<Long> uniqueStates = new ArrayList<>();
        for (long state : states) {
            if (uniqueStates.isEmpty() || uniqueStates.get(uniqueStates.size() - 1) != state) {
                uniqueStates.add(state);
            }
        }
        return uniqueStates;
    }

    static long advanceState(long start, long steps) {
        long mul = 1L;
        long add = 0L;
        long baseMul = A & MASK;
        long baseAdd = C;

        while (steps > 0) {
            if ((steps & 1L) == 1L) {
                add = (mulMod(baseMul, add) + baseAdd) & MASK;
                mul = mulMod(baseMul, mul);
            }
            baseAdd = (mulMod(baseMul, baseAdd) + baseAdd) & MASK;
            baseMul = mulMod(baseMul, baseMul);
            steps >>= 1L;
        }

        return (mulMod(mul, start) + add) & MASK;
    }

    static long discreteLogBaseA(long ratio) {
        int ORDER_BITS = 46;
        long invA = invOdd(A & MASK);

        long[] invPows = new long[ORDER_BITS];
        invPows[0] = invA;
        for (int i = 1; i < ORDER_BITS; ++i) {
            invPows[i] = mulMod(invPows[i - 1], invPows[i - 1]);
        }

        long cur = ratio;
        long exponent = 0L;

        for (int i = 0; i < ORDER_BITS; ++i) {
            long test = powMod(cur, 1L << (ORDER_BITS - 1 - i));
            if (test != 1L) {
                exponent |= (1L << i);
                cur = mulMod(cur, invPows[i]);
            }
        }

        return exponent;
    }

    static long distanceBetweenStates(long start, long target) {
        long bStart = (mulMod((A - 1L) & MASK, start) + C) & MASK;
        long bTarget = (mulMod((A - 1L) & MASK, target) + C) & MASK;

        long invBStart = invOdd(bStart);
        long ratio = mulMod(bTarget, invBStart);
        long baseDistance = discreteLogBaseA(ratio);

        long ORDER = 1L << 46;
        for (long k = 0; k < 4L; ++k) {
            long candidate = baseDistance + k * ORDER;
            if (advanceState(start, candidate) == target) {
                return candidate;
            }
        }
        return 0L;
    }

    public static String solve() {
        ArrayList<Long> puzzleStates = statesStartingWith("PuzzleOne");
        ArrayList<Long> luckyStates = statesStartingWith("LuckyText");

        long answer = distanceBetweenStates(puzzleStates.get(0), luckyStates.get(0));
        return Long.toUnsignedString(answer);
    }

    public static void main(String[] args) {
        System.out.println(solve());
    }
}