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 #-}
