#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <memory.h>

using namespace std;
long long MOD = 7340033;
long long matr[32][4][1001];

int fs[5] = {1, 1, 2, 6, 24};

long long f(int n, int m, int k)
{
    if (n == 0)
        return k == 0;
    if (n == 1 && m == 1)
        return k <= 1 ? 1 : 0;
    if (k == 0)
        return 1;
    if (matr[n][m-1][k] != -1)
        return matr[n][m-1][k];

    long long res = 0;
    if (m == 1)
        res = f(n-1, 4, k-1);
    else
    {
        for (int i = 0; i <= k; i++)
            res = (res + f(n, 1, i) * f(n, m-1, k - i)) % MOD;
    }

    matr[n][m-1][k] = res;

    return res;
}

int main()
{
    for (int i = 0; i < 32; i++)
        for (int k = 0; k < 4; k++)
            for (int j = 0; j < 1001; j++)
            matr[i][k][j] = -1;
    int N;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        int n = 0;
        while (a > 0)
        {
            if (a % 2 == 1)
                n++;
            else
                break;
            a /= 2;
        }
        if (a == 0)
            n--;
        int r = f(n, 1, b);
        printf("%d\n", r);
    }

    return 0;
}


#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <algorithm>
#include <math.h>
#include <memory.h>

using namespace std;
long long MOD = 7340033;
long long matr[32][4][1001];

int fs[5] = {1, 1, 2, 6, 24};

long long f(int n, int m, int k)
{
    if (n == 0)
        return k == 0 ? 1 : 0;
    if (k == 0)
        return 1;
    if (matr[n][m-1][k] != -1)
        return matr[n][m-1][k];

    long long res = 0;
    if (m == 1)
        res = f(n-1, 4, k-1);
    else
    {
        for (int i = 0; i <= k; i++)
            res = (res + f(n, m-1, k - i)) % MOD;
    }

    matr[n][m-1][k] = res;

    return res;
}

int main()
{
    for (int i = 0; i < 32; i++)
        for (int k = 0; k < 4; k++)
            for (int j = 0; j < 1001; j++)
            matr[i][k][j] = -1;
    int N;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
    {
        int a, b;
        scanf("%d%d", &a, &b);
        int n = 0;
        while (a > 0)
        {
            if (a % 2 == 1)
                n++;
            else
                break;
            a /= 2;
        }
        if (a == 0)
            n--;
        int r = f(n, 1, b);
        printf("%d\n", r);
    }

    return 0;
}


#include <algorithm>
#include <iostream>
#include <sstream>
#include <complex>
#include <numeric>
#include <cstring>
#include <vector>
#include <string>
#include <cstdio>
#include <deque>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define all(a)		(a).begin(),(a).end()
#define sqr(x)      ((x) * (x))
#define sz(a)		int((a).size())
#define FOR(i,a,b)	for(int i=a;i<b;++i)
#define REP(i,n)	FOR(i,0,n)
#define UN(v)		sort(all(v)),(v).erase(unique((v).begin(),(v).end()),(v).end())
#define CL(a)		memset(a,0,sizeof a)
#define pb			push_back
#define X			first
#define Y			second
#define MP(a,b) make_pair(a, b)
#define Fopen(file) freopen(file, "r", stdin)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int, int> pii;

const int MOD = 7340033;
const int M = 35;
const int K = 1004;
int q, n ,k;

ll dp[M][K];
ll f[4][K];
int main()
{
	f[0][0] = 1;
	dp[0][0] = 1;
	FOR(i, 1, M)
	{
		dp[i][0] = 1;
		FOR(k, 1, K)
		{
			FOR(j, 1, 4)
			{
				FOR(t, 0, k)
				{
				   f[j][k-1] += (f[j-1][t] * dp[i-1][k-1-t]) % MOD;
				   f[j][k-1] %= MOD;
				}
			}
			dp[i][k] = f[3][k-1];
		}
		memset(f, 0, sizeof(f));
		FOR(k, 0, K) f[0][k] = dp[i][k];
	}
	cin >> q;
	FOR(i, 0, q)
	{
		cin >> n >> k;
		int d = 0;
		while(n % 2 && n - 1)
		{
			++d;
			n /= 2;
		}
		printf("%d\n", dp[d][k]);
	}
	return 0;

}


#include <cstdio>
#include <algorithm>

const long con = 7340033;

const long maxlog = 30;
const long maxk = 1001;

long testcase;
long n, m;

long long f[30][1010][2];

void prepare()
{
	memset(f, 0, sizeof(f));
	f[0][0][0] = 1;
	f[0][0][1] = 1;

	for (long i = 1; i < maxlog; ++i)
	{
		f[i][0][0] = 1;
		for (long j = 0; j < maxk; ++j)
		{
			for (long k = 0; k < j; ++k)
			{
				f[i][j][0] += f[i - 1][k][1] * f[i - 1][j - k - 1][1];
				f[i][j][0] %= con;
			}
			for (long k = 0; k <= j; ++k)
			{
				f[i][j][1] += f[i][k][0] * f[i][j - k][0];
				f[i][j][1] %= con;
			}
		}
	}
}

int main()
{
	//freopen("D.in", "r", stdin);
	//freopen("D.out", "w", stdout);

	prepare();

	scanf("%d", &testcase);

	long temp;

	for (long i = 0; i < testcase; ++i)
	{
		scanf("%d %d", &n, &m);
		temp = 0;
		while ((n & 1) && (n > 1))
		{
			n = (n - 1)/2;
			++temp;
		}
		printf("%d\n", long(f[temp][m][0]));
	}

	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <string>
#include <string.h>
#include <queue>
#include <set>
#include <complex>
#include <iostream>
#include <fstream>
#include <time.h>
#include <functional>
using namespace std;
long long dp[32][1001];
long long dp1[2][1001];
const int MOD=7340033;
int main()
{
    dp[0][0]=1;
    for(int i=1;i<32;i++)
    {
        memset(dp1[0],0,sizeof(dp1[0]));
        dp1[0][1]=1;
        bool flag=0;
        for(int j=0;j<4;j++)
        {
            flag=!flag;
            memset(dp1[flag],0,sizeof(dp1[flag]));
            for(int k=1;k<=1000;k++)
            {
                for(int l=1;l<=k;l++)
                {
                    dp1[flag][k]+=dp1[!flag][l]*dp[i-1][k-l];
                }
                dp1[flag][k]%=MOD;
            }
        }
        memcpy(dp[i],dp1[flag],sizeof(dp1[flag]));
        dp[i][0]=1;
    }
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int n,k;
        scanf("%d %d",&n,&k);
        int cnt=0;
        while(n>1&&n&1) {n>>=1; cnt++;}
        printf("%I64d\n",dp[cnt][k]);
    }
}


#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <map>
#include <string>
#include <string.h>
#include <queue>
#include <set>
#include <complex>
#include <iostream>
#include <fstream>
#include <time.h>
#include <functional>
using namespace std;
long long dp[32][1001];
long long dp1[2][1001];
const int MOD=7340033;
int main()
{
    dp[0][0]=1;
    for(int i=1;i<32;i++)
    {
        memset(dp1[0],0,sizeof(dp1[0]));
        dp1[0][1]=1;
        bool flag=0;
        for(int j=0;j<4;j++)
        {
            flag=!flag;
            memset(dp1[flag],0,sizeof(dp1[flag]));
            for(int k=0;k<=1000;k++)
            {
                for(int l=1;l<=1000;l++)
                {
                    dp1[flag][k]+=dp1[!flag][l]*dp[i-1][k-l];
                }
                dp1[flag][k]%=MOD;
            }
        }
        memcpy(dp[i],dp1[flag],sizeof(dp[flag]));
        dp[i][0]=1;
    }
    int q;
    scanf("%d",&q);
    while(q--)
    {
        int n,k;
        scanf("%d %d",&n,&k);
        int cnt=0;
        while(n>1&&n&1) {n>>=1; cnt++;}
        printf("%I64d\n",dp[cnt][k]);
    }
}


#pragma comment(linker,"/STACK:65000000")
#include <iostream>
#include <cstdio>
#include <bitset>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <string>
#include <cstring>
#include <fstream>
#include <functional>
#include <stack>
#include <complex>
#include <wchar.h>
#include <wctype.h>
#include <cmath>
#include <queue>
#include <ctime>
#include <numeric>
#include <assert.h>

using namespace std;

template<typename T> T mabs(const T &a){ return a<0?-a:a;}
#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define SQR(x) ((x)*(x))
#define all(c) (c).begin(), (c).end()

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef short int si;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;

const double PI = acos(-1.0);

void run()
{
	int t;
	cin>>t;
	const int mod = 7340033;
	ll D[1001][30]={0};
	ll Pr[1001][30]={0};
	D[0][0] = 1;
	Pr[0][0] = 1;
	rep(deep,1,30)
	{
		rep(k,0,1001)
		{
			rep(a,0,k)
				D[k][deep] += Pr[a][deep-1]*Pr[k-a-1][deep-1] % mod;
			D[k][deep]=(D[k][deep]+D[k][deep-1])%mod;
		}
		rep(k,0,1001)
		{
			rep(a,0,k+1)
				Pr[k][deep] += D[a][deep]*D[k-a][deep] % mod;
			Pr[k][deep] %= mod;
		}
	}
	rep(i,0,t)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		int deep=0;
		while ((n&1))
		{
			++deep;
			n>>=1;
		}
		if (n==0) --deep;
		int res = D[k][deep];
		printf("%d\n",res);
	}
}

int main()
{
#ifdef _MONYURA_
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
	time_t st=clock();
#else
	//freopen(name".in","r",stdin);
	//freopen(name".out","w",stdout);
#endif
	run();
#ifdef _MONYURA_
	printf("=============\n");
	printf("Time: %.2lf sec\n",(clock()-st)/double(CLOCKS_PER_SEC));
#endif

	return 0;
}

/*
24 54 96 108
*/


#pragma comment(linker,"/STACK:65000000")
#include <iostream>
#include <cstdio>
#include <bitset>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <string>
#include <cstring>
#include <fstream>
#include <functional>
#include <stack>
#include <complex>
#include <wchar.h>
#include <wctype.h>
#include <cmath>
#include <queue>
#include <ctime>
#include <numeric>
#include <assert.h>

using namespace std;

template<typename T> T mabs(const T &a){ return a<0?-a:a;}
#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define SQR(x) ((x)*(x))
#define all(c) (c).begin(), (c).end()

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef short int si;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;

const double PI = acos(-1.0);

void run()
{
	int t;
	cin>>t;
	const int mod = 7340033;
	ll D[1002][31]={0};
	ll Pr[1002][31]={0};
	D[0][0] = 1;
	Pr[0][0] = 1;
	rep(deep,1,31)
	{
		D[0][deep]=1;
		rep(k,0,1002)
		{
			rep(a,0,k)
				D[k][deep] += Pr[a][deep-1]*Pr[k-a-1][deep-1] % mod;
			D[k][deep]%=mod;
		}
		rep(k,0,1002)
		{
			rep(a,0,k+1)
				Pr[k][deep] += D[a][deep]*D[k-a][deep] % mod;
			Pr[k][deep] %= mod;
		}
	}
	rep(i,0,t)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		int deep=0;
		while ((n&1))
		{
			++deep;
			n>>=1;
		}
		if (n==0) --deep;
		int res = D[k][deep];
		printf("%d\n",res);
	}
}

int main()
{
#ifdef _MONYURA_
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
	time_t st=clock();
#else
	//freopen(name".in","r",stdin);
	//freopen(name".out","w",stdout);
#endif
	run();
#ifdef _MONYURA_
	printf("=============\n");
	printf("Time: %.2lf sec\n",(clock()-st)/double(CLOCKS_PER_SEC));
#endif

	return 0;
}

/*
24 54 96 108
*/


#pragma comment(linker,"/STACK:65000000")
#include <iostream>
#include <cstdio>
#include <bitset>
#include <memory>
#include <algorithm>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <string>
#include <cstring>
#include <fstream>
#include <functional>
#include <stack>
#include <complex>
#include <wchar.h>
#include <wctype.h>
#include <cmath>
#include <queue>
#include <ctime>
#include <numeric>
#include <assert.h>

using namespace std;

template<typename T> T mabs(const T &a){ return a<0?-a:a;}
#define rep(x,y,z) for(int x=(y),e##x=(z);x<e##x;x++)
#define SQR(x) ((x)*(x))
#define all(c) (c).begin(), (c).end()

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef short int si;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;

const double PI = acos(-1.0);

void run()
{
	int t;
	cin>>t;
	const int mod = 7340033;
	ll D[1002][31]={0};
	ll Pr[1002][31]={0};
	D[0][0] = 1;
	Pr[0][0] = 1;
	rep(deep,1,31)
	{
		rep(k,0,1002)
		{
			rep(a,0,k)
				D[k][deep] += Pr[a][deep-1]*Pr[k-a-1][deep-1] % mod;
			D[k][deep]=(D[k][deep]+D[k][deep-1])%mod;
		}
		rep(k,0,1002)
		{
			rep(a,0,k+1)
				Pr[k][deep] += D[a][deep]*D[k-a][deep] % mod;
			Pr[k][deep] %= mod;
		}
	}
	rep(i,0,t)
	{
		int n,k;
		scanf("%d%d",&n,&k);
		int deep=0;
		while ((n&1))
		{
			++deep;
			n>>=1;
		}
		if (n==0) --deep;
		ll val = 1LL<<(2*deep);
		int res = val<k ? 0 : D[k][deep];
		printf("%d\n",res);
	}
}

int main()
{
#ifdef _MONYURA_
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
	time_t st=clock();
#else
	//freopen(name".in","r",stdin);
	//freopen(name".out","w",stdout);
#endif
	run();
#ifdef _MONYURA_
	printf("=============\n");
	printf("Time: %.2lf sec\n",(clock()-st)/double(CLOCKS_PER_SEC));
#endif

	return 0;
}

/*
24 54 96 108
*/


using System;
using System.Linq;

namespace CodeforcesRound181div2.TaskD
{
    public class Task
    {
        const long MaxDepth = 29;
        const long MaxK = 1000;
        const long Mod = 7340033;
        readonly long[,] Dp = new long[MaxDepth + 1, MaxK + 2];
        readonly long[] D = new long[MaxK * 2 + 2];

        public static void Main()
        {
            var task = new Task();
            task.Solve();
        }

        private void Solve()
        {
            Console.ReadLine();

            Dp[0, 0] = 1;
            Dp[1, 0] = 1;
            Dp[1, 1] = 1;
            for (var d = 2; d <= MaxDepth; d++)
            {
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 <= MaxK; k2++)
                    {
                        D[k1 + k2] += Dp[d - 1, k1]*Dp[d - 1, k2];
                    }
                }
                for (var i = 0; i < D.Length; i++) D[i] %= Mod;
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 <= MaxK - k1; k2++)
                    {
                        Dp[d, k1 + k2 + 1] += D[k1] * D[k2];
                    }
                }
                for (var i = 0; i <= MaxK; i++) Dp[d, i] %= Mod;
                Dp[d, 0] = 1;

                Array.Clear(D, 0, D.Length);
            }

            string line;
            while ((line = Console.ReadLine())!=null)
            {
                var data = line.Split().Select(long.Parse).ToList();
                var n = data[0];
                var k = data[1];
                var depth = 0;
                while (n > 1 && n % 2 == 1)
                {
                    n /= 2;
                    depth++;
                }
                var count = Dp[depth, k];
                Console.WriteLine(count);
            }
        }
    }
}


using System;
using System.Linq;

namespace CodeforcesRound181div2.TaskD
{
    public class Task
    {
        const long MaxDepth = 29;
        const long MaxK = 1000;
        const long Mod = 7340033;
        readonly long[,] Dp = new long[MaxDepth + 1, MaxK + 2];
        readonly long[] D = new long[MaxK * 2 + 2];

        public static void Main()
        {
            var task = new Task();
            task.Solve();
        }

        private void Solve()
        {
            Input.Next();

            Dp[0, 0] = 1;
            Dp[1, 0] = 1;
            Dp[1, 1] = 1;
            for (var d = 2; d <= MaxDepth; d++)
            {
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 <= MaxK; k2++)
                    {
                        D[k1 + k2] += Dp[d - 1, k1]*Dp[d - 1, k2];
                    }
                }
                for (var i = 0; i < D.Length; i++) D[i] %= Mod;
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 <= MaxK - k1; k2++)
                    {
                        Dp[d, k1 + k2 + 1] += D[k1] * D[k2];
                    }
                }
                for (var i = 0; i <= MaxK; i++) Dp[d, i] %= Mod;
                Dp[d, 0] = 1;

                Array.Clear(D, 0, D.Length);
            }

            long n, k;
            while (Input.Next(out n, out k))
            {
                var depth = 0;
                while (n > 1 && n % 2 == 1)
                {
                    n /= 2;
                    depth++;
                }
                var count = Dp[depth, k];
                Console.WriteLine(count);
            }
        }
    }

    public class Input
    {
        private static string _line;

        public static bool Next()
        {
            _line = Console.ReadLine();
            return !string.IsNullOrEmpty(_line);
        }

        public static bool Next(out long a)
        {
            var ok = Next();
            a = ok ? long.Parse(_line) : 0;
            return ok;
        }

        public static bool Next(out long a, out long b)
        {
            var ok = Next();
            if (ok)
            {
                var array = _line.Split(' ').Select(long.Parse).ToArray();
                a = array[0];
                b = array[1];
            }
            else
            {
                a = b = 0;
            }

            return ok;
        }

        public static bool Next(out long a, out long b, out long c)
        {
            var ok = Next();
            if (ok)
            {
                var array = _line.Split(' ').Select(long.Parse).ToArray();
                a = array[0];
                b = array[1];
                c = array[2];
            }
            else
            {
                a = b = c = 0;
            }
            return ok;
        }

        public static bool Next(out long a, out long b, out long c, out long d)
        {
            var ok = Next();
            if (ok)
            {
                var array = _line.Split(' ').Select(long.Parse).ToArray();
                a = array[0];
                b = array[1];
                c = array[2];
                d = array[3];
            }
            else
            {
                a = b = c = d = 0;
            }
            return ok;
        }

        public static bool Next(out long a, out long b, out long c, out long d, out long e)
        {
            var ok = Next();
            if (ok)
            {
                var array = _line.Split(' ').Select(long.Parse).ToArray();
                a = array[0];
                b = array[1];
                c = array[2];
                d = array[3];
                e = array[4];
            }
            else
            {
                a = b = c = d = e = 0;
            }
            return ok;
        }
    }
}


using System;
using System.Linq;

namespace CodeforcesRound181div2.TaskD
{
    public class Task
    {
        const int MaxDepth = 29;
        const int MaxK = 1000;
        const int Mod = 7340033;
        readonly int[,] Dp = new int[MaxDepth + 1, MaxK + 1];
        readonly int[] D = new int[MaxK * 2 + 2];

        public static void Main()
        {
            var task = new Task();
            task.Solve();
        }

        private void Solve()
        {
            Console.ReadLine();

            Dp[0, 0] = 0;
            for (var i = 1; i <= MaxDepth; i++)
            {
                Dp[i, 0] = 1;
                Dp[i, 1] = 1;
            }

            for (var d = 2; d <= MaxDepth; d++)
            {
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 <= MaxK; k2++)
                    {
                        D[k1 + k2] += Dp[d - 1, k1]*Dp[d - 1, k2];
                    }
                }
                for (var i = 0; i < D.Length; i++) D[i] %= Mod;
                for (var k1 = 0; k1 <= MaxK; k1++)
                {
                    for (var k2 = 0; k2 < MaxK - k1; k2++)
                    {
                        Dp[d, k1 + k2 + 1] += D[k1] * D[k2];
                    }
                }
                for (var i = 0; i < MaxK; i++) Dp[d, i] %= Mod;

                Array.Clear(D, 0, D.Length);
            }
            Dp[0, 0] = 1;

            string line;
            while ((line = Console.ReadLine())!=null)
            {
                var data = line.Split().Select(long.Parse).ToList();
                var n = data[0];
                var k = data[1];
                var depth = 0;
                while (n > 1 && n % 2 == 1)
                {
                    n /= 2;
                    depth++;
                }
                var count = Dp[depth, k];
                Console.WriteLine(count);
            }
        }
    }
}


#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long       LL;
typedef pair<int, int>  PII;
typedef pair<LL, LL>    PLL;
typedef vector<int>     VI;
typedef vector<LL>      VL;
typedef vector<PII>     VPII;
typedef vector<VI>      VVI;
typedef vector<VPII>    VVPII;
#define MM(a,x) memset(a,x,sizeof(a));
#define ALL(x)  (x).begin(), (x).end()
#define P(x)	 cerr<<"["#x<<" = "<<(x)<<"]"<<endl;
#define P2(x,y)	 cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<"]"<<endl;
#define P3(x,y,z)cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<", "#z" = "<<(z)<<"]"<<endl;
#define PP(x,i)	 cerr<<"["#x<<i<<" = "<<x[i]<<"]"<<endl;
#define TM(a,b)	 cerr<<"["#a" -> "#b": "<<1e3*(b-a)/CLOCKS_PER_SEC<<"ms]\n";
#define UN(v)   sort(ALL(v)), v.resize(unique(ALL(v))-v.begin())
#define mp make_pair
#define pb push_back
#define x first
#define y second
struct _ {_() {ios_base::sync_with_stdio(0);}} _;
template<class A, class B> ostream& operator<<(ostream &o, pair<A, B> t) {o << "(" << t.x << ", " << t.y << ")"; return o;}
template<class T> string tostring(T x, int len = 0, char c = '0') {stringstream ss; ss << x; string r = ss.str(); if(r.length() < len) r = string(len - r.length(), c) + r; return r;}
template<class T> void PV(T a, T b, int n = 0, int w = 0, string s = " ") {int c = 0; while(a != b) {cout << tostring(*a++, w, ' '); if(a != b && (n == 0 || ++c % n)) cout << s; else cout << "\n"; cout.flush();}}
template<class T> inline bool chmin(T &a, T b) {return a > b ? a = b, 1 : 0;}
template<class T> inline bool chmax(T &a, T b) {return a < b ? a = b, 1 : 0;}
const LL linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 7340033;
const int N = 111111;

map<int, int> ID;

int dp[31][1001];

int main() {
	for(int i = 0; i <= 30; i++) ID[(1 << i) - 1] = i - 1;

	dp[0][0] = 1;

	for(int i = 1; i <= 30; i++) {
		int *p = dp[i - 1];
		int p2[1001] = {};

		for(int x = 0; x <= 1000; x++)
			for(int y = 0; x + y <= 1000; y++)
				p2[x + y] = (p2[x + y] + (LL) p[x] * p[y]) % mod;

		dp[i][0] = 1;
		for(int k = 1; k <= 1000; k++) {
			int& r = dp[i][k];
			for(int x = 0; x <= k - 1; x++) {
				r = (r + (LL) p2[x] * p2[k - 1 - x]) % mod;
			}
		}
	}

	int q;
	cin >> q;
	while(q--) {
		int n, k;
		cin >> n >> k;
		int m = 0;
		while((n - 1) % 2 == 0) {
			n /= 2;
			m++;
		}
		if(n == 0) m--;
		cout << dp[m][k] << endl;
	}
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long       LL;
typedef pair<int, int>  PII;
typedef pair<LL, LL>    PLL;
typedef vector<int>     VI;
typedef vector<LL>      VL;
typedef vector<PII>     VPII;
typedef vector<VI>      VVI;
typedef vector<VPII>    VVPII;
#define MM(a,x) memset(a,x,sizeof(a));
#define ALL(x)  (x).begin(), (x).end()
#define P(x)	 cerr<<"["#x<<" = "<<(x)<<"]"<<endl;
#define P2(x,y)	 cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<"]"<<endl;
#define P3(x,y,z)cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<", "#z" = "<<(z)<<"]"<<endl;
#define PP(x,i)	 cerr<<"["#x<<i<<" = "<<x[i]<<"]"<<endl;
#define TM(a,b)	 cerr<<"["#a" -> "#b": "<<1e3*(b-a)/CLOCKS_PER_SEC<<"ms]\n";
#define UN(v)   sort(ALL(v)), v.resize(unique(ALL(v))-v.begin())
#define mp make_pair
#define pb push_back
#define x first
#define y second
struct _ {_() {ios_base::sync_with_stdio(0);}} _;
template<class A, class B> ostream& operator<<(ostream &o, pair<A, B> t) {o << "(" << t.x << ", " << t.y << ")"; return o;}
template<class T> string tostring(T x, int len = 0, char c = '0') {stringstream ss; ss << x; string r = ss.str(); if(r.length() < len) r = string(len - r.length(), c) + r; return r;}
template<class T> void PV(T a, T b, int n = 0, int w = 0, string s = " ") {int c = 0; while(a != b) {cout << tostring(*a++, w, ' '); if(a != b && (n == 0 || ++c % n)) cout << s; else cout << "\n"; cout.flush();}}
template<class T> inline bool chmin(T &a, T b) {return a > b ? a = b, 1 : 0;}
template<class T> inline bool chmax(T &a, T b) {return a < b ? a = b, 1 : 0;}
const LL linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 7340033;
const int N = 111111;

map<int, int> ID;

int dp[31][1001];

int main() {
	for(int i = 0; i <= 30; i++) ID[(1 << i) - 1] = i - 1;

	dp[0][0] = 1;

	for(int i = 1; i <= 30; i++) {
		int *p = dp[i - 1];
		int p2[1001] = {};

		for(int x = 0; x <= 1000; x++)
			for(int y = 0; x + y <= 1000; y++)
				p2[x + y] = (p2[x + y] + (LL) p[x] * p[y]) % mod;

		dp[i][0] = 1;
		for(int k = 1; k <= 1000; k++) {
			int& r = dp[i][k];
			for(int x = 0; x <= k - 1; x++) {
				r = (r + (LL) p2[x] * p2[k - 1 - x]) % mod;
			}
		}
	}

	int q;
	cin >> q;
	while(q--) {
		int n, k;
		cin >> n >> k;
		auto it = ID.find(n);
		if(it == ID.end()) {
			if(k == 0) cout << 1 << endl;
			else cout << 0 << endl;
		} else {
			n = it->y;
			cout << dp[n][k] << endl;
		}
	}
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <vector>
#include <ctime>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long       LL;
typedef pair<int, int>  PII;
typedef pair<LL, LL>    PLL;
typedef vector<int>     VI;
typedef vector<LL>      VL;
typedef vector<PII>     VPII;
typedef vector<VI>      VVI;
typedef vector<VPII>    VVPII;
#define MM(a,x) memset(a,x,sizeof(a));
#define ALL(x)  (x).begin(), (x).end()
#define P(x)	 cerr<<"["#x<<" = "<<(x)<<"]"<<endl;
#define P2(x,y)	 cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<"]"<<endl;
#define P3(x,y,z)cerr<<"["#x" = "<<(x)<<", "#y" = "<<(y)<<", "#z" = "<<(z)<<"]"<<endl;
#define PP(x,i)	 cerr<<"["#x<<i<<" = "<<x[i]<<"]"<<endl;
#define TM(a,b)	 cerr<<"["#a" -> "#b": "<<1e3*(b-a)/CLOCKS_PER_SEC<<"ms]\n";
#define UN(v)   sort(ALL(v)), v.resize(unique(ALL(v))-v.begin())
#define mp make_pair
#define pb push_back
#define x first
#define y second
struct _ {_() {ios_base::sync_with_stdio(0);}} _;
template<class A, class B> ostream& operator<<(ostream &o, pair<A, B> t) {o << "(" << t.x << ", " << t.y << ")"; return o;}
template<class T> string tostring(T x, int len = 0, char c = '0') {stringstream ss; ss << x; string r = ss.str(); if(r.length() < len) r = string(len - r.length(), c) + r; return r;}
template<class T> void PV(T a, T b, int n = 0, int w = 0, string s = " ") {int c = 0; while(a != b) {cout << tostring(*a++, w, ' '); if(a != b && (n == 0 || ++c % n)) cout << s; else cout << "\n"; cout.flush();}}
template<class T> inline bool chmin(T &a, T b) {return a > b ? a = b, 1 : 0;}
template<class T> inline bool chmax(T &a, T b) {return a < b ? a = b, 1 : 0;}
const LL linf = 0x3f3f3f3f3f3f3f3fLL;
const int inf = 0x3f3f3f3f;
const int mod = 7340033;
const int N = 111111;

map<int, int> ID;

int dp[31][1001];

int main() {
	for(int i = 0; i <= 30; i++) ID[(1 << i) - 1] = i - 1;

	dp[0][0] = 1;

	for(int i = 1; i <= 30; i++) {
		int *p = dp[i - 1];
		int p2[1001] = {};

		for(int x = 0; x <= 1000; x++)
			for(int y = 0; x + y <= 1000; y++)
				p2[x + y] = (p2[x + y] + (LL) p[x] * p[y]) % mod;

		dp[i][0] = 1;
		for(int k = 1; k <= 1000; k++) {
			int& r = dp[i][k];
			for(int x = 0; x <= k - 1; x++) {
				r = (r + (LL) p2[x] * p2[k - 1 - x]) % mod;
			}
		}
	}

	int q;
	cin >> q;
	while(q--) {
		int n, k;
		cin >> n >> k;
		n = ID[n];
		cout << dp[n][k] << endl;
	}
	return 0;
}


#include <cstdio>
#include <algorithm>

using namespace std;

typedef long long llint;

const int MAXN = 31, MAXM = 1024;
const llint MOD = 7340033;

void convolution(int n, const llint a[], llint ret[]) {
  llint b[MAXM];
  for (int i = 0; i < n; ++i) {
    llint t = 0;
    for (int j = 0; j <= i; ++j) {
      t += a[j] * a[i - j];
    }
    b[i] = t % MOD;
  }
  copy(b, b + n, ret);
}

llint dp[MAXN][MAXM];

int main() {
  dp[0][0] = 1;
  for (int i = 1; i < MAXN; ++i) {
    convolution(MAXM, dp[i - 1], dp[i]);
    convolution(MAXM, dp[i], dp[i]);
    copy(dp[i], dp[i] + MAXM - 1, dp[i] + 1);
    dp[i][0] = 1;
  }

  int re, n, k;

  scanf("%d", &re);
  for (int ri = 1; ri <= re; ++ri) {
    scanf("%d%d", &n, &k);
    printf("%d\n", (int)dp[min(__builtin_ctz(~n), __builtin_popcount(n) - 1)][k]);
  }

  return 0;
}


#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
using namespace std;

const int INF=0x3f3f3f3f;
typedef long long ll;
const int M=1001;
const int mod=7340033;
const double eps=1e-6;
const double Pi=2*acos(0.0);

inline int max(int a,int b){return a>b?a:b;}
inline int min(int a,int b){return a<b?a:b;}
inline int bit(int x){return 1<<x;}
inline double dabs(double x){return x>0?x:(-x);}
inline int abs(int x){return x>0?x:(-x);}
inline int lowbit(int x){return x&(-x);}

int n,k,t;
ll dp[30][M];
ll tmp[5][M];

void init(){
    dp[0][0]=1;
    for(int i=1;i<30;i++){
        memset(tmp,0,sizeof(tmp));
        tmp[0][0]=1;
        for(int j=1;j<=4;j++)
        for(int k=0;k<=1000;k++)
            for(int x=0;x<=k;x++){
            tmp[j][k]+=tmp[j-1][k-x]*dp[i-1][x]%mod;
            tmp[j][k]%=mod;
            if(j==4&&k) dp[i][k]=tmp[4][k-1];
        }
        dp[i][0]=1;
    }
}
int main(){
    ios::sync_with_stdio(0);
    init();
    cin>>t;
    while(t--){
        cin>>n>>k;
        int cnt=0;
        while(n&1&&n>1){
            cnt++;
            n/=2;
        }
        cout<<dp[cnt][k]<<endl;
    }
    return 0;
}


#pragma comment(linker,"/STACK:100000000,100000000")

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <iomanip>
#include <queue>
#include <map>
#include <functional>
#include <memory.h>
#include <list>
#include <sstream>
#include <ctime>
#include <climits>
#include <bitset>
#include <list>

using namespace std;

/* Constants begin */
const long long inf = 1e18+7;
const long long mod = 7340033;
const double eps = 1e-9;
const double PI = 2*acos(0.0);
const double E = 2.71828;
/* Constants end */

/* Defines begin */
#define pb push_back
#define mp make_pair
#define ll long long
#define double long double
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define forn(i,n) for (ll (i)=0;(i)<(ll)(n);(i)++)
/* Defines end */

ll f[35][2205];
ll g[2205];

int main(void) {
    #ifndef ONLINE_JUDGE
        freopen("input.txt","rt",stdin);
        freopen("output.txt","wt",stdout);
    #endif
    forn(i,35) f[i][0] = 1;
    forn(i,32){
     memset(g,0,sizeof g);
     forn(j,1001)
      forn(k,1001-j)
       g[j+k] += f[i][j]*f[i][k];
     forn(j,1001) g[i] %= mod;
     forn(j,1001)
      forn(k,1001-j)
       f[i+1][j+k+1] += g[j]*g[k];
     forn(j,1001) f[i+1][j] %= mod;
    }
    ll T;
     cin >> T;
    forn(p,T){
     ll n, k;
      cin >> n >> k;
     ll deep = 0;
     while(n > 1 && n & 1)
      n >>= 1LL, deep++;
     cout << f[deep][k] << endl;
    }
    return 0;
}


#pragma comment(linker,"/STACK:100000000,100000000")

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <iomanip>
#include <queue>
#include <map>
#include <functional>
#include <memory.h>
#include <list>
#include <sstream>
#include <ctime>
#include <climits>
#include <bitset>
#include <list>

using namespace std;

/* Constants begin */
const long long inf = 1e18+7;
const long long mod = 7340033;
const double eps = 1e-9;
const double PI = 2*acos(0.0);
const double E = 2.71828;
/* Constants end */

/* Defines begin */
#define pb push_back
#define mp make_pair
#define ll long long
#define double long double
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define forn(i,n) for (ll (i)=0;(i)<(ll)(n);(i)++)
/* Defines end */

ll f[35][2205];
ll g[2205];

int main(void) {
    #ifndef ONLINE_JUDGE
        freopen("input.txt","rt",stdin);
        freopen("output.txt","wt",stdout);
    #endif
    forn(i,35) f[i][0] = 1;
    forn(i,32){
     memset(g,0,sizeof g);
     forn(j,1001)
      forn(k,1001-j)
       g[j+k] += f[i][j]*f[i][k];
     forn(j,1001) g[j] %= mod;
     forn(j,1001)
      forn(k,1001-j)
       f[i+1][j+k+1] += g[j]*g[k];
     forn(j,1001) f[i+1][j] %= mod;
    }
    ll T;
     cin >> T;
    forn(p,T){
     ll n, k;
      cin >> n >> k;
     ll deep = 0;
     while(n > 1 && n & 1)
      n >>= 1LL, deep++;
     cout << f[deep][k] << endl;
    }
    return 0;
}


#pragma comment(linker,"/STACK:100000000,100000000")

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <iomanip>
#include <queue>
#include <map>
#include <functional>
#include <memory.h>
#include <list>
#include <sstream>
#include <ctime>
#include <climits>
#include <bitset>
#include <list>

using namespace std;

/* Constants begin */
const long long inf = 1e18+7;
const long long mod = 7340033;
const double eps = 1e-9;
const double PI = 2*acos(0.0);
const double E = 2.71828;
/* Constants end */

/* Defines begin */
#define pb push_back
#define mp make_pair
#define ll long long
#define double long double
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define forn(i,n) for (ll (i)=0;(i)<(ll)(n);(i)++)
/* Defines end */

ll f[35][2205];
ll g[2205];

int main(void) {
    #ifndef ONLINE_JUDGE
        freopen("input.txt","rt",stdin);
        freopen("output.txt","wt",stdout);
    #endif
    forn(i,35) f[i][0] = 1;
    forn(i,32){
     memset(g,0,sizeof g);
     forn(j,1005)
      forn(k,1005){
       g[j+k] += f[i][j]*f[i][k];
      }
     forn(j,2010)
      g[i+j] %= mod;
     forn(j,1005)
      forn(k,1005){
       f[i+1][j+k+1] += (g[j]*g[k])%mod;
       if(f[i+1][j+k+1] >= mod)
        f[i+1][j+k+1] -= mod;

      }
    }
    ll T;
     cin >> T;
    forn(p,T){
     ll n, k;
      cin >> n >> k;
     ll deep = 0;
     while(n > 1 && n & 1)
      n >>= 1LL, deep++;
     cout << f[deep][k] << endl;
    }
    return 0;
}


#pragma comment(linker,"/STACK:100000000,100000000")

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <string>
#include <cstring>
#include <vector>
#include <stack>
#include <cmath>
#include <map>
#include <stack>
#include <set>
#include <iomanip>
#include <queue>
#include <map>
#include <functional>
#include <memory.h>
#include <list>
#include <sstream>
#include <ctime>
#include <climits>
#include <bitset>
#include <list>

using namespace std;

/* Constants begin */
const long long inf = 1e18+7;
const long long mod = 7340033;
const double eps = 1e-9;
const double PI = 2*acos(0.0);
const double E = 2.71828;
/* Constants end */

/* Defines begin */
#define pb push_back
#define mp make_pair
#define ll long long
#define double long double
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define forn(i,n) for (ll (i)=0;(i)<(ll)(n);(i)++)
/* Defines end */

ll f[35][2205];
ll g[2205];

int main(void) {
    #ifndef ONLINE_JUDGE
        freopen("input.txt","rt",stdin);
        freopen("output.txt","wt",stdout);
    #endif
    forn(i,35) f[i][0] = 1;
    forn(i,32){
     memset(g,0,sizeof g);
     forn(j,1005)
      forn(k,1005){
       g[j+k] += (f[i][j]*f[i][k])%mod;
       if(g[j+k] >= mod) g[j+k] -= mod;
      }
     forn(j,1005)
      forn(k,1005){
       f[i+1][j+k+1] += (g[j]*g[k])%mod;
       if(f[i+1][j+k+1] >= mod)
        f[i+1][j+k+1] -= mod;

      }
    }
    ll T;
     cin >> T;
    forn(p,T){
     ll n, k;
      cin >> n >> k;
     ll deep = 0;
     while(n > 1 && n & 1)
      n >>= 1LL, deep++;
     cout << f[deep][k] << endl;
    }
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define int long long
const int maxN = 1000 + 5;
const int mod = 7340033;
int dp[34][maxN];
int tmp[4][maxN];
main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    for(int i = 0; i < 31; i ++)
	  dp[i][0] = 1;
    for(int i = 1; i < 31; i ++)
    {
	  memset(tmp, 0, sizeof tmp);
	  for(int j = 0; j < maxN; j ++) tmp[0][j] = dp[i - 1][j];

	  for(int j = 0; j < 3; j ++)
		for(int k = 0; k < maxN; k ++)
		    for(int t = 0; t < maxN; t ++)
			  if(k + t < maxN)
				tmp[j + 1][k + t] += tmp[j][k] * dp[i - 1][t], tmp[j + 1][k + t] %= mod;
	  for(int j = 0; j < maxN - 1; j ++)
		dp[i][j + 1] = tmp[3][j];
    }
    int q; cin >> q;
    while(q --)
    {
	  int n , k; cin >> n >> k;
	  int cnt = 0;
	  while(n & 1) cnt ++, n >>= 1;
	  if(!n) cnt --;
	  cout << dp[cnt][k] << endl;
    }
    return 0;

}


#include <bits/stdc++.h>

using namespace std;
#define int long long
const int maxN = 1000 + 5;
const int mod = 7340033;
int dp[34][maxN];
int tmp[4][maxN];
main()
{
    ios::sync_with_stdio(0); cin.tie(0);
    for(int i = 0; i < 31; i ++)
	  dp[i][0] = 1;
    for(int i = 1; i < 31; i ++)
    {
	  memset(tmp, 0, sizeof tmp);
	  for(int j = 0; j < maxN; j ++) tmp[0][j] = dp[i - 1][j];

	  for(int j = 0; j < 3; j ++)
		for(int k = 0; k < maxN; k ++)
		    for(int t = 0; t < maxN; t ++)
			  if(k + t < maxN)
				tmp[j + 1][k + t] += tmp[j][k] * dp[i - 1][t], tmp[j + 1][k + t] %= mod;
	  for(int j = 0; j < maxN; j ++)
		dp[i][j + 1] = tmp[3][j];
    }
    int q; cin >> q;
    while(q --)
    {
	  int n , k; cin >> n >> k;
	  int cnt = 0;
	  while(n & 1) cnt ++, n >>= 1;
	  if(!n) cnt --;
	  cout << dp[cnt][k] << endl;
    }
    return 0;

}


#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <iostream>
#include <sstream>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <bitset>
#include <complex>

using namespace std;

typedef unsigned uint;
typedef long long Int;

const int INF = 1001001001;
const Int INFLL = 1001001001001001001LL;

template<typename T> void pv(T a, T b) { for (T i = a; i != b; ++i) cout << *i << " "; cout << endl; }
template<typename T> void chmin(T& a, T b) { if (a > b) a = b; }
template<typename T> void chmax(T& a, T b) { if (a < b) a = b; }

const Int MOD = 7340033;
int dp[35][1024];

int main()
{
    dp[0][0] = 1;
    for (int i = 1; i < 35; ++i) {
        Int mul[5][1024] = {{}};
        for (int k = 0; k < 1024; ++k) {
            mul[0][0] = 1;
        }
        for (int x = 0; x < 4; ++x) {
            for (int k = 1023; k >= 0; --k) {
                for (int kk = 0; k + kk < 1024; ++kk) {
                    mul[x + 1][k + kk] += (mul[x][k] % MOD) * (dp[i - 1][kk] % MOD) % MOD;
                    if (mul[x + 1][k + kk] >= MOD) {
                        mul[x + 1][k + kk] -= MOD;
                    }
                }
            }
        }
        dp[i][0] = 1;
        for (int k = 1; k < 1024; ++k) {
            dp[i][k] = mul[4][k - 1];
        }
    }

    int Q;
    scanf("%d", &Q);

    for (int i = 0; i < Q; ++i) {
        int n, k;
        scanf("%d%d", &n, &k);

        int cnt = 0;
        while (true) {
            if (n % 2 == 0 || n <= 1) {
                break;
            }
            n >>= 1;
            ++cnt;
        }

        printf("%d\n", dp[cnt][k]);
    }

    return 0;
}


#include <iostream>
#include <algorithm>
using namespace std;

typedef long long ll;
const ll kMod = 7340033;
const int kMaxH = 32;
const int kMaxS = 1005;

int Z, N, K;
ll f[kMaxH + 1][kMaxS + 1], g[kMaxS + 1];

void prep();
void solve();

int main() {
  prep();
  cin >> Z;
  for (int zi = 1; zi <= Z; ++zi) {
    cin >> N >> K;
    solve();
  }

  return 0;
}

void prep() {
  for (int i = 0; i <= kMaxH; ++i)
    f[i][0] = 1;

  for (int i = 0; i < kMaxH; ++i) {
    for (int j = 0; j <= kMaxS; ++j)
      g[j] = 0;

    for (int j = 0; j < kMaxS; ++j) {
      for (int k = 0; j + k < kMaxS; ++k)
        g[j + k] += f[i][j] * f[i][k];
      g[j] %= kMod;
    }

    for (int j = 0; j < kMaxS; ++j)
      for (int k = 0; j + k < kMaxS; ++k)
        f[i + 1][j + k + 1] += g[j] * g[k];

    for (int j = 0; j <= kMaxS; ++j)
      f[i + 1][j] %= kMod;
  }
}

void solve() {
  int h = 0, n = N;

  while (n > 2 && n % 2 == 1)
    n /= 2, ++h;

  cout << f[h][K] << "\n";
}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <stdio.h>
#include <ctime>
#include <cstdlib>
#include <utility>
#include <string.h>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>

#define inf (999999999)
#define pii pair<int,int>
#define pip pair<int,pii>
#define pll pair<long long,long long>
#define eps 1e-8

#ifdef ONLINE_JUDGE
#define debug(args...)
#else
#define debug(args...) fprintf(stderr,args)
#endif

#define pb push_back
#define mod 7340033
#define maxn 100100

using namespace std;

const int r = 3;

long long exp(long long a,int b){
	if(b == 0) return 1;
	if(b == 1) return a;
	long long k = exp(a,b/2);
	k = (k*k) % mod;
	if(b%2) k = (k*a)%mod;
	return k;
}

long long pot[10100];
long long pot2[10100];

vector<int> dft(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft(pa,n/2,2*skip);
	vector<int> vb = dft(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> dft_inverse(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft_inverse(pa,n/2,2*skip);
	vector<int> vb = dft_inverse(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot2[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> square(vector<int> poly,int t){

	while(poly.size() > t) poly.pop_back();

	int n = 2*poly.size();
	while(n != (n&-n))n++;
	while(poly.size() < n)poly.pb(0);

	int inv = exp(n,mod-2);

	int s = exp(r,(mod-1)/n);
	int invs = exp(s,mod-2);

	pot[0] = 1;
	for(int i=1;i<=n;i++)
		pot[i] = (pot[i-1] * s) % mod;

	pot2[0] = 1;
	for(int i=1;i<=n;i++)
		pot2[i] = (pot2[i-1] * invs) % mod;

	vector<int> a = dft(poly,n,1);

	for(int i=0;i<n;i++)
		a[i] = ((long long)a[i]*a[i]) % mod;

	vector<int> b = dft_inverse(a,n,1);

	for(int i=0;i<n;i++)
		b[i] = ((long long)b[i] * inv) % mod;

	return b;

}

vector<int> fix(vector<int> poly){

	vector<int> ret;
	ret.pb(1);
	for(int i=0;i<min(1000,(int)poly.size());i++)
		ret.pb(poly[i]);
	return ret;

}

vector<int> ans[33];

main(){

	/*
		vector<int> d;
		for(int i=1;i<mod-1;i++)
			if((mod-1)%i == 0){printf("+%d ",i);d.pb(i);}

		for(int i=1;i<mod;i++){

			int ok = 1;
			for(int j=0;j<d.size() && ok;j++)
				if(exp(i,d[j]) == 1)
					ok = 0;

			if(ok)
				printf("%d\n",i);

		}										*/

		vector<int> v;
		v.pb(1);
		ans[0] = v;

		for(int i=1;i<33;i++){
			ans[i] = fix(square(square(ans[i-1],250),500));
		}

		int q;
		scanf("%d",&q);

		while(q--){

			int n,k;
			scanf("%d%d",&n,&k);
			int u = 0;
			while((n&1) && n>=3) u++, n >>= 1;
			debug("u = %d\n",u);
			if(ans[u].size() <= k)
				printf("0\n");
			else
				printf("%d\n",ans[u][k]);

		}

}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <stdio.h>
#include <ctime>
#include <cstdlib>
#include <utility>
#include <string.h>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>

#define inf (999999999)
#define pii pair<int,int>
#define pip pair<int,pii>
#define pll pair<long long,long long>
#define eps 1e-8

#ifdef ONLINE_JUDGE
#define debug(args...)
#else
#define debug(args...) fprintf(stderr,args)
#endif

#define pb push_back
#define mod 7340033
#define maxn 100100

using namespace std;

const int r = 3;

long long exp(long long a,int b){
	if(b == 0) return 1;
	if(b == 1) return a;
	long long k = exp(a,b/2);
	k = (k*k) % mod;
	if(b%2) k = (k*a)%mod;
	return k;
}

long long pot[10100];
long long pot2[10100];

vector<int> dft(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft(pa,n/2,2*skip);
	vector<int> vb = dft(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> dft_inverse(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft_inverse(pa,n/2,2*skip);
	vector<int> vb = dft_inverse(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot2[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> square(vector<int> poly,int t){

	//while(poly.size() > t) poly.pop_back();

	int n = 2*poly.size();
	while(n != (n&-n))n++;
	while(poly.size() < n)poly.pb(0);

	int inv = exp(n,mod-2);

	int s = exp(r,(mod-1)/n);
	int invs = exp(s,mod-2);

	pot[0] = 1;
	for(int i=1;i<=n;i++)
		pot[i] = (pot[i-1] * s) % mod;

	pot2[0] = 1;
	for(int i=1;i<=n;i++)
		pot2[i] = (pot2[i-1] * invs) % mod;

	vector<int> a = dft(poly,n,1);

	for(int i=0;i<n;i++)
		a[i] = ((long long)a[i]*a[i]) % mod;

	vector<int> b = dft_inverse(a,n,1);

	for(int i=0;i<n;i++)
		b[i] = ((long long)b[i] * inv) % mod;

	return b;

}

vector<int> fix(vector<int> poly){

	vector<int> ret;
	ret.pb(1);
	for(int i=0;i<min(1000,(int)poly.size());i++)
		ret.pb(poly[i]);
	return ret;

}

vector<int> ans[33];

main(){

	/*
		vector<int> d;
		for(int i=1;i<mod-1;i++)
			if((mod-1)%i == 0){printf("+%d ",i);d.pb(i);}

		for(int i=1;i<mod;i++){

			int ok = 1;
			for(int j=0;j<d.size() && ok;j++)
				if(exp(i,d[j]) == 1)
					ok = 0;

			if(ok)
				printf("%d\n",i);

		}										*/

		vector<int> v;
		v.pb(1);
		ans[0] = v;

		for(int i=1;i<33;i++){
			ans[i] = fix(square(square(ans[i-1],251),501));
		}

		int q;
		scanf("%d",&q);

		while(q--){

			int n,k;
			scanf("%d%d",&n,&k);
			int u = 0;
			while((n&1) && n>=3) u++, n >>= 1;
			debug("u = %d\n",u);
			if(ans[u].size() <= k)
				printf("0\n");
			else
				printf("%d\n",ans[u][k]);

		}

}


#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <assert.h>
#include <stdio.h>
#include <ctime>
#include <cstdlib>
#include <utility>
#include <string.h>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>

#define inf (999999999)
#define pii pair<int,int>
#define pip pair<int,pii>
#define pll pair<long long,long long>
#define eps 1e-8

#ifdef ONLINE_JUDGE
#define debug(args...)
#else
#define debug(args...) fprintf(stderr,args)
#endif

#define pb push_back
#define mod 7340033
#define maxn 100100

using namespace std;

const int r = 3;

long long exp(long long a,int b){
	if(b == 0) return 1;
	if(b == 1) return a;
	long long k = exp(a,b/2);
	k = (k*k) % mod;
	if(b%2) k = (k*a)%mod;
	return k;
}

long long pot[10100];
long long pot2[10100];

vector<int> dft(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft(pa,n/2,2*skip);
	vector<int> vb = dft(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> dft_inverse(vector<int> poly,int n,int skip) {

	if(n == 1) return poly;

	vector<int> pa;
	vector<int> pb;

	for(int i=0;i<n;i+=2)
		pa.pb(poly[i]),
		pb.pb(poly[i+1]);

	vector<int> va = dft_inverse(pa,n/2,2*skip);
	vector<int> vb = dft_inverse(pb,n/2,2*skip);

	vector<int> ret;

	for(int i=0;i<n;i++)

		ret.pb((va[i%(n/2)] + (pot2[i*skip] * vb[i%(n/2)])%mod)%mod);

	return ret;

}

vector<int> square(vector<int> poly){

	int n = 2*poly.size();
	while(n != (n&-n))n++;
	while(poly.size() < n)poly.pb(0);

	int inv = exp(n,mod-2);

	int s = exp(r,(mod-1)/n);
	int invs = exp(s,mod-2);

	pot[0] = 1;
	for(int i=1;i<=n;i++)
		pot[i] = (pot[i-1] * s) % mod;

	pot2[0] = 1;
	for(int i=1;i<=n;i++)
		pot2[i] = (pot2[i-1] * invs) % mod;

	vector<int> a = dft(poly,n,1);

	for(int i=0;i<n;i++)
		a[i] = ((long long)a[i]*a[i]) % mod;

	vector<int> b = dft_inverse(a,n,1);

	for(int i=0;i<n;i++)
		b[i] = ((long long)b[i] * inv) % mod;

	return b;

}

vector<int> fix(vector<int> poly){

	vector<int> ret;
	ret.pb(1);
	for(int i=0;i<min(1000,(int)poly.size());i++)
		ret.pb(poly[i]);
	return ret;

}

vector<int> ans[33];

main(){

	/*
		vector<int> d;
		for(int i=1;i<mod-1;i++)
			if((mod-1)%i == 0){printf("+%d ",i);d.pb(i);}

		for(int i=1;i<mod;i++){

			int ok = 1;
			for(int j=0;j<d.size() && ok;j++)
				if(exp(i,d[j]) == 1)
					ok = 0;

			if(ok)
				printf("%d\n",i);

		}										*/

		vector<int> v;
		v.pb(1);
		ans[0] = v;

		for(int i=1;i<33;i++){
			ans[i] = fix(square(square(ans[i-1])));
		}

		int q;
		scanf("%d",&q);

		while(q--){

			int n,k;
			scanf("%d%d",&n,&k);
			int u = 0;
			while((n&1) && n>=3) u++, n >>= 1;
			debug("u = %d\n",u);
			if(ans[u].size() <= k)
				printf("0\n");
			else
				printf("%d\n",ans[u][k]);

		}

}


#define _CRT_SECURE_NO_WARNINGS
#define THIS

#ifdef THIS

#include <functional>
#include <iostream>
#include <climits>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>

using namespace std;

int main()
{
	int n, l;
	cin >> n >> l;
	vector <int> vct(n);
	for(int i=0; i<n; ++i)
		cin >> vct[i];
	sort(vct.begin(), vct.end());
	bool lght_end=false, lght_beg=false;
	if(vct[0] == 0)
		lght_beg = true;
	if(vct[n-1] == l)
		lght_end = true;
	int _max = INT_MIN;
	for(int i=0; i<n-1; ++i)
		_max = max(_max, vct[i+1]-vct[i]);
	double res = _max/2.0;
	if(!lght_beg)
		res = max(res, (double)vct[0]);
	if(!lght_end)
		res = max(res, (double)(n-vct[n-1]));
	cout << res;
}
#endif


#define _CRT_SECURE_NO_WARNINGS
#define THIS

#ifdef THIS

#include <functional>
#include <algorithm>
#include <iostream>
#include <climits>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>

using namespace std;

int main()
{
	int n, l;
	cin >> n >> l;
	vector <int> vct(n);
	for(int i=0; i<n; ++i)
		cin >> vct[i];
	sort(vct.begin(), vct.end());
	bool lght_end=false, lght_beg=false;
	if(vct[0] == 0)
		lght_beg = true;
	if(vct[n-1] == l)
		lght_end = true;
	int _max = INT_MIN;
	for(int i=0; i<n-1; ++i)
		_max = max(_max, vct[i+1]-vct[i]);
	double res = _max/2.0;
	if(!lght_beg)
		res = max(res, (double)vct[0]);
	if(!lght_end)
		res = max(res, (double)(n-vct[n-1]));
	cout.precision(15);
	cout << res;
}
#endif


#define _CRT_SECURE_NO_WARNINGS
#define THIS

#ifdef THIS

#include <functional>
#include <algorithm>
#include <iostream>
#include <climits>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>

using namespace std;

int main()
{
	int n, l;
	cin >> n >> l;
	vector <int> vct(n);
	for(int i=0; i<n; ++i)
		cin >> vct[i];
	sort(vct.begin(), vct.end());
	bool lght_end=false, lght_beg=false;
	if(vct[0] == 0)
		lght_beg = true;
	if(vct[n-1] == l)
		lght_end = true;
	int _max = INT_MIN;
	for(int i=0; i<n-1; ++i)
		_max = max(_max, vct[i+1]-vct[i]);
	double res = _max/2.0;
	if(!lght_beg)
		res = max(res, (double)vct[0]);
	if(!lght_end)
		res = max(res, (double)(n-vct[n-1]));
	cout << res;
}
#endif


#define _CRT_SECURE_NO_WARNINGS
#define THIS

#ifdef THIS

#include <functional>
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>

using namespace std;

int main()
{
	int n, l;
	cin >> n >> l;
	vector <int> vct(n);
	for(int i=0; i<n; ++i)
		cin >> vct[i];
	sort(vct.begin(), vct.end());
	bool lght_end=false, lght_beg=false;
	if(vct[0] == 0)
		lght_beg = true;
	if(vct[n-1] == l)
		lght_end = true;
	int _max = INT_MIN;
	for(int i=0; i<n-1; ++i)
		_max = max(_max, vct[i+1]-vct[i]);
	double res = _max/2.0;
	if(!lght_beg)
		res = max(res, (double)vct[0]);
	if(!lght_end)
		res = max(res, (double)(n-vct[n-1]));
	cout << res;
}
#endif


#define _CRT_SECURE_NO_WARNINGS
#define THIS

#ifdef THIS

#include <functional>
#include <algorithm>
#include <iostream>
#include <climits>
#include <string>
#include <vector>
#include <queue>
#include <map>
#include <set>

using namespace std;

int main()
{
	int n, l;
	cin >> n >> l;
	vector <int> vct(n);
	for(int i=0; i<n; ++i)
		cin >> vct[i];
	sort(vct.begin(), vct.end());
	bool lght_end=false, lght_beg=false;
	if(vct[0] == 0)
		lght_beg = true;
	if(vct[n-1] == l)
		lght_end = true;
	int _max = INT_MIN;
	for(int i=0; i<n-1; ++i)
		_max = max(_max, vct[i+1]-vct[i]);
	double res = _max/2.0;
	if(!lght_beg)
		res = max(res, (double)vct[0]);
	if(!lght_end)
		res = max(res, (double)(l-vct[n-1]));
	cout.precision(15);
	cout << res;
}
#endif


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    for(int i=0;i<n;++i)
    cin >> arr[i];

    sort(arr,arr+n);
    float b=-1;
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    float x = max((float)arr[0],max(b/2,(float)l-arr[n-1]));
    cout.precision(9);
    cout << fixed << x << endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    for(int i=0;i<n;++i)
    cin >> arr[i];

    sort(arr,arr+n);
    double b=-1;
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    double x = max((double)arr[0],max(b/2,(double)(l-arr[n-1])));
    /* cout.precision(10);
    cout << fixed << x << endl;  */
    printf("%.10lf",x);
return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    for(int i=0;i<n;++i)
    cin >> arr[i];

    sort(arr,arr+n);
    float b=-1;
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    float x = max((float)arr[0],max(b/2,(float)(l-arr[n-1])));
    /* cout.precision(10);
    cout << fixed << x << endl;  */
    printf("%.10f",x);
return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    for(int i=0;i<n;++i)
    cin >> arr[i];

    sort(arr,arr+n);
    double b=-1;
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    double x = max((double)arr[0],max(b/2,(double)(l-arr[n-1])));
    cout.precision(9);
    cout << fixed << x << endl;
    //printf("%.10lf",x);
return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    long long level=0;
    long long val=0;
    for(int i=0;i<n;++i)
    cin >> arr[i];
    sort(arr,arr+n);
    int inf=1e9+1;
    float a=-1,b=-1,c=-1;
    if(arr[0]!=0) a=arr[0];
    if(arr[n-1]!=l) c=l-arr[n-1];
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    float x = max(a,max(b/2,c));
    cout << x << endl;
    /* if(x!=a&&x!=c) cout << x << endl;
    else cout << b/2.0 << endl; */
return 0;
}


#include<bits/stdc++.h>
using namespace std;
#define lol long long
int arr[1001];
int main()
{
    int n,l; cin >>n>>l;
    for(int i=0;i<n;++i)
    cin >> arr[i];

    sort(arr,arr+n);
    float b=-1;
    for(int i=1;i<n;++i)
    {
        float diff=arr[i]-arr[i-1];
        if(diff>b) b=diff;
    }
    //cout << a <<" "<< b <<" "<< c << endl;
    float x = max((float)arr[0],max(b/2,(float)(l-arr[n-1])));
    cout.precision(9);
    cout << fixed << x << endl;
return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define MAX 1000

int n;
double a[MAX],l;
bool test(double dis)
{
    bool ok = false;
    if (a[0] - dis <= 0)
    {
        ok = true;
    }

    for (int i = 1; i < n && ok; ++i)
    {
        if (a[i] - dis > a[i-1] + dis)
        {
            ok = false;
        }
    }

    if (a[n-1] + dis < l)
        ok = false;

    return ok;
}

double bs(double lo, double hi)
{
    double eps = 1e-9;
    while (hi - lo > eps)
    {
        double mid = (hi + lo)/2;

        if (test(mid))
        {
            hi = mid;
        }
        else
        {
            lo = mid;
        }
    }

    if (test(lo))
        return lo;

    return hi;
}

int main(void)
{
    ios::sync_with_stdio(false);
    cin >> n >> l;

    for (int i = 0; i < n; ++i)
    {
        cin >> a[i];
    }

    sort(a, a + n);

    cout << fixed << setprecision(10) << bs(0,1000000100) << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define MAX 1010

int n;
double a[MAX],l;
int main(void)
{
    ios::sync_with_stdio(false);

    cin >> n >> l;

    for (int i = 0; i < n; ++i)
    {
        cin >> a[i];
    }

    sort(a,  a + n);

    double dis = a[0];
    double last = a[0];

    for (int i = 1; i < n; ++i)
    {
        double disLocal = a[i] - a[i-1];
        if (last < disLocal/2.0)
        {
            last = disLocal/2.0;
            dis = max(dis, last);
        }
        else
        {
            last = 0;
        }
    }

    dis = max(dis, l - (a[n-1] + last));
    cout << fixed << setprecision(10) << dis  << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define MAX 1010

int n;
double a[MAX],l;
int main(void)
{
    ios::sync_with_stdio(false);

    cin >> n >> l;

    for (int i = 0; i < n; ++i)
    {
        cin >> a[i];
    }

    sort(a,  a + n);

    double dis = a[0];

    for (int i = 1; i < n; ++i)
    {
        dis = max(dis, (a[i] - a[i-1])/2.0);
    }

    dis = max(dis, l - a[n-1]);

    cout << fixed << setprecision(10) << dis  << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define MAX 1000

int n;
double a[MAX],l;
bool test(double dis)
{
    bool ok = false;
    if (a[0] - dis <= 0)
    {
        ok = true;
    }

    for (int i = 1; i < n && ok; ++i)
    {
        if (a[i] - dis > a[i-1] + dis)
        {
            ok = false;
        }
    }

    if (a[n-1] + dis < l)
        ok = false;

    return ok;
}

double bs(double lo, double hi)
{
    double eps = 1e-10;
    while (hi - lo > eps)
    {
        double mid = (hi + lo)/2;

        if (test(mid))
        {
            hi = mid;
        }
        else
        {
            lo = mid;
        }
    }

    if (test(lo))
        return lo;

    return hi;
}

int main(void)
{
    cin >> n >> l;

    for (int i = 0; i < n; ++i)
    {
        cin >> a[i];
    }

    sort(a, a + n);

    cout << fixed << setprecision(9) << bs(0,1000000100) << "\n";
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
#define MAX 1010

int n;
double a[MAX],l;
int main(void)
{
    ios::sync_with_stdio(false);

    cin >> n >> l;

    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i];
    }

    sort(a + 1,  a + n + 1);

    a[n + 1] = l;
    a[0] = 0;
    double ans = 0;
    double last = 0;
    for (int i = 1; i <= n; ++i)
    {
        double disLocalT = max(a[i] - (a[i-1] + last),0.0);
        double disLocalF = (a[i + 1] - a[i])/2.0;
        double dis = max(disLocalF, disLocalT);
        ans = max(ans, dis);
        last = dis;
    }

    cout << fixed << setprecision(10) << ans  << "\n";
    return 0;
}


#include<iostream>

#include<cstdio>

#include<cstdlib>

#include<iomanip>

using namespace std;

void QuickSort(int l, int h, int a[])
{
    int i = l, j = h;

    int pivot = a[l + rand() % (h - l + 1)];

    while(i <= j)
    {
        while(a[i] < pivot) i++;

        while(a[j] > pivot) j--;

        if(i <= j)
        {
            int tmp;

            tmp = a[i]; a[i] = a[j]; a[j] = tmp;

            i++;

            j--;
        }
    }

    if(l < j) QuickSort(l, j, a);

    if(i < h) QuickSort(i, h, a);
}

int main()
{
    int n, l;

    //freopen("in.txt", "r", stdin);

    cin >> n >> l;

    int a[n + 1];

    for(int i = 1; i <= n; i++)
    cin >> a[i];

    QuickSort(1, n, a);

    double ans = 0;

    for(int i = 1; i < n; i++)
    {
        if(ans < a[i + 1] - a[i]) ans = a[i + 1] - a[i];
    }

    ans /= 2;

    if(a[1] != 0)
    if(ans < a[1]) ans = a[1];

    if(a[n] != l)
    if(ans < l - a[n]) ans = l - a[n];

    printf("%.9lf", ans);
}


#include<iostream>

#include<algorithm>

#include<cstdio>
using namespace std;

int main()
{
    int n, l;

    //freopen("in.txt", "r", stdin);

    cin >> n >> l;

    double a[n + 1];

    for(int i = 1; i <= n; i++) cin >> a[i];

    sort(a + 1, a + n + 1);

    double max_distance = 0;

    for(int i = 1; i < n; i++)
        max_distance = max(max_distance, (a[i + 1] - a[i]) / 2);

    if(a[1]) max_distance = max(max_distance, a[1]);

    if(a[n] != (double)l) max_distance = max(max_distance, (double) l - a[n]);

    printf("%.9lf", max_distance);
}


#include<iostream>

#include<cstdio>

#include<cstdlib>

using namespace std;

void QuickSort(int l, int h, int a[])
{
    int i = l, j = h;

    int pivot = a[l + rand() % (h - l + 1)];

    while(i <= j)
    {
        while(a[i] < pivot) i++;

        while(a[j] > pivot) j--;

        if(i <= j)
        {
            int tmp;

            tmp = a[i]; a[i] = a[j]; a[j] = tmp;

            i++;

            j--;
        }
    }

    if(l < j) QuickSort(l, j, a);

    if(i < h) QuickSort(i, h, a);
}

int main()
{
    int n, l;

    //freopen("in.txt", "r", stdin);

    cin >> n >> l;

    int a[n + 1];

    for(int i = 1; i <= n; i++)
    cin >> a[i];

    QuickSort(1, n, a);

    float ans = 0;

    for(int i = 1; i < n; i++)
    {
        if(ans < a[i + 1] - a[i])
        {
            ans = (float)(a[i + 1] - a[i]) / 2;
        }
    }

    if(a[1] != 0) ans = ans < a[1] ? a[1] : ans;

    if(a[n] != l) ans = ans < l - a[n] ? l - a[n] : ans;

    printf("%.9f", ans);
}


#include<iostream>

#include<algorithm>

#include<iomanip>
using namespace std;

int main()
{
    int n, l;

    cin >> n >> l;

    float a[n + 1];

    for(int i = 1; i <= n; i++) cin >> a[i];

    sort(a + 1, a + n + 1);

    float max_distance = 0;

    for(int i = 1; i < n; i++)
        max_distance = max(max_distance, (a[i + 1] - a[i]) / 2);

    if(a[1]) max_distance = max(max_distance, a[1]);

    if(a[n] != (float)l) max_distance = max(max_distance, (float) l - a[n - 1]);

    cout << max_distance;
}


#include<bits/stdc++.h>
#define intMAX 1123456789LL
#define MAX intMAX * intMAX
#define F first
#define S second
#define mp make_pair
#define ll long long
#define pb push_back
#define pv(v,b,a) v.insert(v.begin()+b,a)
#define all(c) c.begin(),c.end()
#define sf(a) scanf("%d",&a);
#define sl(a) scanf("%lld",&a);
#define MAXCR 1000000000
#define mem(arr,a) memset(arr, a, sizeof arr);
#define er(vec,a,b) vec.erase(vec.begin() + a, vec.begin() + b+1);
#define pii pair<int ,int>
#define mod 1000000007
using namespace std;
int main()
{
    int i,n,arr[1005]={0},l,a,k=0;
    sf(n)
    sf(l)
    for(i=0;i<n;i++)
    {
        sf(arr[i])
    }
    sort(arr,arr+n);

    double d=-1,max_=0,flag=0;
    for(i=0;i<=l;i++)
    {
        d++;
    //  cout<<d<<" ";
        if(i==arr[k])
        {
            k++;
            double g=((flag==0)?d:d/2);
            max_=max(max_,g);
            flag=1;
            d=0;
        }
        else if(i==l)
        {
            double g=d;
            max_=max(max_,g);
        }
    }
    printf("%0.10f",max_);
    return 0;
}


#include<bits/stdc++.h>
#define intMAX 1123456789LL
#define MAX intMAX * intMAX
#define F first
#define S second
#define mp make_pair
#define ll long long
#define pb push_back
#define pv(v,b,a) v.insert(v.begin()+b,a)
#define all(c) c.begin(),c.end()
#define sf(a) scanf("%d",&a);
#define sl(a) scanf("%lld",&a);
#define MAXCR 1000000000
#define mem(arr,a) memset(arr, a, sizeof arr);
#define er(vec,a,b) vec.erase(vec.begin() + a, vec.begin() + b+1);
#define pii pair<int ,int>
#define mod 1000000007
using namespace std;
int main()
{
    int i,n,l,a,k=0;
    double arr[1005];
    sf(n)
    sf(l)
    for(i=0;i<n;i++)
    {
        cin>>a;
        arr[i]=a;
    }
    sort(arr,arr+n);

    double d=-1,max_=0,flag=0;
    for(i=1;i<n;i++)
    {
    //a cout<<arr[i]<<arr[i-1]<<" ";
        max_=max(max_,(arr[i]-arr[i-1])/2);
    }
    //cout<<arr[n-1]<<" gg";
    printf("%0.10f",max(max_,max(arr[0],l-arr[n-1])));
    return 0;
}


#include<bits/stdc++.h>
#define intMAX 1123456789LL
#define MAX intMAX * intMAX
#define F first
#define S second
#define mp make_pair
#define ll long long
#define pb push_back
#define pv(v,b,a) v.insert(v.begin()+b,a)
#define all(c) c.begin(),c.end()
#define sf(a) scanf("%d",&a);
#define sl(a) scanf("%lld",&a);
#define MAXCR 1000000000
#define mem(arr,a) memset(arr, a, sizeof arr);
#define er(vec,a,b) vec.erase(vec.begin() + a, vec.begin() + b+1);
#define pii pair<int ,int>
#define mod 1000000007
using namespace std;
int main()
{
    int i,n,arr[1005]={0},l,a;
    sf(n)
    sf(l)
    for(i=0;i<n;i++)
    {
        sf(a)
        arr[a]=1;
    }
    double d=-1,max_=0,flag=0;
    for(i=0;i<=l;i++)
    {
        d++;
    //  cout<<d<<" ";
        if(arr[i])
        {
            double g=((flag==0)?d:d/2);
            max_=max(max_,g);
            flag=1;
            d=0;
        }
        else if(i==l)
        {
            double g=d;
            max_=max(max_,g);
        }
    }
    printf("%0.10f",max_);
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define N 1000000
using namespace std;
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        int zu[1005];
        for(int i=0;i<n;i++){
            scanf("%d",&zu[i]);
        }
        sort(zu,zu+n);
        double d1,d2=0,d3;
        d1=fabs(zu[0]);
        d3=(fabs(m*1.0-zu[n-1]))/2.0;
        for(int i=0;i<n-1;i++){
            if(fabs((zu[i]-zu[i+1])/2.0)-d2>10e-10){
                d2=fabs((zu[i]-zu[i+1])/2.0);
            }
        }
        double ans1=max(d1,d3);
        double ans=max(ans1,d2);
        printf("%.10lf\n",ans);
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define N 1000000
using namespace std;
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        int zu[1005];
        for(int i=0;i<n;i++){
            scanf("%d",&zu[i]);
        }
        sort(zu,zu+n);
        double d1,d2=0,d3;
        d1=fabs(zu[0]);
        d3=(fabs(m*1.0-zu[n-1]))/2.0;
        for(int i=0;i<n-1;i++){
            if(fabs((zu[i]-zu[i+1])/2.0)-d2>10e-9){
                d2=fabs((zu[i]-zu[i+1])/2.0);
            }
        }
        double ans1=max(d1,d3);
        double ans=max(ans1,d2);
        printf("%.10lf\n",ans);
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#define N 1000000
using namespace std;
int main()
{
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        int zu[1005];
        for(int i=0;i<n;i++){
            scanf("%d",&zu[i]);
        }
        sort(zu,zu+n);
        double d1,d2=0,d3;
        d1=fabs(zu[0]);
        d3=(fabs(m*1.0-zu[n-1]));
        for(int i=0;i<n-1;i++){
            if(fabs((zu[i]-zu[i+1])/2.0)-d2>10e-10){
                d2=fabs((zu[i]-zu[i+1])/2.0);
            }
        }
        double ans1=max(d1,d3);
        double ans=max(ans1,d2);
        printf("%.10lf\n",ans);
    }
    return 0;
}


#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
#define all(c) c.begin(),c.end();
#define loop(k,n) for(int i=k;i<n;i++)
#define pb(x) push_back(x);
typedef long long int ll;
typedef vector<double> VEC;
typedef vector< pair<int,int> > PI;
int main()
{
    double n,l,a;
    VEC v;
    cin>>n>>l;
    for(int i=0;i<n;i++){
            cin>>a;
            v.push_back(a);
    }
    //v.push_back(l);
    sort(v.begin(),v.end());
    double red=0;
    red=v[0];
    double x=0;
    for(int i=1;i<n;i++)
    {
        x=((double)(v[i]-v[i-1])/2);
        if(x>red)
            red=x;
    }
    if(v[n-1]+red<l)
    {
        red+=(l-v[n-1]-red);
    }
    printf("%.10lf\n",red);
    return 0;
}


#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
#define all(c) c.begin(),c.end();
#define loop(k,n) for(int i=k;i<n;i++)
#define pb(x) push_back(x);
typedef long long int ll;
typedef vector<ll> VEC;
typedef vector< pair<int,int> > PI;
int main()
{
    ll n,l,a;
    VEC v;
    cin>>n>>l;
    for(int i=0;i<n;i++){
            cin>>a;
            v.push_back(a);
    }
    v.push_back(l);
    sort(v.begin(),v.end());
    double red=0;
    red=v[0];
    double x=0;
    for(int i=1;i<n+1;i++)
    {
        x=((double)(v[i]-v[i-1])/2);
        if(x>red)
            red=x;
    }
    cout<<(double)red<<"\n";
    return 0;
}


#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
#define all(c) c.begin(),c.end();
#define loop(k,n) for(int i=k;i<n;i++)
#define pb(x) push_back(x);
typedef long long int ll;
typedef vector<ll> VEC;
typedef vector< pair<int,int> > PI;
int main()
{
    ll n,l,a;
    VEC v;
    cin>>n>>l;
    for(int i=0;i<n;i++){
            cin>>a;
            v.push_back(a);
    }
    v.push_back(l);
    sort(v.begin(),v.end());
    double red=0;
    red=v[0];
    double x=0;
    for(int i=1;i<n+1;i++)
    {
        x=((double)(v[i]-v[i-1])/2);
        if(x>red)
            red=x;
    }
    printf("%.10lf\n",red);
    return 0;
}


#include<iostream>
#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<map>
using namespace std;
#define all(c) c.begin(),c.end();
#define loop(k,n) for(int i=k;i<n;i++)
#define pb(x) push_back(x);
typedef long long int ll;
typedef vector<ll> VEC;
typedef vector< pair<int,int> > PI;
int main()
{
    ll n,l,a;
    VEC v;
    cin>>n>>l;
    for(int i=0;i<n;i++){
            cin>>a;
            v.push_back(a);
    }
    v.push_back(l);
    sort(v.begin(),v.end());
    double red=0;
    red=v[0];
    double x=0;
    for(int i=1;i<n+1;i++)
    {
        x=((double)(v[i]-v[i-1])/2);
        if(x>red)
            red=x;
    }
    cout<<red<<"\n";
    return 0;
}


#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <queue>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <cctype>
#include <cassert>
#include <limits>
#include <functional>
using namespace std;

int main() {
    int n, l;
    cin >> n >> l;
    vector<int>a(n, 0);
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a.begin(), a.end());
    double ans = max(a[0], l - a[n - 1]);
    for (int i = 0; i < n - 1; i++) {
        double x = a[i+1] - a[i];
        x /= 2.0;
        ans = max(ans, x);
    }
    printf("%.17lf\n", ans);
}


#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <queue>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <cctype>
#include <cassert>
#include <limits>
#include <functional>
using namespace std;

int main() {
    int n, l;
    cin >> n >> l;
    vector<int>a(n, 0);
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a.begin(), a.end());
    double ans = max(a[0], l - a[n - 1]);
    for (int i = 0; i < n - 1; i++) {
        double x = a[i+1] - a[i];
        x /= 2.0;
        ans = max(ans, x);
    }
    cout << ans << endl;
}


#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <set>
#include <map>
#include <queue>
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <cctype>
#include <cassert>
#include <limits>
#include <functional>
using namespace std;

int main() {
    int n, l;
    cin >> n >> l;
    vector<int>a(n, 0);
    for (int i = 0; i < n; i++) cin >> a[i];
    sort(a.begin(), a.end());
    double ans = max(a[0], l - a[n - 1]);
    for (int i = 1; i < n - 1; i++) {
        double x = a[i] - a[i - 1];
        x /= 2.0;
        ans = max(ans, x);
    }
    cout << ans << endl;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
  int n, l;
  cin >> n >> l;
  vector <int> a;

  int tmp;
  for (int i = 0; i < n; i ++) {
    cin >> tmp;
    a.push_back(tmp);
  }

  sort(a.begin(), a.end());

  double ans = 0;
  for (int i = 1; i < a.size(); i ++) {
    double dis = (a[i] - a[i - 1]) / 2.0;
    if(dis > ans) {
      ans = dis;
    }
  }

  double tmp_dis = max(a[0], l - a.back());
  if(tmp_dis > ans) {
    ans = tmp_dis;
  }

  cout << ans << std::endl;

  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
  int n, l;
  cin >> n >> l;
  vector <int> a;

  int tmp;
  for (int i = 0; i < n; i ++) {
    cin >> tmp;
    a.push_back(tmp);
  }
  a.push_back(l);

  sort(a.begin(), a.end());

  double ans = 0;
  for (int i = 1; i < a.size(); i ++) {
    double dis = (a[i] - a[i - 1]) / 2.0;
    if(dis > ans) {
      ans = dis;
    }
  }

  cout << ans << std::endl;

  return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
  int n, l;
  cin >> n >> l;
  vector <int> a;

  int tmp;
  for (int i = 0; i < n; i ++) {
    cin >> tmp;
    a.push_back(tmp);
  }

  sort(a.begin(), a.end());

  double ans = 0;
  for (int i = 1; i < a.size(); i ++) {
    double dis = (a[i] - a[i - 1]) / 2.0;
    if(dis > ans) {
      ans = dis;
    }
  }

  double tmp_dis = max(a[0], l - a.back());
  if(tmp_dis > ans) {
    ans = tmp_dis;
  }

  printf("%.9f\n", ans);
  return 0;
}


#include<stdio.h>
void sort(int*, int);
void swap(int*,int*);
int main(void){
  int n, l, arr[100000], cnt;
  double diff=-1;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%d", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(1.0*diff)/2;
  printf("%f", diff);
  return(0);
}

void swap(int* a,int* b){
  int temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(int* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(int*, int);
void swap(int*,int*);
int main(void){
  int n, l, arr[100000], cnt;
  double diff;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%d", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(1.0*diff)/2;
  if(diff<arr[0])
  printf("%f", (double)arr[0]);
  else if(diff<l-arr[n-1])
  printf("%f", (double)l-arr[n-1]);
  else{
  printf("%f", diff);
  }
  return(0);
}

void swap(int* a,int* b){
  int temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(int* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(double*, int);
void swap(double*,double*);
int main(void){
  int n, l;
  double arr[100000];
  int cnt;
  double diff=-1;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%lf", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(1.0*diff)/2;
  if(diff<arr[0] || diff<l-arr[n-1]){
    if(arr[0]<l-arr[n-1])
    printf("%f", l-arr[n-1]);
    else printf("%f", arr[0]);
  }
  else{
  printf("%f", diff);
  }
  return(0);
}

void swap(double* a,double* b){
  double temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(double* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(double*, int);
void swap(double*,double*);
int main(void){
  int n, l;
  double arr[100000];
  int cnt;
  double diff;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%lf", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(1.0*diff)/2;
  if(diff<arr[0])
  printf("%f", arr[0]);
  else if(diff<l-arr[n-1])
  printf("%f", l-arr[n-1]);
  else{
  printf("%f", diff);
  }
  return(0);
}

void swap(double* a,double* b){
  double temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(double* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(int*, int);
void swap(int*,int*);
int main(void){
  int n, l, arr[100000], cnt;
  double diff;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%d", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  if(diff<arr[0])
  printf("%f", arr[0]);
  else if(diff<l-arr[n-1])
  printf("%f", l-arr[n-1]);
  else{
  diff=(1.0*diff)/2;
  printf("%f", diff);
  }
  return(0);
}

void swap(int* a,int* b){
  int temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(int* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(double*, int);
void swap(double*,double*);
int main(void){
  int n, l;
  double arr[100000];
  int cnt;
  double diff = 0;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%lf", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(diff)/2;
  if(diff<arr[0])
  printf("%f", arr[0]);
  else if(diff<l-arr[n-1])
  printf("%f", l-arr[n-1]);
  else{
  printf("%f", diff);
  }
  return(0);
}

void swap(double* a,double* b){
  double temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(double* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>
void sort(double*, int);
void swap(double*,double*);
int main(void){
  int n, l;
  double arr[100000];
  int cnt;
  double diff;
  scanf("%d%d", &n, &l);
  for(cnt=0;cnt<n;cnt++)
  scanf("%lf", arr+cnt);
  sort(arr, n);
  for(cnt=0;cnt<n-1;cnt++){
    if(arr[cnt+1]-arr[cnt]>diff){
      diff=arr[cnt+1]-arr[cnt];
    }
  }
  diff=(1.0*diff)/2;
  if(diff<arr[0] || diff<l-arr[n-1]){
    if(arr[0]<l-arr[n-1])
    printf("%f", l-arr[n-1]);
    else printf("%f", arr[0]);
  }
  else{
  printf("%f", diff);
  }
  return(0);
}

void swap(double* a,double* b){
  double temp=(*a);
  (*a)=(*b);
  (*b)=temp;
}

void sort(double* arr,int n){
  int cnt, cnt2, d;
  for(cnt=0;cnt<n-1;cnt++){
    d=cnt;
    for(cnt2=cnt+1;cnt2<n;cnt2++){
      if(arr[d]>arr[cnt2])
      d=cnt2;
    }
    if(d!=cnt)
    swap(arr+d,arr+cnt);
  }
}


#include<stdio.h>

int a[100000],b[100000];

void merge(int p,int m,int q,int n)
{
    int i,j,k;
    if(n-p==0)
        return;
    i=p;j=q;
    for(k=0;k<=n-p&&j<=n&&i<=m;k++)
    {
        if(a[i]>a[j])
        {
            b[k]=a[j];
            j++;
        }
        else
        {
            b[k]=a[i];
            i++;
        }
    }
    if(i>m)
        while(j<=n)
            b[k++]=a[j++];
    else
        while(i<=m)
            b[k++]=a[i++];
    i=p;
    for(k=0;k<=n-p;k++)
    {
        a[i++]=b[k];
    }
    return;
}

void mergesort(int l,int r)
{
    int mid;
    if(l<r)
    {
        mid=l+(r-l)/2; //important: careful
        mergesort(l,mid);
        mergesort(mid+1,r);
        merge(l,mid,mid+1,r);
    }
    return;
}

int main()
{
    double max,d;
    int n,l,i;
    scanf("%d%d",&n,&l);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    mergesort(0,n-1);
    max=d=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(i==(n-1)&&n!=2)
            d=l-a[i];
        else
        {
            d=(a[i]-a[i-1])/(double)2;
        printf("%.10lf\n",d);
        }
        if(d>max)
            max=d;
    }
    printf("%.10lf\n",max);
    return 0;
}


#include<stdio.h>

int a[100000],b[100000];

void merge(int p,int m,int q,int n)
{
    int i,j,k;
    if(n-p==0)
        return;
    i=p;j=q;
    for(k=0;k<=n-p&&j<=n&&i<=m;k++)
    {
        if(a[i]>a[j])
        {
            b[k]=a[j];
            j++;
        }
        else
        {
            b[k]=a[i];
            i++;
        }
    }
    if(i>m)
        while(j<=n)
            b[k++]=a[j++];
    else
        while(i<=m)
            b[k++]=a[i++];
    i=p;
    for(k=0;k<=n-p;k++)
    {
        a[i++]=b[k];
    }
    return;
}

void mergesort(int l,int r)
{
    int mid;
    if(l<r)
    {
        mid=l+(r-l)/2; //important: careful
        mergesort(l,mid);
        mergesort(mid+1,r);
        merge(l,mid,mid+1,r);
    }
    return;
}

int main()
{
    double max,d;
    int n,l,i;
    scanf("%d%d",&n,&l);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    mergesort(0,n-1);
    max=d=a[0]-0;
    for(i=1;i<n;i++)
    {
        d=(a[i]-a[i-1])/(double)2;
        if(d>max)
            max=d;
    }
    if(max<(l-a[n-1]))
        max=l-a[n-1];
    printf("%.10lf\n",max);
    return 0;
}


#include<stdio.h>

int a[100000],b[100000];

void merge(int p,int m,int q,int n)
{
    int i,j,k;
    if(n-p==0)
        return;
    i=p;j=q;
    for(k=0;k<=n-p&&j<=n&&i<=m;k++)
    {
        if(a[i]>a[j])
        {
            b[k]=a[j];
            j++;
        }
        else
        {
            b[k]=a[i];
            i++;
        }
    }
    if(i>m)
        while(j<=n)
            b[k++]=a[j++];
    else
        while(i<=m)
            b[k++]=a[i++];
    i=p;
    for(k=0;k<=n-p;k++)
    {
        a[i++]=b[k];
    }
    return;
}

void mergesort(int l,int r)
{
    int mid;
    if(l<r)
    {
        mid=l+(r-l)/2; //important: careful
        mergesort(l,mid);
        mergesort(mid+1,r);
        merge(l,mid,mid+1,r);
    }
    return;
}

int main()
{
    double max,d;
    int n,l,i;
    scanf("%d%d",&n,&l);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    mergesort(0,n-1);
    max=d=(a[0]-0)*2;
    for(i=1;i<n;i++)
    {
        if(i==n-1)
            d=(l-a[i])*2;
        else
            d=a[i]-a[i-1];
        if(d>max)
            max=d;
    }
    printf("%.10lf\n",max/(double)2);
    return 0;
}


#include<stdio.h>

int a[100000],b[100000];

void merge(int p,int m,int q,int n)
{
    int i,j,k;
    if(n-p==0)
        return;
    i=p;j=q;
    for(k=0;k<=n-p&&j<=n&&i<=m;k++)
    {
        if(a[i]>a[j])
        {
            b[k]=a[j];
            j++;
        }
        else
        {
            b[k]=a[i];
            i++;
        }
    }
    if(i>m)
        while(j<=n)
            b[k++]=a[j++];
    else
        while(i<=m)
            b[k++]=a[i++];
    i=p;
    for(k=0;k<=n-p;k++)
    {
        a[i++]=b[k];
    }
    return;
}

void mergesort(int l,int r)
{
    int mid;
    if(l<r)
    {
        mid=l+(r-l)/2; //important: careful
        mergesort(l,mid);
        mergesort(mid+1,r);
        merge(l,mid,mid+1,r);
    }
    return;
}

int main()
{
    double max,d;
    int n,l,i;
    scanf("%d%d",&n,&l);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    mergesort(0,n-1);
    max=d=a[0]-0;
    for(i=1;i<n;i++)
    {
        if(i==(n-1)&&n!=2)
            d=l-a[i];
        else
        {
            d=(a[i]-a[i-1])/(double)2;
        }
        if(d>max)
            max=d;
    }
    printf("%.10lf\n",max);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
void Tri(long T[],int n)
{
    int i,j,ind,autre;
    for(i=0;i<n-1;i++)
    {
        ind=i;
        for(j=i+1;j<n;j++)
            if (T[j]<T[ind]) ind=j;
        autre=T[ind];
        T[ind]=T[i];
        T[i]=autre;
    }
}
int main()
{
    int n,i;
    long l;
    long T[1001];
    double max,x;
    scanf("%d %ld",&n,&l);
    for(i=0;i<n;i++)
        scanf("%ld",&T[i]);
    Tri(T,n);
    max=T[0];
    for(i=0;i<n-1;i++)
    {
        x=(T[i+1]-T[i])/2.0;
        if (x>max) max=x;
    }
    x=l-T[n-1];
    if (x>max) max=x;
    printf("%.010lf",max);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
void Tri(long T[],int n)
{
    int i,j,ind,autre;
    for(i=0;i<n-1;i++)
    {
        ind=i;
        for(j=i+1;j<n;j++)
            if (T[j]<T[ind]) ind=j;
        autre=T[ind];
        T[ind]=T[i];
        T[i]=autre;
    }
}
int main()
{
    int n,i;
    long l;
    long T[1001];
    double max,x;
    scanf("%d %ld",&n,&l);
    for(i=0;i<n;i++)
        scanf("%ld",&T[i]);
    Tri(T,n);
    max=T[0];
    for(i=0;i<n-1;i++)
    {
        x=(T[i+1]-T[i])/2.0;
        if (x>max) max=x;
    }
    x=l-T[n-1];
    if (x>max) max=x;
    printf("%.07lf",max);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
void Tri(long T[],int n)
{
    int i,j,ind,autre;
    for(i=0;i<n-1;i++)
    {
        ind=i;
        for(j=i+1;j<n;j++)
            if (T[j]<T[ind]) ind=j;
        autre=T[ind];
        T[ind]=T[i];
        T[i]=autre;
    }
}
int main()
{
    int n,i;
    long l;
    long T[1001];
    double max,x;
    scanf("%d %ld",&n,&l);
    for(i=0;i<n;i++)
        scanf("%ld",&T[i]);
    T[n]=l;
    Tri(T,n);
    max=T[0];
    for(i=0;i<n;i++)
    {
        x=(T[i+1]-T[i])/2.0;
        if (x>max) max=x;
    }
    printf("%lf",max);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
void Tri(long T[],int n)
{
    int i,j,ind,autre;
    for(i=0;i<n-1;i++)
    {
        ind=i;
        for(j=i+1;j<n;j++)
            if (T[j]<T[ind]) ind=j;
        autre=T[ind];
        T[ind]=T[i];
        T[i]=autre;
    }
}
int main()
{
    int n,i;
    long l;
    long T[1001];
    double max,x;
    scanf("%d %ld",&n,&l);
    for(i=0;i<n;i++)
        scanf("%ld",&T[i]);
    T[n]=l;
    Tri(T,n);
    max=T[0];
    for(i=0;i<n;i++)
    {
        x=(T[i+1]-T[i])/2.0;
        if (x>max) max=x;
    }
    printf("%.010lf",max);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
long long a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(long long int*)a-*(long long int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=1e9,x=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",l);
       else
       {
          printf("%lf",(l>l-a[0])?l:a[0]-l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    max=(max>a[n-1]?max:a[n-1]);
    for(i=1;i<n;i++)
    {
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
    }
    if(max*2>=r)
    printf("%lf",max);
    else
    printf("%lf",r/2.0);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
long long a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(long long int*)a-*(long long int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=1e9,x=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",l);
       else
       {
          printf("%lf",(l>l-a[0])?l:a[0]-l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    max=(max>a[n-1]?max:a[n-1]);
    for(i=1;i<n;i++)
    {
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
    }
    if(max*2>=r)
    printf("%lf",max);
    else
    {
       r=r/2.0;
    printf("%lf",r);
    }
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
long long a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(long long int*)a-*(long long int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=1e9,x=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",l);
       else
       {
          printf("%lf",(l>l-a[0])?l:a[0]-l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    max=(max>a[n-1]?max:a[n-1]);
    for(i=1;i<n;i++)
    {
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
    }
    if(max*2>=r)
    printf("%lf",max);
    else
    printf("%lf",(r/2.0));
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
int a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(int*)a-*(int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=0,x=0;
  double ans=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",(double)l);
       else
       {
          printf("%lf",(double)(a[0]>l-a[0])?a[0]:l-a[0]);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
   /* for(i=0;i<n;i++)
    printf("%d ",a[i]);
    puts("\n");*/
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    min=l-a[n-1];
    max=(max>min)?max:min;
    //printf("%d %d %d\n",a[0],a[n-1],max);
    for(i=1;i<n;i++)
    {
       //printf("%d %d\n",a[i-1],a[i]);
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
       //printf("%.0lf ;",r);
    }
    //r=r/2.0;
    if(max*2>=r)
    printf("%lf",(double)max);
    else
    printf("%lf",(double)r/2.0);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
int a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(int*)a-*(int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=0,x=0;
  double ans=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",(double)l);
       else
       {
          printf("%lf",(double)(l>l-a[0])?l:l-a[0]);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
   /* for(i=0;i<n;i++)
    printf("%d ",a[i]);
    puts("\n");*/
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    min=l-a[n-1];
    max=(max>min)?max:min;
    //printf("%d %d %d\n",a[0],a[n-1],max);
    for(i=1;i<n;i++)
    {
       //printf("%d %d\n",a[i-1],a[i]);
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
       //printf("%.0lf ;",r);
    }
    //r=r/2.0;
    if(max*2>=r)
    printf("%lf",(double)max);
    else
    printf("%lf",(double)r/2.0);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
int a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(int*)a-*(int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=1e9,x=0;
  double ans=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",(double)l);
       else
       {
          printf("%lf",(double)(l>l-a[0])?l:a[0]-l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
   /* for(i=0;i<n;i++)
    printf("%d ",a[i]);
    puts("\n");*/
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    max=(max>a[n-1]?max:a[n-1]);
    for(i=1;i<n;i++)
    {
       //printf("%d %d\n",a[i-1],a[i]);
       x=a[i]-a[i-1];
       if(ans<x)
       ans=x;
      // printf("%lf ",ans);
    }
    if(max*2>=ans)
    printf("%lf",(double)max);
    else
    printf("%lf",ans/2.0);
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
long long a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(long long int*)a-*(long long int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=1e9,x=0;
    double ans=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",l);
       else
       {
          printf("%lf",(l>l-a[0])?l:a[0]-l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    max=(max>a[n-1]?max:a[n-1]);
    for(i=1;i<n;i++)
    {
       x=a[i]-a[i-1];
       if(ans<x)
       ans=x;
    }
    if(max*2>=ans)
    printf("%lf",max);
    else
    {
       ans=ans/2.0;
    printf("%lf",ans);
    }
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define N 1000005
int a[N],b[N];
typedef struct{
     int x;
     int y;
}sort;
sort hotel[N];
int cmf(const void*a,const void*b)
{
    return *(int*)a-*(int*)b;
}
int bns(long long a[],int n,long long m)
{
   int r=n,l=1,mid=0;
   while(l<=r)
   {
      mid=(l+r)/2;
      if(a[mid]>m)
      r=mid-1;
      else if(a[mid]<m)
      l=mid+1;
      else
      return 1;

   }
   return 0;
}
int main()
{
    int n,m,k,i,t,j,l=0,r=0,sum=0,max=0,min=0,x=0;
  double ans=0;
    scanf("%d %d",&n,&l);
    for(i=0;i<n;i++)
    {
       scanf("%d",&a[i]);
    }
    if(n==1)
    {
       if(a[0]==0||a[0]==l)
       printf("%lf",(double)l);
       else
       {
          if(l-a[0]>a[0])
          l=l-a[0];
          else
          l=a[0];
          printf("%lf",(double)l);
       }
       return 0;
    }
    qsort(a,n,sizeof(int),cmf);
   /* for(i=0;i<n;i++)
    printf("%d ",a[i]);
    puts("\n");*/
    if(a[0]!=0)
    max=a[0];
    if(a[n-1]!=l)
    min=l-a[n-1];
    max=(max>min)?max:min;
    //printf("%d %d %d\n",a[0],a[n-1],max);
    for(i=1;i<n;i++)
    {
       //printf("%d %d\n",a[i-1],a[i]);
       x=a[i]-a[i-1];
       if(r<x)
       r=x;
       //printf("%.0lf ;",r);
    }
    //r=r/2.0;
    if(max*2>=r)
    printf("%lf",(double)max);
    else
    printf("%lf",(double)r/2.0);
    return 0;
}


#include <stdio.h>
#include <stdio.h>
#include <ctype.h>

int main() {
    int n, m, i, num, tmp, flag = 1, rozdil, max = 0;
    scanf("%d %d", &n, &m);
    int array[n+2];
    array[0] = 0;
    array[n+2] = m;

   for (i=1; i<n+1; i++) {
       scanf("%d", &num);
       array[i] = num;
   }

   while (flag != 0) {
       flag = 0;
   for (i=0; i<n+1; i++) {
       if (array[i] > array[i+1]) {
           tmp = array[i];
           array[i] = array[i+1];
           array[i+1] = tmp;
           flag = 1;
       }
   }
   }

   for (i=0; i<n; i++) {
       rozdil = array[i+1] - array[i];
      // printf("rozdil %d\n", rozdil);
       if ( rozdil > max) max = rozdil;
       // printf("max %d\n", max);
   }

   printf("%lf0000\n", max/2.);

  return 0;

}


#include <stdio.h>
#include <stdio.h>
#include <ctype.h>

int main() {
    int n, m, i, num, tmp, flag = 1, rozdil, max = 0;
    scanf("%d %d", &n, &m);
    int array[n+2];

   for (i=1; i<n+1; i++) {
       scanf("%d", &num);
       array[i] = num;
   }

   while (flag != 0) {
       flag = 0;
   for (i=1; i<n; i++) {
       if (array[i] > array[i+1]) {
           tmp = array[i];
           array[i] = array[i+1];
           array[i+1] = tmp;
           flag = 1;
       }
   }
   }

   array[0] = -array[1];
   array[n+2] = m + m-array[n+1];

   for (i=0; i<n; i++) {
       rozdil = array[i+1] - array[i];
      // printf("rozdil %d\n", rozdil);
       if ( rozdil > max) max = rozdil;
       // printf("max %d\n", max);
   }

   printf("%lf0000\n", max/2.);

  return 0;

}