#ifdef DEBUG
#define _GLIBCXX_DEBUG
#endif
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdint>
#include <utility>
#include <cassert>
#include <numeric>

using namespace std;

class Solver {
private:
	struct Diff {
		int64_t len;
		int64_t cnt;
		int64_t psum; // strictly before this segment
	};
	
public:
	Solver() : a{{0, 0, 0}} {
	}
	
	void add(int64_t x) {
		assert(stk.empty());
		doAdd({x, 1, 0});
		assert(stk.empty());
	}
	
	int64_t total() {
		int64_t ans = 0;
		for (const auto &it : a) {
			ans += it.cnt;
		}
		return ans;
	}
	
private:
	void doAdd(Diff d) {
		const size_t stkSz = stk.size();
		if (addSimple(d, false)) {
			return;
		}
		const Diff &p = a.back();
		if (d.len < p.len) {
			Diff p = pop();
			if (p.cnt == 1 && p.len > p.psum) {
				d.cnt += p.len / d.len;
				p.len %= d.len;
				if (p.len != 0) {
					doAdd(p);
				}
				doAdd(d);
				return;
			}
			const int64_t g = gcd(d.len, p.len);
			doAdd({g, (d.len / g * d.cnt) + (p.len / g * p.cnt), 0});
			return;
		}
		if (d.len > p.len) {
			d.psum = p.psum + p.len*p.cnt;
			stk.push_back(d);
			int64_t lay = 0;
			for (;;) {
				assert(a.size() > 1);
				Diff p = pop();
				const int64_t nxt = p.len*p.cnt + lay;
				if (nxt < d.len) {
					stk.push_back(p);
					lay = nxt;
					continue;
				}
				const int64_t dif = d.len - lay;
				const int64_t db = dif % p.len, da = p.len - db;
				if (db == 0) {
					a.push_back(p);
					assert(stk.size() >= stkSz);
					while (stk.size() != stkSz) {
						a.push_back(stk.back());
						stk.pop_back();
					}
					return;
				}
				const int64_t cut = dif / p.len;
				if (p.cnt - cut == 1 && p.len > p.psum) {
					if (cut != 0) {
						stk.push_back({p.len, cut, 0});
					}
					doAdd({da, 1, 0});
					doAdd({db, 1, 0});
				} else {
					const int64_t g = gcd(da, db);
					doAdd({g, p.len / g * p.cnt, 0});
				}
				assert(stk.size() >= stkSz);
				while (stk.size() != stkSz) {
					addSimple(stk.back(), true);
					stk.pop_back();
				}
				return;
			}
		}
		assert(false);
	}
	
	bool addSimple(Diff d, bool force) {
		assert(d.cnt != 0 && d.len != 0);
		Diff &p = a.back();
		d.psum = p.psum + p.cnt*p.len;
		if (d.len > d.psum) {
			a.push_back(d);
			return true;
		}
		if (d.len == p.len) {
			p.cnt += d.cnt;
			return true;
		}
		if (d.len % p.len == 0) {
			p.cnt += d.len / p.len * d.cnt;
			return true;
		}
		if (d.len == d.psum || force) {
			a.push_back(d);
			return true;
		}
		return false;
	}
	
	Diff pop() {
		Diff res = a.back();
		a.pop_back();
		return res;
	}
	
	vector<Diff> stk;
	vector<Diff> a;  // first element here is dummy, i.e. {0, 0, 0}
};

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	for (;;) {
		int n;
		int64_t l;
		cin >> n >> l;
		if (n == 0) {
			break;
		}
		
		bool hasOne = false;
		vector<int64_t> a(n+1);
		a[n] = 0;
		for (int i = 0; i < n; ++i) {
			cin >> a[i];
			if (a[i] == 1) {
				hasOne = true;
			}
		}
		if (!hasOne) {
			++n;
			a.push_back(1);
		}
		sort(begin(a), end(a));
		
		vector<int64_t> d(n);
		for (int i = 0; i < n; ++i) {
			d[i] = a[i+1] - a[i];
		}
		
		Solver solver;
		for (int i = 0; i < n; ++i) {
			solver.add(d[i]);
		}
		cout << solver.total() << "\n";
	}
	return 0;
}