Problem:
Score : 500 points

Problem Statement

Let us denote by f(x, m) the remainder of the Euclidean division of x by m.

Let A be the sequence that is defined by the initial value A_1=X and the recurrence relation A_{n+1} = f(A_n^2, M).
Find \displaystyle{\sum_{i=1}^N A_i}.

Constraints

1 \leq N \leq 10^{10}

0 \leq X < M \leq 10^5

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N X M

Output

Print \displaystyle{\sum_{i=1}^N A_i}.

Sample Input 1

6 2 1001

Sample Output 1

1369

The sequence A begins 2,4,16,256,471,620,\ldots Therefore, the answer is 2+4+16+256+471+620=1369.

Sample Input 2

1000 2 16

Sample Output 2

6

The sequence A begins 2,4,0,0,\ldots Therefore, the answer is 6.

Sample Input 3

10000000000 10 99959

Sample Output 3

492443256176507

Solution in Haskell (GHC 8.8.3) (judge verdict: Accepted)

import qualified Data.Text.Lazy as T
import qualified Data.Text.Lazy.IO as T
import qualified Data.Text.Lazy.Read as T
import qualified Data.Vector.Unboxed as VU

main :: IO ()
main = do
  let
    detectCycle :: Eq a => (a -> a) -> a -> ((Int, a), Int)
    detectCycle f = start 0 <$> id <*> (knot <$> id <*> id)
      where
        -- knot = a -> a -> a
        knot x y | x' == y'  = x'
                 | otherwise = knot x' y'
          where
            x' = f x
            y' = f (f y)
        -- start :: Int -> a -> a -> ((Int, a), Int)
        start k x y | x == y    = ((k, x), period x)
                    | otherwise = start (succ k) (f x) (f y)
        -- period :: a -> Int
        period x = period' 1 (f x)
          where
            period' k y | x == y    = k
                        | otherwise = period' (succ k) (f y)
  [n, x, m] <- map unsafeTextToInt . T.words <$> T.getLine :: IO [Int]
  let
    next :: Int -> Int
    next y = y * y `mod` m
    as = iterate next x :: [Int]
    ((h, k), l) = detectCycle next x
    (stem, cycle) = splitAt h . take (h + l) $ as
    h' = min h n :: Int
    n' = n - h' :: Int
    (q, r) = n' `divMod` l :: (Int, Int)
  print $ sum (take h' stem) + q * sum cycle + sum (take r cycle)

unsafeTextToInt :: T.Text -> Int
unsafeTextToInt s = case T.signed T.decimal s of
  Right (n, _) -> n
{-# INLINE unsafeTextToInt #-}