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)

use proconio::{
    fastout, input,
    marker::{Bytes, Chars, Isize1, Usize1},
};

#[fastout]
fn main() {
    input! {
        mut n:usize,mut x:usize,m:usize,
    }
    let mut v = vec![];
    let mut cycle = 0;
    let mut flag = vec![999999999; m];
    let mut t = 0;
    for i in 0.. {
        if flag[x] != 999999999 {
            t = flag[x];
            break;
        }
        flag[x] = i;
        cycle += x;
        v.push(x);
        x = (x * x) % m;
    }

    dbg!(cycle, v.len());
    let mut cv = vec![];
    for i in t..v.len() {
        cv.push(v[i]);
    }

    let mut ans = 0;

    let mut cv_sum = cv.iter().sum::<usize>();
    let mut ans = 0;

    if v.len() <= n {
        ans += cycle;
        n -= v.len();
    } else {
        println!("{}", v.iter().take(n).sum::<usize>());
        return;
    }

    if *v.last().unwrap() == 0 && n / v.len() >= 1 {
        ans += cv_sum;
    } else {
        ans += cv_sum * (n / cv.len());
    }

    n %= cv.len();
    dbg!(n);
    if *v.last().unwrap() != 0 {
        for i in cv.iter().take(n) {
            ans += *i;
        }
    }
    println!("{}", ans);
}