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 LuaJIT (2.0.4) (judge verdict: Wrong Answer)

local read = setmetatable({}, {__index = function(t, k) local a = {} for i=1,#k do table.insert(a, '*'..string.sub(k, i, i)) end local r = io.read local u = table.unpack or unpack return function() return r(u(a)) end end})
read.N = function(N) local t={} for i=1,N do t[i]=read.n() end return t end
string.totable = function(s) local t={} local u=string.sub for i=1,#s do t[i] = u(s, i, i) end return t end
string.split = function(s) local t={} for w in string.gmatch(s, "[^%s]+") do table.insert(t, w) end return (table.unpack or unpack)(t) end
----
local function gcd(a,b)
    if b == 0 then
        return a
    else
        return gcd(b, a % b)
    end
end

local function gcdmany(tbl)
    local ans = tbl[1]
    for i=2,#tbl do
        ans = gcd(ans, tbl[i])
    end
    return ans
end

local function lcm(a, b)
    return math.floor(a / gcd(a, b)) * b
end

local function lcmmany(tbl)
    local ans = tbl[1]
    for i=2, #tbl do
        ans = lcm(ans, tbl[i])
    end
    return ans
end
---
local N, M = read.nn()
local A = read.N(N)
table.sort(A)
local L = lcmmany(A)
local highest = A[#A]
local low_limit = math.floor(A[1] / 2)
local high_limit = M % L

local function check(x, ak)
    local x_shifted = x - math.floor(ak / 2)
    return x_shifted % ak == 0
end

local count_first_bad = 0
local count = 0
local count_last_bad = 0
local x = math.floor(highest / 2)
local function check2(x, ak)
    return x >= math.floor(ak / 2)
end
local function check3(x, ak)
    return x <= high_limit
end

while x <= L do
    local result = true
    local result_first = true
    local result_last = true
    for k, ak in ipairs(A) do
        result = result and check(x, ak)
        result_first = result_first and check2(x, ak)
        result_last = result_last and check3(x, ak)
    end
    if result then
        count = count + 1
        if not result_first then
            count_first_bad = count_first_bad + 1
        end
        if not result_last then
            count_last_bad = count_last_bad + 1
        end
    end
    x = x + highest
end
local roundup = L * math.ceil(M / L)
local cycles = math.floor(roundup / L)
if M % L == 0 then
    roundup = roundup + L
    cycles = cycles + 1
end
--print(L, roundup, cycles, count, count_first_bad, count_last_bad)
local ans = cycles * count - count_first_bad - count_last_bad
print(ans)