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)

use std::vec::Vec;
use std::collections::HashSet;
use std::cmp::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>().split_whitespace().map(|e| e.parse().ok().unwrap()).collect()
}

fn read_touple<T: std::str::FromStr + Copy>() -> (T, T) {
  let v: Vec<T> = read_vec();
  assert_eq!(v.len(), 2);
  (v[0], v[1])
}

fn main() {
    let (n, m) = read_touple::<usize>();
    let a: Vec<usize> = read_vec();
    let b: Vec<usize> = a.iter().map(|&x| x / 2).collect();
    let c: Vec<usize> = a.iter().map(|&x| count2(x)).collect();
    let l = b.iter().fold(1, |acc, &x| (acc * x) / gcd(x, acc));
    let mut d = false;
    for i in 0..n {
      if c[0] != c[i] {
         d = true;
      }
    }
    //let ans: usize = (m / l) / 2;
    let ans: usize = if d {
       0
    } else if (m / l) % 2 == 0  {
       (m / l) / 2
    } else {
      (m / l) / 2 + 1
    };

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


fn gcd(a: usize, b: usize) -> usize {
  if b > a {
    gcd(b, a);
  }

  if a % b == 0 {
    return b;
  }

  let r: usize = a % b;

  return gcd(b, r);
}

fn count2(x: usize) -> usize {
  let mut res = 0;
  let mut x = x;
  while x % 2 == 0{
    res += 1;
    x /= 2;
  }
  res
}