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 C (GCC 5.4.1) (judge verdict: Accepted)

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>

#define ARR_MAX 100000
#define BUF_SIZE (ARR_MAX*12)

int get_int2(int *a1, int *a2) {
#ifdef BUF_SIZE
  char line[BUF_SIZE];
  if(!fgets(line, BUF_SIZE, stdin)) return -1;
  sscanf(line, "%d %d", a1, a2);
#else
#error
#endif
  return 0;
}

// <arr[0]> <arr[1]> .. <arr[size-1]>
int fget_array_half(int *arr, int size) {
#ifdef BUF_SIZE
    char line[BUF_SIZE];
    char *tmpbuf = line;
    int i;
    if(!fgets(line, BUF_SIZE, stdin)) return -1;
    for(i = 0; i < size; i++) {
        char *tmp = strtok(tmpbuf, " ");
        arr[i] = strtol(tmp, NULL, 10);
        arr[i] /= 2;
        tmpbuf = NULL;
    }
#else
#error
#endif
    return 0;
}

// assume that a <= b
uint64_t gcd(uint64_t a, uint64_t b) {
    if(a==0) return b;
    return gcd(b%a, a);
}

int desc(const void *a, const void *b) {
    return *(int*)b - *(int*)a;
}

int main(void) {
    int size, ulimit;
    int arr[ARR_MAX];
    get_int2(&size, &ulimit);
    fget_array_half(arr, size);
    int i;
    qsort(arr, size, sizeof(int), desc);

    uint64_t res = arr[0];
    int prev = arr[0];
    for(i = 1; i < size; i++) {
        int cur = arr[i];
        if(cur == prev) continue;
        // ensure that arr[i] <= res
        uint64_t g = gcd(cur, res);
        res = (res/g)*cur; // calc lcm
        prev = cur;
        // too big..
        if(res > ulimit) break;
    }
#ifdef DEBUG
    printf("ans: %llu(lcm)*(odd number)\n", res);
#endif
    if(res > ulimit) { printf("0\n"); return 0; }
    for(i = 0; i < size; i++) {
        int m = res / arr[i];
        // if even, No answer
        if(!(m%2)) { printf("0\n"); return 0; } 
    }
    uint64_t div = (uint64_t)ulimit/res;
    // answer should be integer
    printf("%d\n", (int)(div+1)/2);
    return 0;
}