fn peaks(a: &[i64]) -> i64 {
    let n = a.len();
    if n <= 2 {
        return 0;
    }

    let mut sum = vec![0i64; n];
    let mut last: i64 = -1;
    let mut dist: i64 = 0;

    for i in 1..n - 1 {
        sum[i] = sum[i - 1];
        if a[i] > a[i - 1] && a[i] > a[i + 1] {
            dist = dist.max(i as i64 - last);
            last = i as i64;
            sum[i] += 1;
        }
    }

    sum[n - 1] = sum[n - 2];
    if sum[n - 1] == 0 {
        return 0;
    }

    dist = dist.max(n as i64 - last);

    let mut i = (dist >> 1) + 1;
    while i < dist {
        if n as i64 % i == 0 {
            let mut last_sum = 0i64;
            let mut j = i;
            while j <= n as i64 {
                if sum[(j - 1) as usize] <= last_sum {
                    break;
                }
                last_sum = sum[(j - 1) as usize];
                j += i;
            }
            if j > n as i64 {
                return n as i64 / i;
            }
        }
        i += 1;
    }

    let mut last_final = dist;
    while n as i64 % last_final != 0 {
        last_final += 1;
    }

    n as i64 / last_final
}