Problem:
Score : 400 points

Problem Statement

Given are a sequence A= {a_1,a_2,......a_N} of N positive even numbers, and an integer M.

Let a semi-common multiple of A be a positive integer X that satisfies the following condition for every k (1 \leq k \leq N):

There exists a non-negative integer p such that X= a_k \times (p+0.5).

Find the number of semi-common multiples of A among the integers between 1 and M (inclusive).

Constraints

1 \leq N \leq 10^5

1 \leq M \leq 10^9

2 \leq a_i \leq 10^9

a_i is an even number.

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N M
a_1 a_2 ... a_N

Output

Print the number of semi-common multiples of A among the integers between 1 and M (inclusive).

Sample Input 1

2 50
6 10

Sample Output 1

2

15 = 6 \times 2.5

15 = 10 \times 1.5

45 = 6 \times 7.5

45 = 10 \times 4.5

Thus, 15 and 45 are semi-common multiples of A. There are no other semi-common multiples of A between 1 and 50, so the answer is 2.

Sample Input 2

3 100
14 22 40

Sample Output 2

0

The answer can be 0.

Sample Input 3

5 1000000000
6 6 2 6 2

Sample Output 3

166666667

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

macro_rules! scan_sub {
    ( $itr:ident, $t:ty ) => {
        let mut buf = String::new();
        let $itr = {
            while buf.trim().len() == 0 {
                buf = String::new();
                std::io::stdin().read_line(&mut buf).unwrap();
            }
            buf.split_whitespace().map(|n| n.parse::<$t>().unwrap())
        };
    };
}

macro_rules! scan {
    ( $x:ident; Vec<$t:ty> ) => {
        scan_sub!(itr, $t);
        let $x = itr.collect::<Vec<_>>();
    };
    ( $( $x:ident ),*; $t:ty ) => {
        scan_sub!(itr, $t);
        let mut itr = itr;
        $(
            let $x = itr.next().unwrap();
        )*
    };
}

fn gcd(a: u64, b: u64) -> u64 {
    let (mut a, mut b) = if a < b { (a, b) } else { (b, a) };

    while a > 0 {
        let (t, u) = (b % a, a);
        a = t;
        b = u;
    }

    return b;
}

fn lcm(a: u64, b: u64) -> u64 {
    let g = gcd(a, b);
    return a * b / g;
}

fn main() {
    scan!(n, m; usize);
    let m = m as u64;
    scan!(array; Vec<u64>);
    let mut array = array.into_iter().map(|i| i / 2).collect::<Vec<_>>();
    array.sort();
    let array = array;

    let mut l = array[0];
    for i in 1..n {
        l = lcm(l, array[i]);
    }
    let l = l;

    let mut t = 1;
    let mut u = l;
    let mut ans = 0;
    while u < m {
        ans += 1;
        t += 2;
        u = l * t;
    }

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