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::input;

fn main() {
    input! {
        n: i64,
        x: i64,
        m: i64,
    }

    let mut v = vec![false; m as usize + 5];
    let mut now = x;
    while !v[now as usize] {
        v[now as usize] = true;
        now = (now * now) % m;
    }
    let start_loop = now;

    let mut init_len = 0i64;
    let mut init_s = 0i64;
    let mut now = x;
    while now != start_loop {
        init_len += 1;
        init_s += now;
        now = (now * now) % m;
    }
    let init_len = init_len;
    let init_s = init_s;

    let mut loop_len = 1i64;
    let mut loop_s = start_loop;
    let mut now = (start_loop * start_loop) % m;
    while now != start_loop {
        loop_len += 1;
        loop_s += now;
        now = (now * now) % m;
    }
    let loop_len = loop_len;
    let loop_s = loop_s;

    // dbg!(start_loop, init_len, init_s, loop_len, loop_s);

    if n < init_len {
        // dbg!("route 1");
        let mut ans = 0i64;
        let mut now = x;
        for _ in 0..n {
            ans += now;
            now = (now * now) % m;
        }
        println!("{}", ans);
    } else {
        // dbg!("route 2");
        let mut ans = 0;
        let rem = n - init_len;
        ans += init_s;
        // dbg!(ans);

        ans += loop_s * (rem / loop_len);
        // dbg!(ans);

        let rem = rem % loop_len;
        let mut now = start_loop;
        for _ in 0..rem {
            ans += now;
            now = (now * now) % m;
        }

        println!("{}", ans);
    }
}