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 Rust (1.42.0) (judge verdict: Accepted)

#![doc = " # Bundled libraries"]
#[allow(unused_imports)]
use itertools::Itertools;
use proconio::input;
#[allow(unused_imports)]
use proconio::marker::*;
fn main() {
    input! { n : u64 , mut x : usize , m : usize , }
    let mut t = vec![None; m];
    let mut v = vec![];
    while t[x] == None {
        t[x] = Some(v.len());
        v.push(x as u64);
        x *= x;
        x %= m;
    }
    if n <= v.len() as u64 {
        println!("{}", v[..n as usize].iter().sum::<u64>());
    } else {
        let y = t[x].unwrap();
        let mut res = v[..y].iter().sum::<u64>();
        let n = n - y as u64;
        let v = v[y..].iter().collect_vec();
        for i in 0..v.len() {
            res += v[i] * (n / v.len() as u64);
            if (i as u64) < (n % v.len() as u64) {
                res += v[i];
            }
        }
        println!("{}", res);
    }
}