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: Accepted)

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 max_two_num = std::u64::MAX;
    let mut array = array.into_iter()
        .map(|i| {
            let mut c = i;
            let mut num = 0;
            while c % 2 == 0 {
                c /= 2;
                num += 1;
            }
            if num < max_two_num {
                max_two_num = num;
            }
            i / 2
        }).collect::<Vec<_>>();
    max_two_num -= 1;
    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;
    let mut ans = 0;
    loop {
        u = l * t;
        if u > m { break; }
        t += 2;
        let mut c = u;
        let mut num = 0;
        while c % 2 == 0 {
            c /= 2;
            num += 1;
        }
        if num <= max_two_num {
            ans += 1;
        }
    }

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