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)

fn main() {
    proconio::input! {
        n: i128,
        x: i128,
        m: i128,
    }
    fn f(x: i128, m: i128) -> i128 {
        x % m
    }
    let mut a_s = vec![x];
    let mut map = std::collections::HashMap::new();
    map.insert(x, 0);
    for i in 1..n {
        let next = f(a_s.last().unwrap().pow(2), m);
        match map.get(&next) {
            Some(start) => {
                let end = i;
                let loop_indices = end - start;
                let loop_sum = a_s
                    .iter()
                    .skip(*start as usize)
                    .take(loop_indices as usize)
                    .sum::<i128>();
                let before_loop_sum = a_s.iter().take(*start as usize).sum::<i128>();
                let loop_times = (n - start) / loop_indices;
                let mod_indices = (n - start) % loop_indices;
                let mod_sum = a_s
                    .iter()
                    .skip(*start as usize)
                    .take(mod_indices as usize)
                    .sum::<i128>();
                let ans = before_loop_sum + loop_times * loop_sum + mod_sum;
                println!("{}", ans);
                return;
            }
            None => {
                map.insert(next, i);
            }
        }
        a_s.push(next);
    }
    let ans = a_s.iter().sum::<i128>();
    println!("{}", ans);
}