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(unused, non_snake_case, dead_code, non_upper_case_globals)]
use {
    proconio::{marker::*, *},
    std::*,
    std::{cmp::*, collections::*, convert::*, iter::*, marker::*, mem::*, ops::*},
};
fn main() {
    input! {//
        n:i64,
        x:i64,
        MOD:i64,
    }
    let mut a = x;
    let mut v = vec![];
    v.push(a);
    let mut dup = 0;
    for k in 2..=1234124111 {
        a = (a * a) % MOD;
        if v.contains(&a) {
            dup = a;
            break;
        }
        v.push(a);
    }
    let ln = v.len() as i64;
    let mut ans = 0i64;
    let mut tt = 0i64;
    let mut dd = 0i64;
    if n < ln {
        ans = v.iter().take(n as usize).fold(0, |sum, x| sum + x);
        println!("{}", ans);
        return;
    }
    dd = v.iter().fold(0, |sum, x| sum + x);
    ans += dd;
    let n = n - ln;
    let mut a = dup;
    let mut v = vec![];
    v.push(a);
    for ll in 1.. {
        a = (a * a) % MOD;
        if v.contains(&a) {
            break;
        }
        v.push(a);
    }
    // dbg!(&v);
    let ln = v.len() as i64;
    if n < ln {
        ans += v.iter().take(n as usize).fold(0, |sum, x| sum + x);
        println!("{}", ans);
        return;
    }
    for (i, &x) in v.iter().enumerate() {
        let i = (i) as i64;
        ans += x * ((n - i + ln - 1) / ln);
        // let fl = n / ln;
        // if fl * (i) * ln < n {
        //     ans += x * (fl + 1);
        // } else {
        //     ans += x * fl;
        // }
    }
    println!("{}", ans);
}