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)

#![allow(non_snake_case)]
#![allow(unused_imports)]
#![allow(dead_code)]

use proconio::{input, fastout};
use proconio::marker::*;
use whiteread::parse_line;
use std::collections::*;
use num::*;
use num_traits::*;
use superslice::*;
use std::ops::*;

use itertools::Itertools;
use itertools_num::ItertoolsNum;


#[fastout]
fn solve() {
    const MOD: usize = 1_000_000_007;
    const INF: usize = std::usize::MAX;
    
    input!{
        n: usize, x: usize, m: usize,
    }

    let mut vec = vec![x];
    let mut set: HashSet<usize> = HashSet::new();
    let mut idx = 0;
    for j in 0..n-1 {
        let t = (*vec.last().unwrap()).pow(2) % m;

        if !set.contains(&t) {
            set.insert(t);
            vec.push(t);
        } else {
            for (i, &v) in vec.iter().enumerate() {
                if v == t {
                    idx = i;
                    break;
                }
            }
            break
        }
    }

    
    let rep = vec[idx..].iter().map(|x| *x).collect::<Vec<usize>>();

    let rep_cnt = (n - idx) / rep.len();
    let rep_mod = (n - idx) % rep.len();

    let ans = vec[..idx].iter().sum::<usize>() + rep.iter().sum::<usize>() * rep_cnt + rep[..rep_mod].iter().sum::<usize>();    

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

fn main() {
    solve()
}

#[cfg(test)]
mod test {
    use super::solve;
}