Problem:
Score : 300 points

Problem Statement

There are N cities on a number line. The i-th city is located at coordinate x_i.

Your objective is to visit all these cities at least once.

In order to do so, you will first set a positive integer D.

Then, you will depart from coordinate X and perform Move 1 and Move 2 below, as many times as you like:

Move 1: travel from coordinate y to coordinate y + D.

Move 2: travel from coordinate y to coordinate y - D.

Find the maximum value of D that enables you to visit all the cities.

Here, to visit a city is to travel to the coordinate where that city is located.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq X \leq 10^9

1 \leq x_i \leq 10^9

x_i are all different.

x_1, x_2, ..., x_N \neq X

Input

Input is given from Standard Input in the following format:

N X
x_1 x_2 ... x_N

Output

Print the maximum value of D that enables you to visit all the cities.

Sample Input 1

3 3
1 7 11

Sample Output 1

2

Setting D = 2 enables you to visit all the cities as follows, and this is the maximum value of such D.

Perform Move 2 to travel to coordinate 1.

Perform Move 1 to travel to coordinate 3.

Perform Move 1 to travel to coordinate 5.

Perform Move 1 to travel to coordinate 7.

Perform Move 1 to travel to coordinate 9.

Perform Move 1 to travel to coordinate 11.

Sample Input 2

3 81
33 105 57

Sample Output 2

24

Sample Input 3

1 1
1000000000

Sample Output 3

999999999

Solution in C (Clang 3.8.0) (judge verdict: Accepted)

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <ctype.h>
#include <stdint.h>
#include <string.h>
#include <wchar.h>

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) < 0 ? -(a) : (a))
#define ABSS(a, b) ((a) > (b) ? (a) - (b) : (b) - (a))

int compare_f(const void *a, const void *b) {
	return *((size_t *)a) < *((size_t *)b) ? -1 : 1;
}

static size_t comb(const size_t n, const size_t r) {
	size_t result = 1;

	for (size_t i = 0; i < r; i++) {
		result *= n - i;
		result /= i + 1;
	}

	return result;
}

static size_t x[100000];

int main(void) {
	size_t N, X;

	scanf("%zu %zu\n", &N, &X);
	for (size_t idx = 0; idx < N; idx++) {
		scanf("%zu", &x[idx]);
		if (idx < N - 1) {
			scanf(" ");
		}
	}
	
	qsort(x, N, sizeof(size_t), compare_f);

	size_t minAbss = (size_t)UINT32_MAX;

	if (X < x[0]) {
		const size_t rightAbssX = x[0] - X;
		if (rightAbssX < minAbss) {
			minAbss = rightAbssX;
		}
	}
	else if (x[N - 1] < X) {
		const size_t leftAbssX = X - x[N - 1];
		if (leftAbssX < minAbss) {
			minAbss = leftAbssX;
		}
	}

	for (size_t idx = 0; idx < N - 1; idx++) {
		const size_t abss = x[idx + 1] - x[idx];
		if (abss < minAbss) {
			minAbss = abss;
		}
		if (x[idx] < X && X < x[idx + 1]) {
			const size_t leftAbssX = X - x[idx];
			if (leftAbssX < minAbss) {
				minAbss = leftAbssX;
			}
			const size_t rightAbssX = x[idx + 1] - X;
			if (rightAbssX < minAbss) {
				minAbss = rightAbssX;
			}
		}
	}

	size_t dCandidate = minAbss;
	while (1 < dCandidate) {
		bool isCommonDivisor = true;
		for (size_t idx = 0; idx < N; idx++) {
			const size_t abss = ABSS(X, x[idx]);
			if (abss%dCandidate != 0) {
				isCommonDivisor = false;
			}
		}
		if (isCommonDivisor) {
			break;
		}
		dCandidate--;
	}

	printf("%zu\n", dCandidate);

	return 0;
}