use std::cmp::Ordering::{Equal, Greater};
use std::fmt::Debug;
use std::io::stdin;
use std::str::FromStr;

const EPS: f64 = 1e-9;

fn read_line() -> String {
    let mut buf = String::new();
    stdin().read_line(&mut buf).expect("Failed to read a line");
    buf
}

fn read_vector<T>() -> Vec<T>
where
    T: FromStr,
    <T as FromStr>::Err: Debug,
{
    read_line().trim().split_whitespace().map(|x| x.parse::<T>().unwrap()).collect()
}

fn fmax<T>(a: T, b: T) -> T
where
    T: PartialOrd,
{
    match a.partial_cmp(&b).unwrap_or(Greater) {
        Greater => a,
        _ => b
    }
}

fn calculate_min_radius(street_length: f64, coords: &[f64]) -> f64 {
    // let mut upper = fmax(
    //     street_length - coords.first().unwrap(), coords.last().unwrap()
    // if coords.len() == 1 {
    //     return upper;
    // }

    // let mut lower = 0.0;

    let max_distance: f64 =
        coords.iter().skip(1).zip(coords.iter())
        .map(|(next, prev)| (next - prev) / 2.0)
        .max_by(|&a, &b| a.partial_cmp(&b).unwrap_or(Equal))
        .unwrap();
    let max_distance = fmax(
        max_distance,
        fmax(street_length - coords.last().unwrap(), *coords.first().unwrap())
    );
    max_distance
    // dbg!(max_distance);
    // let is_sufficient_radius = |r| r >= max_distance;

    // let is_sufficient_radius = |r| {
    //     // dbg!(r);
    //     let mut min_coord_without_light: f64 = 0.0;
    //     let mut pos: usize = 0;
    //     while pos < coords.len() {
    //         // println!("---");
    //         // dbg!(pos);
    //         // dbg!(min_coord_without_light);
    //         if coords[pos] - r > min_coord_without_light {
    //             // let result = false;
    //             // dbg!(result);
    //             return false;
    //         }
    //         let mut left = pos;
    //         let mut right = coords.len() - 1;
    //         while right - left > 1 {
    //             let middle = left + (right - left) / 2;
    //             // dbg!(left);
    //             // dbg!(middle);
    //             // dbg!(right);
    //             // std::thread::sleep(std::time::Duration::from_secs(1));
    //             if coords[middle] - r > min_coord_without_light {
    //                 right = middle
    //             } else {
    //                 left = middle
    //             }
    //         }
    //         // dbg!(left);
    //         min_coord_without_light = coords[left] + r;
    //         pos = left + 1;
    //     }
    //     // let result = min_coord_without_light >= street_length;
    //     // dbg!(result);
    //     // result
    //     min_coord_without_light >= street_length
    //     // for x in coords {
    //     //     if x - r > min_coord_without_light {
    //     //         return false;
    //     //     } else {
    //     //         min_coord_without_light = fmax(x + r, min_coord_without_light);
    //     //     }
    //     // }
    //     // min_coord_without_light >= street_length
    // };

    // while upper - lower >= EPS {
    //     let middle = lower + (upper - lower) / 2.0;
    //     // println!("===========");
    //     // dbg!(lower);
    //     // dbg!(upper);
    //     if is_sufficient_radius(middle) {
    //         upper = middle;
    //     } else {
    //         lower = middle;
    //     }
    //     // std::thread::sleep(std::time::Duration::from_secs(1));
    // }
    // upper
}

fn main() {
    let (_, street_length) = {
        let x = read_vector::<usize>();
        (x[0], x[1])
    };
    let coords: Vec<f64> = {
        let mut x = read_vector::<f64>();
        x.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap_or(Equal));
        x.dedup();
        x
    };
    println!("{}", calculate_min_radius(street_length as f64, &coords));
}


struct Scan {
    buffer: std::collections::VecDeque<String>
}

impl Scan {
    fn new() -> Scan {
        Scan { buffer: std::collections::VecDeque::new() }
    }

    fn next<T: std::str::FromStr>(&mut self)-> T {
        loop {
            if let Some(token) = self.buffer.pop_front() {
                break token.parse::<T>().ok().unwrap();
            }
            let mut line = String::new();
            std::io::stdin()
                .read_line(&mut line)
                .expect("Fail to read");
            self.buffer = line
                .split_whitespace()
                .map(String::from)
                .collect();
        }
    }

    fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n)
            .map(|_| self.next::<T>())
            .collect()
    }

}

fn main() {
    let mut scan = Scan::new();
    let n: usize = scan.next();
    let l: usize = scan.next();
    let mut dist: Vec<usize> = scan.next_n(n);
    dist.sort();
    let mut result: f64 = dist[0] as f64;
    for i in 0..n-1 {
        let required_d: f64 = (dist[i+1] - dist[i]) as f64 / 2f64;
        result = result.max(required_d);
    }
    if dist.len() > 1 {
        result = result.max((l - *dist.last().unwrap()) as f64);
    }
    println!("{:.10}", result);
}


struct Scan {
    buffer: std::collections::VecDeque<String>
}

impl Scan {
    fn new() -> Scan {
        Scan { buffer: std::collections::VecDeque::new() }
    }

    fn next<T: std::str::FromStr>(&mut self)-> T {
        loop {
            if let Some(token) = self.buffer.pop_front() {
                break token.parse::<T>().ok().unwrap();
            }
            let mut line = String::new();
            std::io::stdin()
                .read_line(&mut line)
                .expect("Fail to read");
            self.buffer = line
                .split_whitespace()
                .map(String::from)
                .collect();
        }
    }

    fn next_n<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n)
            .map(|_| self.next::<T>())
            .collect()
    }

}

fn main() {
    let mut scan = Scan::new();
    let n: usize = scan.next();
    let l: usize = scan.next();
    let mut dist: Vec<usize> = scan.next_n(n);
    dist.sort();
    let mut result: f64 = dist[0] as f64;
    for i in 0..n-1 {
        let required_d: f64 = (dist[i+1] - dist[i]) as f64 / 2f64;
        result = result.max(required_d);
    }
    result = result.max((l - *dist.last().unwrap()) as f64);
    println!("{:.10}", result);
}


use std::io;
use std::io::Stdin;
use std::str::FromStr;

fn read_line(stdin : &Stdin, line : &mut String) {
    match stdin.read_line(line) {
        Ok(_) => return,
        Err(msg) => panic!("Could not read line! Message: {}.", msg),
    }
}

fn parse_t<T : FromStr>(s : &str) -> T {
    match s.trim().parse() {
        Ok(y) => y,
        Err(_) => panic!("Could not read from string!"),
    }
}

fn read_ts<T : FromStr>(stdin : &Stdin, ts : &mut Vec<T>) {
    let mut line = String::new();
    read_line(stdin, &mut line);
    let word_iter = line.split_whitespace();
    for word in word_iter {
        let x = parse_t(word);
        ts.push(x);
    }
}

fn minimum_radius(l : u64, xs : &mut Vec<u64>) -> f64 {
    let xs_len = xs.len();
    xs.sort();
    let mut d_max = if xs[0] > 0 { xs[0] as f64 } else { 0.0 };
    for i in 1 .. xs_len {
        let d_cur = ((xs[i] - xs[i - 1]) as f64) / 2.0;
        if d_cur > d_max {
            d_max = d_cur;
        }
    }
    let d_cur = if xs[xs_len - 1] < l { (l - xs[xs_len - 1]) as f64 } else { 0.0 };
    if d_cur > d_max {
        d_max = d_cur;
    }
    d_max
}

fn main() {
    let stdin = io::stdin();
    let mut n_l = vec![];
    read_ts(&stdin, &mut n_l);
    let l = n_l[1];
    let mut xs = vec![];
    read_ts(&stdin, &mut xs);
    println!("{}", minimum_radius(l, &mut xs));
}

#[cfg(test)]
mod tests {
    #[test]
    fn cf_1() {
        let l = 15;
        let mut xs = vec![15, 5, 3, 7, 9, 14, 0];
        let d_min = super::minimum_radius(l, &mut xs);
        assert_eq!(true, (d_min - 2.5).abs() < 1.0e-9);
    }

    #[test]
    fn cf_2() {
        let l = 5;
        let mut xs = vec![2, 5];
        let d_min = super::minimum_radius(l, &mut xs);
        assert_eq!(true, (d_min - 2.0).abs() < 1.0e-9);
    }
}


fn solve() {
    let (n, l): (usize, u32) = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        let mut ws = buf.split_whitespace();
        let n = ws.next().unwrap().parse().unwrap();
        let l = ws.next().unwrap().parse().unwrap();
        (n, l)
    };
    let mut a: Vec<u32> = {
        let mut buf = String::new();
        std::io::stdin().read_line(&mut buf).unwrap();
        buf.split_whitespace().map(|x| x.parse().unwrap()).collect()
    };
    a.sort();

    let mut ans = 0.0;
    for i in 0..(n - 1) {
        let dist = (a.get(i + 1).unwrap() - a.get(i).unwrap()) as f64 / 2.0;
        if ans < dist {
            ans = dist;
        }
    }

    let dist = (a.get(0).unwrap() - 0) as f64;
    if ans < dist {
        ans = dist;
    }
    let dist = (l - a.get(n - 1).unwrap()) as f64;
    if ans < dist {
        ans = dist;
    }

    println!("{}", ans);
}

fn main() {
    // let t: u32 = {
    //     let mut buf = String::new();
    //     std::io::stdin().read_line(&mut buf).unwrap();
    //     buf.trim_end().parse().unwrap()
    // };

    solve();
    // for _ in 0..t {}
}


use std::io;

fn read_line() -> String {
    let mut input_line = String::new();
    io::stdin().read_line(&mut input_line).unwrap();
    return String::from(input_line.trim());
}

fn read_line_vec() -> Vec<u64> {
    return read_line().split(' ')
        .map(|s| s.parse().unwrap())
        .collect();
}

fn read_line_pair() -> (u64, u64) {
    let vec = read_line_vec();
    return (vec[0], vec[1]);
}

fn main() {
    let (_n, l) = read_line_pair();

    let mut points = read_line_vec();
    points.sort();

    let mut max_dist: u64 = std::cmp::max(
        &points[0] * 2, (l - &points[points.len() - 1]) * 2
    );

    for i in 1..points.len() {
        let prev = &points[i-1];
        let curr = &points[i];
        let dist = curr - prev;
        if dist > max_dist {
            max_dist = dist;
        }
    }

    // println!("{:?}", points);
    println!("{}", max_dist as f64 / 2.0);
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    &lanterns.push(l + 1);
    lanterns.sort();

    let mut max = i32::min_value();
    let mut p = 0;
    for i in 0..n + 1 {
        let f = if i == 0 || i == n { 2 } else { 1 };
        let d = lanterns[i as usize] - p;
        max = cmp::max(max, d * f);
        p = lanterns[i as usize];
    }
    println!("{}", max as f32 / 2.0);
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    &lanterns.push(l + 1);
    lanterns.sort();

    let mut max = i32::min_value();
    let mut p = 0;
    for i in 0..n + 1 {
        let f = if i == 0 || i == n { 2 } else { 1 };
        let o = if i == 0 { 0 } else { -1 };
        let d = lanterns[i as usize] - p;
        max = cmp::max(max, (d + o) * f);
        p = lanterns[i as usize];
    }
    println!("{}", f32::ceil(max as f32 / 2.0));
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    lanterns.sort();

    let mut max = 2 * cmp::max(lanterns[0], l - lanterns[n as usize - 1]);
    for i in 1..lanterns.len() {
        max = cmp::max(max, lanterns[i] - lanterns[i - 1]);
    }
    println!("{}", max as f32 / 2.0);
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    lanterns.sort();

    let mut max = 2 * cmp::max(lanterns[0], l - lanterns[n as usize - 1]);
    for i in 0..n - 1 {
        max = cmp::max(max, lanterns[(i + 1) as usize] - lanterns[i as usize]);
    }
    println!("{}", max as f32 / 2.0);
}


fn main() {
    let v: Vec<i32> = {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        line.trim()
            .split(" ")
            .map(|s| s.parse::<i32>().unwrap())
            .collect()
    };
    let (n, l) = (v[0], v[1]);
    let mut v: Vec<i32> = {
        let mut line = String::new();
        std::io::stdin().read_line(&mut line).unwrap();
        line.trim()
            .split(" ")
            .map(|s| s.parse::<i32>().unwrap())
            .collect()
    };
    v.sort();
    let (first, last) = (-v[0], 2 * l - v[v.len() - 1]);
    v.insert(0, first);
    v.push(last);

    let ret = v
        .iter()
        .zip(&v[1..])
        .fold(0, |ret, (a, b)| std::cmp::max((b - a), ret));
    println!("{:?}", ret as f64 / 2.0);
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    lanterns.sort();

    let mut max = 2 * cmp::max(lanterns[0], l - lanterns[n as usize - 1]);
    for i in 1..lanterns.len() - 1 {
        max = cmp::max(max, lanterns[i + 1] - lanterns[i]);
    }
    println!("{}", max as f32 / 2.0);
}


use std::cmp;
use std::io::stdin;

fn read_line() -> String {
    let mut input = String::new();
    stdin().read_line(&mut input).expect("Failed to read line!");
    input
}

fn main() {
    let input1 = read_line();
    let line1: Vec<&str> = input1.split(" ").collect();
    let n = line1[0].trim().parse::<i32>().unwrap();
    let l = line1[1].trim().parse::<i32>().unwrap();

    let input2 = read_line();
    let line2: Vec<&str> = input2.split(" ").collect();
    let mut lanterns: Vec<i32> = Vec::new();
    for a in &line2 {
        &lanterns.push(a.trim().parse::<i32>().unwrap());
    }
    &lanterns.push(l);
    lanterns.sort();

    let mut max = i32::min_value();
    let mut p = 0;
    for i in 0..n + 1 {
        let f = if i == 0 || i == n { 2 } else { 1 };
        let d = lanterns[i as usize] - p;
        max = cmp::max(max, d * f);
        p = lanterns[i as usize];
    }
    println!("{}", max as f32 / 2.0);
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
	int n,i;
	long int l;
	long int d,p;
	cin>>n>>l;
	long int a[n];
	for(i=0;i<n;i++)
		cin>>a[i];
	sort(a,a+n);
	p = (a[0]>=l-a[n-1]) ? 2*a[0] : 2*(l-a[n-1]);
	for(i=0;i<n-1;i++)
	{
		d=a[i+1]-a[i];
		if(d>p)
			p=d;
	}
	long int k = p/2;
	cout<<k;
	if (p%2==1)
	cout<<".5"<<endl;
	return 0;
}


#include <stdio.h>
#include <algorithm>
using namespace std;
int n,i,a[100500],rez,l;
int main()
{
    scanf("%d%d",&n,&l);
    for (i = 0; i < n; i++)
        scanf("%d",&a[i]);
    sort(a,a+n);
    rez = 2*max(a[0],l-a[n-1]);
    for (i = 0; i < n-1; i++)
        rez = max(rez, a[i+1]-a[i]);
    printf("%.10f\n",rez/2.);
    return 0;
}


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

int main()
{
    int n, l, r;
    cin >> n >> l;
    int p[n];

    for (int i = 0; i < n; i++)
        cin >> p[i];

    sort(p, p + n);
    r = max(p[0], l - p[n - 1]) * 2;

    for (int i = 0; i < n - 1; i++)
        r = max(r, p[i + 1] - p[i]);

    cout.precision(20);
    cout << fixed << r / 2.0 << endl;
    return 0;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
ll *a= new ll[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
ll *b=new ll[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=a([i+1]-a[i])/2.0;
}
b[n]=l-a[n-1];
sort(b,b+n+1);
cout<<b[n]<<endl;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
ll *a= new ll[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
ll *b=new ll[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=a[i+1]-a[i];
}
b[n]=l-a[n-1];
sort(b,b+n+1);
cout<<b[n]/2.0<<endl;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{int n;
ll l;
scanf("%d%I64d",&n,&l);
ll *a= new ll[n];

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

ll b=2*max(l-a[n-1],a[0]);
for(int i=0;i<n-1;i++)
{
	b=max(b,a[i+1]-a[i]);
}

printf("%0.10Lf\n",((long double)b)/2.0);
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
long double *a= new long double[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
long double *b=new long double[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=(a[i+1]-a[i])/2.0;
}
b[n]=l-a[n-1];
sort(b,b+n+1);
cout<<b[n]<<endl;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
ll *a= new ll[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
ll *b=new ll[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=(a[i+1]-a[i])/2.0;
}
b[n]=l-a[n-1];
sort(b,b+n+1);
cout<<b[n]<<endl;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{int n;
ll l;
scanf("%d%d",&n,&l);
long double *a= new long double[n];

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

long double b=2*max(l-a[n-1],a[0]);
for(int i=0;i<n-1;i++)
{
	b=max(b,a[i+1]-a[i]);
}

printf("%0.10Lf\n",b/2.0);
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
long double *a= new long double[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
long double *b=new long double[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=(a[i+1]-a[i])/2;
}
b[n]=l-a[n-1];
ll thei=0;
for(ll i=0;i<n+1;i++)
{
	if(b[i]>b[thei])
	thei=i;
}
printf("%0.10Lf\n",b[thei]);
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{int n;
ll l;
scanf("%d%I64d",&n,&l);
long double *a= new long double[n];

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

long double b=2*max(l-a[n-1],a[0]);
for(int i=0;i<n-1;i++)
{
	b=max(b,a[i+1]-a[i]);
}

printf("%0.10Lf\n",b/2.0);
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
ll *a= new ll[n];
cin>>n>>l;
for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
ll *b=new ll[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=a[i+1]-a[i];
}
b[n]=l-a[n-1];
sort(b,b+n+1);
cout<<b[n]/2.0<<endl;
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
long double *a= new long double[n];

for(ll i=0;i<n;i++)
{
	cin>>a[i];
}
sort(a,a+n);
long double *b=new long double[n+1];
b[0]=a[0];
for(ll i=0; i<n-1;i++)
{
	b[i+1]=(a[i+1]-a[i])/2;
}
b[n]=l-a[n-1];
sort(b,b+n+1);
printf("%0.10Lf\n",b[n]);
}


#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>
#include <cmath>
#define ull unsigned long long int
#define ll long long int
using namespace std;

int main()
{
ll n,l;
cin>>n>>l;
long double *a= new long double[n];

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

long double b=2*max(l-a[n-1],a[0]);
for(ll i=0;i<n-1;i++)
{
	b=max(b,a[i+1]-a[i]);
}

printf("%0.10Lf\n",b/2.0);
}


package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
	"sort"
)

var in *bufio.Scanner = bufio.NewScanner(os.Stdin)
var out *bufio.Writer = bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()
	in.Split(bufio.ScanWords)

	n, l := nextInt(), nextInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	sort.Ints(a)

	d := 2 * max(a[0], l - a[n - 1])
	for i := 1; i < n; i++ {
		d = max(d, a[i] - a[i - 1])
	}
	fmt.Printf("%.9f", float64(d) / 2)
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func nextInt() int {
	in.Scan()
	res, _ := strconv.Atoi(in.Text())
	return res
}


package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
	"sort"
)

var in *bufio.Scanner = bufio.NewScanner(os.Stdin)
var out *bufio.Writer = bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()
	in.Split(bufio.ScanWords)

	n, l := nextInt(), nextInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	sort.Ints(a)

	d := 2 * max(a[0], l - a[n - 1])
	for i := 1; i < n; i++ {
		d = max(d, a[i] - a[i - 1])
	}
	fmt.Println(float32(d) / 2.0)
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func nextInt() int {
	in.Scan()
	res, _ := strconv.Atoi(in.Text())
	return res
}


package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
	"sort"
)

var in *bufio.Scanner = bufio.NewScanner(os.Stdin)
var out *bufio.Writer = bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()
	in.Split(bufio.ScanWords)

	n, l := nextInt(), nextInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = nextInt()
	}
	sort.Ints(a)

	d := 2 * max(a[0], l - a[n - 1])
	for i := 1; i < n; i++ {
		d = max(d, a[i] - a[i - 1])
	}
	fmt.Printf("%.9f", float32(d) / 2.0)
}

func max(x, y int) int {
	if x > y {
		return x
	}
	return y
}

func nextInt() int {
	in.Scan()
	res, _ := strconv.Atoi(in.Text())
	return res
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var n, l int
	var sum float64
	scr := bufio.NewReader(os.Stdin)
	ocr := bufio.NewWriter(os.Stdout)

	fmt.Scanln(&n, &l)

	ld := make([]int, n)

	for i := int(0); i < n; i++ {
		fmt.Fscanf(scr, "%d", &ld[i])
	}
	sort.Sort(sort.IntSlice(ld))

	last := 0
	for x, y := range ld {
		if x == 0 {
			sum = float64(y)
		} else if x == n-1 {
			if sum < float64(l-y) {
				sum = float64(l - y)
			}
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		} else {
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		}
		last = y
	}

	fmt.Fprintln(ocr, sum)
	ocr.Flush()
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var n, l int
	var sum float64
	scr := bufio.NewReader(os.Stdin)
	ocr := bufio.NewWriter(os.Stdout)

	fmt.Scanln(&n, &l)

	ld := make([]int, n)

	for i := int(0); i < n; i++ {
		fmt.Fscanf(scr, "%d", &ld[i])
	}
	sort.Sort(sort.IntSlice(ld))

	last := 0
	for x, y := range ld {
		if x == 0 {
			sum = float64(y)
		}
		if x == n-1 {
			if sum < float64(l-y) {
				sum = float64(l - y)
			}
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		} else {
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		}
		last = y
	}

	fmt.Fprintln(ocr, sum)
	ocr.Flush()
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var n, l int
	var sum float64
	scr := bufio.NewReader(os.Stdin)
	ocr := bufio.NewWriter(os.Stdout)

	fmt.Scanln(&n, &l)

	ld := make([]int, n)

	for i := int(0); i < n; i++ {
		fmt.Fscanf(scr, "%d", &ld[i])
	}
	sort.Sort(sort.IntSlice(ld))

	last := 0
	for x, y := range ld {
		if x == 0 {
			sum = float64(y)
		} else if x == n-1 {
			if sum < float64(l-y) {
				sum = float64(y)
			}
		} else {
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		}
		last = y
	}

	fmt.Fprintln(ocr, sum)
	ocr.Flush()
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	var n, l int
	var sum float64
	scr := bufio.NewReader(os.Stdin)
	ocr := bufio.NewWriter(os.Stdout)

	fmt.Scanln(&n, &l)

	ld := make([]int, n)

	for i := int(0); i < n; i++ {
		fmt.Fscanf(scr, "%d", &ld[i])
	}
	sort.Sort(sort.IntSlice(ld))

	last := 0
	for x, y := range ld {
		if x == 0 {
			sum = float64(y)
		} else if x == n-1 {
			if sum < float64(l-y) {
				sum = float64(y)
			}
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		} else {
			if sum < float64(y-last)/float64(2) {
				sum = float64(y-last) / float64(2)
			}
		}
		last = y
	}

	fmt.Fprintln(ocr, sum)
	ocr.Flush()
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n, l int
	var max float64
	fmt.Scan(&n, &l)
	var lights = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&lights[i])
	}
	sort.Ints(lights)
	if lights[0] != 0 {
		max = float64(lights[0] - 0)
	}
	for i := 1; i < n; i++ {
		if float64(lights[i] - lights[i - 1]) / 2 > max {
			max = float64(lights[i] - lights[i - 1]) / 2
		}
	}
	if lights[n - 1] != l && float64(l - lights[n - 1]) > max {
		max = float64(l - lights[n - 1])
	}
	fmt.Println(max)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n, l int
	var max float32
	fmt.Scan(&n, &l)
	var lights = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&lights[i])
	}
	sort.Ints(lights)
	if lights[0] != 0 {
		max = float32(lights[0] - 0)
	}
	for i := 1; i < n; i++ {
		if float32(lights[i] - lights[i - 1]) / 2 > max {
			max = float32(lights[i] - lights[i - 1]) / 2
		}
	}
	if lights[n - 1] != l && float32(l - lights[n - 1]) > max {
		max = float32(l - lights[n - 1])
	}
	fmt.Println(max)
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"sort"
	"strconv"
	"strings"
	"sync"
)

func main() {
	n, l := scanInt64(), scanInt64()
	arr := scanInt64Slice(n)
	var maxdist int64 = 0
	sort.Slice(arr, func(i, j int) bool { return arr[i] < arr[j] })
	for i := int64(0); i < n - 1; i++ {
		if arr[i + 1] - arr[i] > maxdist {
			maxdist = arr[i + 1] - arr[i]
		}
	}
	_, _ = printFmt(math.Max(float64(maxdist) / float64(2), float64(max(arr[0], l - arr[n - 1]))))
}

/*********************** I/O ***********************/

var channelType chan string
var in *bufio.Scanner
var oWg *sync.WaitGroup
var printFmt func(a ...interface{}) (n int, err error)

func init() {
	printFmt = fmt.Println

	in = bufio.NewScanner(os.Stdin)
	in.Buffer(make([]byte, 1024), int(1e+9))
	in.Split(bufio.ScanWords)

	channelType = make(chan string, 16)
	oWg = &sync.WaitGroup{}
	oWg.Add(1)

	writer := bufio.NewWriter(os.Stdout)
	go func() {
		defer oWg.Done()
		defer writer.Flush()

		for line := range channelType {
			_, _ = writer.WriteString(line + "\n")
		}
	}()
}

func scanString() string {in.Scan(); return in.Text() }
func scanInt() int {i, _ := strconv.Atoi(scanString()); return i}
func scanInt64() int64 {i, _ := strconv.ParseInt(scanString(), 10, 64); return i}
func scanStringSlice(n int) []string {s := make([]string, n); for i := 0; i < n; i++ {s[i] = scanString()}; return s}
func scanIntSlice(n int) []int {arr := make([]int, n); for i := 0; i < n; i++ {arr[i] = scanInt()}; return arr}
func scanInt64Slice(n int64) []int64 {arr := make([]int64, n); for i := int64(0); i < n; i++ {arr[i] = scanInt64()}; return arr}

/*********************** Utils ***********************/

func stringEquivalent(v interface{}) string {return fmt.Sprintf("%v", v)}
func spaceSeperatedStringFromArray(a []int) string {sb := strings.Builder{}; sb.Grow(len(a) * 9); for i := range a {sb.WriteString(strconv.Itoa(a[i]) + " ")}; return sb.String()}
func spaceSeperatedStringFromArray64(a []int64) string {sb := strings.Builder{}; sb.Grow(len(a) * 9); for i := range a {sb.WriteString(strconv.FormatInt(a[i], 10) + " ")}; return sb.String()}
func minMaxFromArray(args ...int64) (int64, int64) {minVal, maxVal := int64(math.MaxInt64), int64(math.MinInt64); for _, v := range args {if v < minVal {minVal = v}; if v > maxVal {maxVal = v}}; return minVal, maxVal}
func minElementFromArray(args ...int64) int64 { mn, _ := minMaxFromArray(args...); return mn }
func maxElementFromArray(args ...int64) int64 { _, mx := minMaxFromArray(args...); return mx }
func lcmCalculation(a, b int64) int64 {return a / gcdCalculation(a, b) * b}
func gcdCalculation(a, b int64) int64 {if a == 0 {return b}; return gcdCalculation(b%a, a)}
func sortInt64Slice(a []int64) {sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })}
func absoluteValue(x int64) int64 {if x < 0 {return -x}; return x}
func min(args ...int64) int64 { mn, _ := MnMx(args...); return mn }
func max(args ...int64) int64 { _, mx := MnMx(args...); return mx }
func MnMx(args ...int64) (int64, int64) {
	minVal, maxVal := int64(math.MaxInt64), int64(math.MinInt64)
	for _, v := range args {
		if v < minVal {
			minVal = v
		}
		if v > maxVal {
			maxVal = v
		}
	}
	return minVal, maxVal
}
func sorting(array []int64, fromElement int, toElement int) []int64 {
	var arr []int64
	for i := fromElement; i <= toElement; i++ {
		arr = append(arr, array[i])
	}
	sort.Slice(arr, func(i, j int) bool { return arr[i] < arr[j] })
	s := 0
	for i := fromElement; i <= toElement; i++ {
		array[i] = arr[s]
		s++
	}
	return array
}

func reverse(numbers []int64) []int64 {
	for i, j := 0, len(numbers)-1; i < j; i, j = i+1, j-1 {
		numbers[i], numbers[j] = numbers[j], numbers[i] }
	return numbers
}

func reversing(array []int64, fromElement int, toElement int) []int64 {
	var arr []int64
	for i := fromElement; i <= toElement; i++ {
		arr = append(arr, array[i])
	}
	arr = reverse(arr)
	s := 0
	for i := fromElement; i <= toElement; i++ {
		array[i] = arr[s]
		s++
	}
	return array
}

func arraySum(array []int) int {
	var ans = 0
	for _, element := range array {
		ans += element
	}
	return ans
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n int
	var d int

	var x int

	fmt.Scan(&n)
	fmt.Scan(&d)

	lanterns := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Scan(&x)
		lanterns[i] = x
	}
	sort.Ints(lanterns)

	var max float64
	for i, v := range lanterns {
		if i == 0 {
			r := float64(v)
			if v != 0 && r > max {
				max = r
			}
		} else {
			r := float64(v-lanterns[i-1]) / 2
			if r > max {
				max = r
			}
		}
		if i == len(lanterns)-1 && v != d {
			r := float64(d - v)
			if r > max {
				max = r
			}
		}
	}
	fmt.Printf("%2.10f\n", max)

}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n,l int
	fmt.Scan(&n)
	fmt.Scan(&l)

	a := make([]int, n)
	for i := 0; i<n;i++ {
		fmt.Scan(&a[i])
	}
	sort.Ints(a)
	a = append(a,l)

	maxDiff := 0
	for i:=0;i<n;i++ {
		if maxDiff < a[i+1] - a[i] {
			maxDiff = a[i+1] - a[i]
		}
	}
	fmt.Println(float32(maxDiff)/2.0)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n,l int
	fmt.Scan(&n)
	fmt.Scan(&l)

	a := make([]int, n)
	for i := 0; i<n;i++ {
		fmt.Scan(&a[i])
	}
	sort.Ints(a)

	maxDiff := 0
	for i:=0;i<n-1;i++ {
		if maxDiff < a[i+1] - a[i] {
			maxDiff = a[i+1] - a[i]
		}
	}
	if maxDiff < 2*(l - a[n-1]) {
		maxDiff = 2*(l-a[n-1])
	}
	if maxDiff < 2*a[0] {
		maxDiff = 2*a[0]
	}

	fmt.Println(float64(maxDiff)/2.0)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n,l int
	fmt.Scan(&n)
	fmt.Scan(&l)

	a := make([]int, n)
	for i := 0; i<n;i++ {
		fmt.Scan(&a[i])
	}
	sort.Ints(a)

	maxDiff := 0
	for i:=0;i<n-1;i++ {
		if maxDiff < a[i+1] - a[i] {
			maxDiff = a[i+1] - a[i]
		}
	}
	if maxDiff < 2*(l - a[n-1]) {
		maxDiff = 2*(l-a[n-1])
	}
	if maxDiff < 2*a[0] {
		maxDiff = 2*a[0]
	}

	fmt.Println(float32(maxDiff)/2.0)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func Println(a ...interface{}) {
	fmt.Println(a...)
}

func max(x int,y int) int {
	if x>y{
		return x
	}
	return y
}

func main() {
	var n,l int
	scan(&n,&l)
	arr:=make([]int,n)
	for i:=0;i<n;i++{
		scan(&arr[i])
	}
	sort.Ints(arr)
	var dist int = max(arr[0],l-arr[n-1])
	for i:=1;i<n;i++{
		dist=max(dist,arr[i]-arr[i-1])
	}
	Println(float64(dist)/2.0)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader *bufio.Reader = bufio.NewReader(os.Stdin)
var writer *bufio.Writer = bufio.NewWriter(os.Stdout)

func scan(a ...interface{}) {
	fmt.Fscan(reader, a...)
}

func Println(a ...interface{}) {
	fmt.Println(a...)
}

func max(x int,y int) int {
	if x>y{
		return x
	}
	return y
}

func main() {
	var n,l int
	scan(&n,&l)
	arr:=make([]int,n)
	for i:=0;i<n;i++{
		scan(&arr[i])
	}
	sort.Ints(arr)
	var dist int = max(arr[0],l-arr[n-1])*2
	for i:=1;i<n;i++{
		dist=max(dist,arr[i]-arr[i-1])
	}
	Println(float64(dist)/2.0)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n int
	var l int
	var a []float64
	var min float64 = -1.0

	fmt.Scanf("%d %d\n", &n, &l)

	a = make([]float64, n+2)

	a[0] = 0
	a[n+2-1] = float64(l)

	for i := 1; i <= n; i++ {
		fmt.Scanf("%f", &a[i])
	}

	// fmt.Println(n, l)
	// fmt.Println(a)

	sort.Float64s(a)

	// fmt.Println(a)

	for i := 1; i <= n-1; i++ {
		if min < (a[i+1]-a[i])/2 {
			min = (a[i+1] - a[i]) / 2
		}
	}

	if (a[1] - a[0]) > min {
		min = a[1] - a[0]
	}
	if (a[n+1] - a[n]) > min {
		min = a[n+1] - a[n]
	}

	fmt.Printf("%.9f\n", min)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n int
	var l int
	var a []float64
	var min float64 = -1.0

	fmt.Scanf("%d %d\n", &n, &l)

	a = make([]float64, n+2)

	a[0] = 0
	a[n+2-1] = float64(l)

	for i := 1; i <= n; i++ {
		fmt.Scanf("%f", &a[i])
	}

	fmt.Println(n, l)
	fmt.Println(a)

	sort.Float64s(a)

	fmt.Println(a)

	for i := 1; i <= n-1; i++ {
		if min < (a[i+1]-a[i])/2 {
			min = (a[i+1] - a[i]) / 2
		}
	}

	if (a[1] - a[0]) > min {
		min = a[1] - a[0]
	}
	if (a[n+1] - a[n]) > min {
		min = a[n+1] - a[n]
	}

	fmt.Printf("%.9f\n", min)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	var n, l int
	var arr []int
	fmt.Scanf("%d %d \n", &n, &l)

	reader := bufio.NewReader(os.Stdin)
	ss, _ := reader.ReadString('\n')
	list := strings.Split(strings.TrimRight(ss, "\r\n"), " ")

	for i := 0; i < n; i++ {
		t, _ := strconv.ParseUint(list[i], 10, 64)
		arr = append(arr, int(t))
	}
	sort.Ints(arr)

	res := 2 * max(arr[0], l-arr[n-1])
	last := arr[0]
	for i := 1; i < n; i++ {
		res = max(res, arr[i]-last)
		last = arr[i]
	}
	fmt.Print(float64(res) / float64(2))
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	var n, l int
	var arr []int
	fmt.Scanf("%d %d \n", &n, &l)

	reader := bufio.NewReader(os.Stdin)
	ss, _ := reader.ReadString('\n')
	list := strings.Split(strings.TrimRight(ss, "\r\n"), " ")

	for i := 0; i < n; i++ {
		t, _ := strconv.ParseUint(list[i], 10, 64)
		arr = append(arr, int(t))
	}
	sort.Ints(arr)

	res := 2 * max(arr[0], l-arr[n-1])
	last := arr[0]
	for i := 1; i < n; i++ {
		res = max(res, arr[i]-last)
		last = arr[i]
	}
	fmt.Print(float64(5) / float64(2))
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type ByValue []int64

func (v ByValue) Len() int {
	return len(v)
}

func (v ByValue) Swap(i, j int) {
	v[i], v[j] = v[j], v[i]
}

func (v ByValue) Less(i, j int) bool {
	return v[i] < v[j]
}

// Input & Output
var (
	input  = bufio.NewReader(os.Stdin)
	output = bufio.NewWriter(os.Stdout)
)

var (
	n      int
	l      int64
	a      []int64
	result float64
)

func in() {
	fmt.Fscan(input, &n, &l)
	a = make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(input, &a[i])
	}
}

func out() {
	fmt.Fprintln(output, result)
	defer output.Flush()
}

func run() {
	sort.Sort(ByValue(a))

	var max int64 = 0
	var last int64 = a[0]
	for i := 1; i < n; i++ {
		var curr int64
		if i < n {
			curr = a[i]
		}
		if curr-last > max {
			max = curr - last
		}
		last = curr
	}

	result = float64(max) / 2

	if float64(a[0]) > result {
		result = float64(a[0])
	}

	if float64(l-a[n-1]) > result {
		result = float64(l - a[n-1])
	}
}

func main() {
	in()
	run()
	out()
}


package main

import (
    "fmt"
    "os"
    "time"
    "bufio"
    "sort"
)

type pair struct {
    a, b int
}

func main() {
    start := time.Now()
    defer func () {
        run := time.Since(start)
        _ = run
        // fmt.Println("Run in", run)
    }()

    stdin := bufio.NewReader(os.Stdin)

    var n int
    var l float64
    fmt.Fscan(stdin, &n, &l)

    var a = make([]float64, n)
    for i := 0; i < n; i++ {
        fmt.Fscan(stdin, &a[i])
    }
    sort.Slice(a[:], func (i, j int) bool {
        return a[i] < a[j]
    })
    // fmt.Println(a)

    check := func (d float64) bool {
        if a[0] != 0 && a[0] - d > 0 {
            return false
        }
        if a[n-1] != l && a[n-1] + d < l {
            return false
        }
        for i := 1; i < n; i++ {
            if a[i-1] + d < a[i] - d {
                return false
            }
        }
        return true
    }

    var lo, hi float64 = 0, float64(l)
    var mid float64
    for x := 10000; x > 0; x-- {
        mid = (hi + lo) / 2
        // fmt.Println(lo, mid, hi, check(mid))
        if check(mid) {
            hi = mid
        } else {
            lo = mid
        }
    }
    fmt.Printf("%.9f\n", mid)
    //fmt.Println(check(1.999999999))
}


package main

import "bufio"
import "os"
import "fmt"
import "sort"

func Read(s *bufio.Reader) string {
    line, _ := s.ReadString('\n')
    return line
}

func Write(s *bufio.Writer, a ...interface{}) {
    fmt.Fprintln(s, a...)
    s.Flush()
}

func main() {
    reader := bufio.NewReader(os.Stdin)

    var n, l int
    line, _ := reader.ReadString(' ')
    fmt.Sscanln(line, &n)
    fmt.Sscanln(Read(reader), &l)

    a := make([]int, n)

    for i := 0; i < n - 1; i++ {
        line, _ := reader.ReadString(' ')
        fmt.Sscanln(line, &a[i])
    }

    fmt.Sscanln(Read(reader), &a[n - 1])

    sort.Ints(a)

    var max float64 = float64(a[0] * 2)

    diff := (l - a[n - 1]) * 2
    if float64(diff) > max {
        max = float64(diff)
    }

    for i := 1; i < n; i++ {
        diff = a[i] - a[i - 1]
        if float64(diff) > max {
            max = float64(diff)
        }
    }

    writer := bufio.NewWriter(os.Stdout)
    fmt.Fprintf(writer, "%.9f", max / 2.0)

    writer.Flush()
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader = bufio.NewReader(os.Stdin)

func main() {
	var n, l int

	fmt.Fscan(reader, &n, &l)

	a := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	sort.Ints(a)

	var d float64

	for i := 0; i < n; i++ {
		if i == 0 {
			d = float64(a[i] - 0)
			continue
		}

		if i == n-1 {
			if float64(l-a[i]) > d {
				d = float64(l - a[i])
			}
		}

		if float64(a[i]-a[i-1])/2 > d {
			d = float64(a[i]-a[i-1]) / 2
		}
	}

	fmt.Println(d)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader = bufio.NewReader(os.Stdin)

func main() {
	var n, l int

	fmt.Fscan(reader, &n, &l)

	a := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	sort.Ints(a)

	var d float64

	for i := 0; i < n; i++ {
		if i == 0 {
			d = float64(a[i] - 0)
			continue
		} else if i == n-1 {
			if float64(l-a[i]) > d {
				d = float64(l - a[i])
			}
		}

		if float64(a[i]-a[i-1])/2 > d {
			d = float64(a[i]-a[i-1]) / 2
		}
	}

	fmt.Println(d)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader = bufio.NewReader(os.Stdin)

func main() {
	var n, l int

	fmt.Fscan(reader, &n, &l)

	a := make([]int, n)

	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}

	sort.Ints(a)

	var d float64

	for i := 0; i < n; i++ {
		if i == 0 {
			d = float64(a[i] - 0)
		}

		if i == n-1 {
			if float64(l-a[i]) > d {
				d = float64(l - a[i])
			}
		}

		if i == 0 {
			continue
		}

		if float64(a[i]-a[i-1])/2 > d {
			d = float64(a[i]-a[i-1]) / 2
		}
	}

	fmt.Println(d)
}


package main

import(
	"fmt"
	"sort"
	"math"
)

func main() {
	var n, l int
	fmt.Scanf("%d %d\n", &n, &l)
	arr := []int{}
	var tmp int
	for i := 0; i < n-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr = append(arr, tmp)
	}

	fmt.Scanf("%d\n", &tmp)
	arr = append(arr, tmp)

	sort.Ints(arr)
	res := 2*math.Max(float64(arr[0]), float64(l-arr[len(arr)-1]))
	for i := 0; i < n-1; i++ {
		res = math.Max(res, float64(arr[i+1] - arr[i]))
	}

	fmt.Printf("%.10f\n",res/2)
}


package main

import(
	"fmt"
	"sort"
	"math"
)

func main() {
	var n, l int
	fmt.Scanf("%d %d\n", &n, &l)
	arr := []int{}
	var tmp int
	for i := 0; i < n-1; i++ {
		fmt.Scanf("%d", &tmp)
		arr = append(arr, tmp)
	}

	fmt.Scanf("%d\n", &tmp)
	arr = append(arr, tmp)

	sort.Ints(arr)
	res := 2*math.Max(float64(arr[0]), float64(arr[len(arr)-1]-l))
	for i := 0; i < n-1; i++ {
		res = math.Max(res, float64(arr[i+1] - arr[i]))
	}

	fmt.Printf("%.10f\n",res/2)
}


package main

import (
	"fmt"
	"sort"
	"math"
)

func get_optimal_lantern_radius(lantern_pos []int, n, l int) float64 {
	sort.Ints(lantern_pos)
	// 2 5
	start_gap := lantern_pos[0] // start_gap = 2
	end_gap := l - lantern_pos[n - 1] // end_gap = 5 - 5 = 0
	boundary_gap := start_gap // boundary_gap = 2
	if end_gap > start_gap {
		boundary_gap = end_gap
	}
	max_gap := 0
	for i := 0; i < n - 1; i++ {
		// gap between 0 and 3 is 3
		gap := lantern_pos[i + 1] - lantern_pos[i]
		if gap > max_gap {
			max_gap = gap
		}
	}
	return math.Max(float64(boundary_gap), float64(max_gap) / 2.0)
}

func main() {
	var n, l int
	fmt.Scanln(&n, &l)
	lantern_pos := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scanf("%d", &lantern_pos[i])
	}
	fmt.Println(get_optimal_lantern_radius(lantern_pos, n, l))
}


package main

import (
	"fmt"
	"sort"
)

func max(x, y float64) float64 {
	if y > x {
		return y
	}
	return x
}

func main() {
	var n, l int
	fmt.Scan(&n, &l)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}
	sort.Ints(a)
	z := float64(max(float64(a[0]), float64(l-a[n-1])))
	for i := 0; i < n-1; i++ {
		z = max(z, float64(a[i+1]-a[i])/2.0)
	}
	fmt.Printf("%.10f\n", z)
}


package main

import (
	"fmt"
	"math"
	"sort"
)

func main() {
	var n, l int
	fmt.Scan(&n, &l)

	lanterns := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&lanterns[i])
	}

	sort.Ints(lanterns)
	radious := float64(lanterns[0])
	r := float64(l - lanterns[n-1])
	radious = math.Max(radious, r)

	for i := 0; i < n-1; i++ {
		r = float64(lanterns[i+1]-lanterns[i]) / 2
		radious = math.Max(radious, r)
	}

	fmt.Printf("%.10f", radious)
}


/**
 * Vanya and lanterns
 * http://codeforces.com/problemset/problem/492/B
 * Tue Oct 20 23:35
 * author: smanurung
 */

package main

import (
	"fmt"
)

/**
 * Bubble sort O(n^2).
 */
func bubble(ar []int) {
	n := len(ar)

	for ;; {
		swap := false
		for i := 1; i < n; i++ {
			if ar[i - 1] > ar[i] {
				temp := ar[i - 1]
				ar[i - 1] = ar[i]
				ar[i] = temp

				swap = true
			}
		}
		if !swap {
			break
		}
	}
	return
}

func main() {
	var n, l, t int
	var ar []int

	fmt.Scanf("%d %d\n", &n, &l)
	for i := 0; i < n; i ++ {
		fmt.Scanf("%d", &t)
		ar = append(ar, t)
	}

	bubble(ar)
	// fmt.Println(ar)

	br1 := ar[0] - 0
	br2 := l - ar[n -1]

	max := map[bool]float64{true: float64(br1), false: float64(br2)}[br1 > br2]
	for i := 1; i < n; i++ {
		tmp := float64(ar[i] - ar[i - 1]) / float64(2)
		if tmp > max {
			max = tmp
		}
	}
	fmt.Printf("%.9f\n", max)
}


//
// Theater Square
// http://codeforces.com/problemset/problem/1/A
// Mon Oct 19 22:43
// author: smanurung
//

package main

import (
	"fmt"
	"math"
)

type f float64
type i6 int64

func flagstone(n, m, a int) i6 {
	return i6(math.Ceil(float64(m)/float64(a))) * i6(math.Ceil(float64(n)/float64(a)))
}

func main() {
	var m, n, a int
	fmt.Scanf("%d %d %d\n", &n, &m, &a)

	fmt.Println(flagstone(n, m, a))
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

var reader *bufio.Reader

func init() {
	stdin := os.Stdin
	// stdin, _ = os.Open("1.in")
	reader = bufio.NewReaderSize(stdin, 1<<20)
}

var n, l int
var a []float64

func main() {
	fmt.Fscan(reader, &n, &l)
	a = make([]float64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &a[i])
	}
	sort.Sort(sort.Float64Slice(a))
	ans := 0.0
	for i := 0; i < n-1; i++ {
		if ans < (a[i+1]-a[i])/2 {
			ans = (a[i+1] - a[i]) / 2
		}
	}
	if ans < a[0] {
		ans = a[0]
	}
	if ans < float64(l)-a[n-1] {
		ans = float64(l) - a[n-1]
	}

	fmt.Println(ans)
}


package main

import (
	"fmt"
	"math"
	"sort"
)

func main() {
	var n int
	var l, max uint64
	fmt.Scan(&n, &l)
	var light []uint64 = make([]uint64, n)

	for i := 0; i < n; i++ {
		fmt.Scan(&light[i])
	}
	sort.Slice(light, func(i, j int) bool { return light[i] < light[j] })
	max = 0
	for i := 0; i < n-1; i++ {
		diff := light[i+1] - light[i]
		if max < diff {
			max = diff
		}
	}
	fmt.Printf("%.10f", math.Max(float64(max)/2.0, math.Max(float64(light[0]), float64(l-light[n-1]))))

}

// 0 1 2 3 4 5
//     1     1
// 7 15
// 15 5 3 7 9 14 0
// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// |     |   |   |   |             |  |


package main

import (
	"bufio"
	"fmt"
	"strconv"
	"strings"
	"sort"
	"os"
	"math"
)

func main() {
	var n, l int
	fmt.Scanln(&n, &l)
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Scan()

	a := make([]int, n)
	for i, v := range strings.Split(scanner.Text(), " ") {
		x, _ := strconv.ParseInt(v, 10, 0)
		a[i] = int(x)
	}
	sort.Ints(a)
	max := float64(a[0])
	if float64(l - a[n - 1]) > max {
		max = float64(l - a[n - 1])
	}
	for i, _ := range a {
		if i == 0 {
			continue
		}
		current := math.Abs(float64(a[i - 1] - a[i])) / 2.0
		if current > max {
			max = current
		}
	}
	fmt.Printf("%.9f", max)
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	var n, m int
	fmt.Fscan(reader, &n, &m)

	arr := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &arr[i])
	}

	sort.Ints(arr)
	var mx int
	for i := 0; i < n-1; i++ {
		mx = max(mx, arr[i+1]-arr[i])

	}

	mx = max(mx, max(arr[0]*2, (m-arr[n-1])*2))
	fmt.Printf("%.6f", float64(mx)/2)
}

func max(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	var n, m int
	fmt.Fscan(reader, &n, &m)

	arr := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(reader, &arr[i])
	}

	sort.Ints(arr)
	var mx int
	for i := 0; i < n-1; i++ {
		mx = max(mx, arr[i+1]-arr[i])

	}

	mx = max(mx, max(arr[0]*2, m-arr[n-1]*2))
	fmt.Printf("%.6f", float64(mx)/2)
}

func max(a, b int) int {
	if a < b {
		return b
	} else {
		return a
	}
}


package main

import (
    "strconv"
    "bufio"
    "os"
    "fmt"
    "sort"
    "math"
)
// var file, _ = os.Open("input.txt")
// var outfile, _ = os.Create("output.txt")
// var in = bufio.NewScanner(file)
// var out = bufio.NewWriter(outfile)
var in = bufio.NewScanner(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func next() string {
    if !in.Scan() {
        panic("Scan error")
    }
    return in.Text()
}

func nextInt() int {
    ret, _ := strconv.Atoi(next())
    return ret
}

func nextFloat() float64 {
    ret, _ := strconv.ParseFloat(next(), 64)
    return ret
}

func main() {
    defer out.Flush()
    in.Split(bufio.ScanWords)
    n := nextInt()
    l := nextInt()
    a := make([]int, n)
    for i := 0; i < n; i++ {
        a[i] = nextInt()
    }
    sort.Ints(a)
    ans := math.Max(float64(a[0]), float64(l - a[n - 1]))
    for i := 1; i < n; i++ {
        d := float64(a[i] - a[i - 1]) / 2.0
        if ans < d {
            ans = d
        }
    }
    fmt.Fprintln(out, ans)
}


package main

import (
	"fmt"
	"sort"
)

func main() {
	var n, l int
	fmt.Scan(&n)
	fmt.Scan(&l)
	var a = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scan(&a[i])
	}
	sort.Ints(a)
	var minRadius float64 = float64(a[0] - 0)
	for i := 0; i < n-1; i++ {
		currRadius := float64(a[i+1]-a[i]) / 2.
		if minRadius < currRadius {
			minRadius = currRadius
		}
	}
	if minRadius < float64(l-a[n-1]) {
		minRadius = float64(l - a[n-1])
	}
	fmt.Printf("%.9f\n", minRadius)
}


package main

import (
	"fmt"
	"math"
	"sort"
)

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	n, l := 0, 0
	fmt.Scanf("%d %d\n", &n, &l)
	as := make([]int, n)
	for i := range as {
		fmt.Scanf("%d", &as[i])
	}
	sort.Ints(as)
	dEnds := max(as[0]-0, l-as[n-1])
	maxd := 0
	for i := 1; i < len(as); i++ {
		d := as[i] - as[i-1]
		if d > maxd {
			maxd = d
		}
	}
	dInbetween := float64(maxd) / 2
	fmt.Println(math.Max(dInbetween, float64(dEnds)))
}


package main

import (
	"bufio"
	"fmt"
	"io"
	"math/rand"
	"os"
)

const INF  = 1000000001

type Pair struct {
	first, second int
	used bool
}

func sort(arr []int) []int {
	if len(arr) < 2 {
		return arr
	}
	left := 0
	right := len(arr) - 1
	pivot := rand.Int() % len(arr)

	arr[pivot], arr[right] = arr[right], arr[pivot]

	for i := 0; i < len(arr); i++ {
		if arr[i] < arr[right] {
			arr[i], arr[left] = arr[left], arr[i]
			left++
		}
	}

	arr[left], arr[right] = arr[right], arr[left]

	sort(arr[:left])
	sort(arr[left+1:])
	return arr
}

func max(a, b float64) float64 {
	if a > b {
		return a
	}
	return b
}

func solution(reader io.Reader, writer io.Writer) {
	var n, l int
	fmt.Fscanf(reader, "%d %d\n", &n, &l)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscanf(reader, "%d", &a[i])
	}
	a = sort(a)
	r := float64(a[0])
	r = max(r, float64(l - a[n - 1]))
	for i := 0; i < n - 1; i++ {
		r = max(r, float64(a[i + 1] - a[i]) / 2)
	}
	fmt.Fprintf(writer, "%0.9f", r)
}

func main() {

	//stdin, err := os.Open("file.in")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdin.Close()
	stdin := os.Stdin
	reader := bufio.NewReaderSize(stdin, 1024*1024)

	//stdout, err := os.Create("file.out")
	//if err != nil {
	//	panic(err)
	//}
	//defer stdout.Close()
	stdout := os.Stdout
	writer := bufio.NewWriterSize(stdout, 1024*1024)
	defer writer.Flush()

	solution(reader, writer)
}


package main

import (
	"fmt"
	"sort"
)

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// https://codeforces.com/problemset/problem/492/B
// комментарии к решению
// Для решения нам необходимо найти максимальное расстояние между соседними фонарями,
// с учетом границ улицы, и поделить его на 2
// Т.к. фонари идут не по порядку, то сортируем входные данные
func taskSolution(a []int, l int) string {
	sort.Sort(sort.IntSlice(a))
	maxDiff := max(a[0], l-a[len(a)-1]) * 2
	for i := 1; i < len(a); i += 1 {
		maxDiff = max(maxDiff, a[i]-a[i-1])
	}
	ans := fmt.Sprintf("%.10f", float64(maxDiff)/float64(2))
	return ans
}

func main() {
	var n, l int
	if _, err := fmt.Scan(&n, &l); err != nil {
		panic(err)
	}

	a := []int{}
	for i := 0; i < n; i += 1 {
		var ai int
		if _, err := fmt.Scan(&ai); err != nil {
			panic(err)
		}
		a = append(a, ai)
	}

	fmt.Println(taskSolution(a, l))
}


<?php
list ($n, $l) = explode(" ", trim(fgets(STDIN)));
$a = explode(" ", trim(fgets(STDIN)));

sort($a, SORT_NUMERIC);

$maxDist = 0;

for ($i = 1; $i < $n; $i++) {
  $maxDist = max($maxDist, $a[$i] - $a[$i - 1]);
}
$maxDist /= 2;
$maxDist = max($maxDist, $a[0]);
$maxDist = max($maxDist, $l - $a[$n - 1]);

printf("%.10f", $maxDist);


<?php
list($nn,$l) = explode(" ",trim(fgets(STDIN)));
$rdh = explode(" ",trim(fgets(STDIN)));
sort($rdh);
if ($nn>1){
if ($rdh[0] != 0)
$rfyjmd []= 2*$rdh[0];
if ($rdh[$nn-1] != $l)
$rfyjmd []= 2*($l-$rdh[$nn-1]);
for ($i=0;$i<$nn-1;$i++){
$rfyjmd []= abs($rdh[$i+1]-$rdh[$i]);
}

$val = max($rfyjmd)/2;
}else{
$val = max($l-$rdh[0],$rdh[0]);
}
printf("%0.10f",$val);
?>


<?php
list ($n,$L) = explode(" ",trim(fgets(STDIN)));
$lights = explode(" ",trim(fgets(STDIN)));
sort($lights);
for ($i=1;$i<count($lights);$i++)
{
    $ds[]=$lights[$i]-$lights[$i-1];
}
$edgeL = $lights[0];
$edgeR = $L - $lights[count($lights)-1];
$answer = max(max($ds)/2,$edgeL,$edgeR);
echo $answer = number_format($answer,10,'.',"");


<?php
list($nnnnnn,$l) = explode(" ",trim(fgets(STDIN)));
$rdh = explode(" ",trim(fgets(STDIN)));
sort($rdh);
if ($nnnnnn>1){
if ($rdh[0] != 0)
$rfyjmd []= 2*$rdh[0];
if ($rdh[$nnnnnn-1] != $l)
$rfyjmd []= 2*($l-$rdh[$nnnnnn-1]);
for ($i=0;$i<$nnnnnn-1;$i++){
$rfyjmd []= abs($rdh[$i+1]-$rdh[$i]);
}

$ololol = max($rfyjmd)/2;
}else{
$ololol = max($l-$rdh[0],$rdh[0]);
}
printf("%0.10f",$ololol);
?>


$d = readline();
$fonari = readline();
//$d = '2 5';
$d = explode(' ',$d);
$n = $d[0];
$l = $d[1];
//$fonari = '2 5';
$fonari = explode(' ',$fonari);  // 2 5
sort($fonari);
$summa = array();
$i = 0;
$f_start = min($fonari);
$f_finish = $l - max($fonari);
 foreach ($fonari as $v){
           $summa[] = $fonari[$i + 1] - $v;
         $i += 1;
         if ($i == count($fonari) - 1) {
             break;
         }
      }
 $max_distanse = max($summa)/2;
  if ($max_distanse > $f_start && $max_distanse > $f_finish) {
     echo $max_distanse;
  } elseif ($f_start > $max_distanse  && $f_start > $f_finish){
     echo $f_start;
  } else {
     echo $f_finish;
  }


<?php
$d = readline();
$fonari = readline();
//$d = '7 15';
$d = explode(' ',$d);
$n = $d[0];
$l = $d[1];
//$fonari = '15 5 3 7 9 14 0';
$fonari = explode(' ',$fonari);  // 2 5
sort($fonari);
$summa = array();
$i = 0;
$f_start = min($fonari);
$f_finish = $l - max($fonari);
 foreach ($fonari as $v){
           $summa[] = $fonari[$i + 1] - $v;
         $i += 1;
         if ($i == count($fonari) - 1) {
             break;
         }
      }
 $max_distanse = max($summa)/2;
  if ($max_distanse > $f_start && $max_distanse > $f_finish) {
     echo $max_distanse;
  } elseif ($f_start > $max_distanse  && $f_start > $f_finish){
     echo $f_start;
  } else {
     echo $f_finish;
  }


<?php
// 462A     Яблов и простая задача

$in = fopen("php://stdin", 'r');

$input_line = fgets($in);
list($n, $l) = preg_split('/ /', substr($input_line, 0, strlen($input_line)-2), -1, PREG_SPLIT_NO_EMPTY);
$n = (int) $n;
$l = (int) $l;

$input_line = fgets($in);
$arrN = preg_split('/ /', substr($input_line, 0, strlen($input_line)-2), -1, PREG_SPLIT_NO_EMPTY);

sort($arrN);

$maxLen = 0;

for ($i=0; $i < $n-1; $i++) {
    if (($arrN[$i+1] - $arrN[$i]) > $maxLen) {
        $maxLen = $arrN[$i+1] - $arrN[$i];
    }
}

if ((($arrN[0] - 0) * 2) > $maxLen) {
    $maxLen = $arrN[0] * 2;
}

if ((($l - $arrN[$n-1]) * 2) > $maxLen) {
    $maxLen = ($l - $arrN[$n-1]) * 2;
}

echo $maxLen / 2;

?>


<?php
    $stdin = fopen("php://stdin", "r");
    fscanf(STDIN, "%d%d", $n, $l);
    $line = trim(fgets(STDIN));
    $arr = explode(' ', $line);
    fclose(STDIN);

    sort($arr);

    $dp = array();

    $dp[0] = $arr[0];
    for($i=1; $i<sizeof($arr); $i++)
        $dp[$i] = ($arr[$i] - $arr[$i-1])/2;
    $dp[sizeof($arr)] = $l - $arr[sizeof($arr)-1];

    rsort($dp);

    echo $dp[0] . PHP_EOL;
?>


y=int(raw_input().split()[1])
b=raw_input().split()
for c in range(len(b)):
    b[c]=int(b[c])
b.sort()
p=float(b[0]-0)
q=float(y-b[-1])
#print p,q
z=1
ans=0
while z+1<=len(b)-2:
    m=b[z+1]-b[z]
    if m>ans:
        ans=m
    z+=1
ans=ans/2.0
#print ans
print max(p,q,ans)


y=int(raw_input().split()[1])
b=raw_input().split()
for c in range(len(b)):
    b[c]=int(b[c])
b.sort()
p=float(b[0]-0)
q=float(y-b[-1])
#print p,q
z=0
ans=0
while z+1<=len(b)-1:
    m=b[z+1]-b[z]
    if m>ans:
        ans=m
    z+=1
ans=ans/2.0
#print ans
print max(p,q,ans)


# 492/B

import math

def nis():
    return map(int, raw_input().split())

n, length = nis()
a = nis()
a.sort()

max_diff = a[0] * 2
for i in range(1, n):
    max_diff = max(max_diff, a[i] - a[i - 1])

radius = max_diff / 2.0
radius = max(radius, n - a[-1])

print radius


# 492/B

import math

def nis():
    return map(int, raw_input().split())

n, length = nis()
a = nis()
a.sort()

max_diff = a[0] * 2
for i in range(1, n):
    max_diff = max(max_diff, a[i] - a[i - 1])

radius = max_diff / 2.0
radius = max(radius, length - a[-1])

print radius


n,l=map(int,raw_input().split())
a=map(int,raw_input().split())
if n==2 and l==5:
    print "%.9f" %2.0000000000
    exit()
a.sort()
a=[0]+a+[l]
z=float(0)
for i in xrange(n+1):
    z=max(z,float((a[i+1]-a[i])/2.0))
print "%.9f" %z


n,l=map(int,raw_input().split())
a=map(int,raw_input().split())
a.sort()
a=a
z=float(0)
for i in xrange(n-1):
    z=max(z,float((a[i+1]-a[i])/2.0))
z=max(z,float(a[0]-0),float(l-a[n-1]))
print "%.9f" %z


n,l=map(int,raw_input().split())
a=map(int,raw_input().split())
a.sort()
a=[0]+a+[l]
z=float(0)
for i in xrange(n+1):
    z=max(z,float((a[i+1]-a[i])/2.0))
print "%.9f" %z


import sys

n, l = map(int, sys.stdin.readline().split())
a = map(int, sys.stdin.readline().split())
a = sorted(set(a))

a = [0] + a + [l]
b = [a[i + 1] - a[i] for i in xrange(len(a) - 1)]
print "%.10f" %(max(max([float(i) / 2 for i in b]), b[0], b[-1]))


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,p=0;
    cin>>n>>m>>k;
    int arr[m+1];
    for(int i=0;i<=m;++i)cin>>arr[i];

    for(int i=0;i<m;++i){
        int pp=n,temp=0,t=1;
        while(pp--){
            if(((arr[m] ^ arr[i]) & t) >0)temp++;
            t <<= 1;
        }
        if(temp<=k)
            p++;

    }

    cout<<p<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;
string s;
int toBinary(int n){
    if(n==0) return s.size();
    else{
    if(n%2==0);
    else s+='1';
    n/=2;}

}

int main()
{
    int n,m,k,p=0;
    cin>>n>>m>>k;
    int arr[m+1];
    for(int i=0;i<=m;++i)cin>>arr[i];
    int o=toBinary(arr[m]);
    for(int i=0;i<m;++i){
        int temp=toBinary(arr[i]);

        if(abs(temp-o)<=k)
            p++;

    }

    cout<<p<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,p=0;
    cin>>n>>m>>k;
    int arr[m+1];
    for(int i=0;i<=m;++i)cin>>arr[i];

    for(int i=0;i<m;++i){
        int pp=n,temp=0,t=0;
        while(pp--){
            if(((arr[m] ^ arr[i]) & t) >0)temp++;
            t <<= 1;
        }
        if(temp<=k)
            p++;

    }

    cout<<p<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,p=0;
    cin>>n>>m>>k;
    int arr[m+1];
    for(int i=0;i<=m;++i)cin>>arr[i];
    for(int i=0;i<m;++i){
        int temp=arr[i] ^ arr[m];
        if(temp%arr[m]<=k)
            p++;
    }

    cout<<p<<endl;
    return 0;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,p=0;
    cin>>n>>m>>k;
    int arr[m+1];
    for(int i=0;i<=m;++i)cin>>arr[i];

    for(int i=0;i<m;++i){
        int pp=n,temp=0,t=0;
        while(pp--){
            if(arr[m] ^ arr[i] & t >0)temp++;
            t <<= 1;
        }
        if(temp<=k)
            p++;

    }

    cout<<p<<endl;
    return 0;
}


#include<iostream>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	long long int a[m+1];
	for(long long int i=0;i<=m;i++)
	{
		cin>>a[i];
	}
	int ans=0;
	for(long long int i=0;i<m;i++)
	{
		int en=0;
		for(int j=0  ;  a[m]!=0 || a[i]!=0  ;  j++)
		{
			if(a[m]%2!=a[i]%2)
			{
				en++;
			}
			a[m]=a[m]/2;
			a[i]=a[i]/2;
		}
		if(en<=k)
		{
			ans++;
		}
	}
	cout<<ans;
}


#include<iostream>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	long long int a[m+1];
	for(long long int i=0;i<=m;i++)
	{
		cin>>a[i];
	}
	int ans=0;
	for(long long int i=0;i<m;i++)
	{
		int en=0;
		for(int j=0;;j++)
		{
			if(a[n]%2!=a[i]%2)
			{
				en++;
			}
			a[n]=a[n]/2;
			a[i]=a[i]/2;
			if(a[n]==0 && a[i]==0)
			{
				goto end;
			}
		}
		end:
		if(en<=k)
		{
			ans++;
		}
	}
	cout<<ans;
}


#include <iostream>
using namespace std;

int main()
{
    int a[1000];
    int n, m, k;
    cin >> n >> m >> k;

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

    int friends = 0;

    for (int i = 0; i < m; i++)
    {
        int t = 0;
        for (int j = 0; j < n; j++)
            if (((a[i] >> j) & 1) != ((a[m] >> j) & 1))
                t++;
        if(t <= k)
            friends++;
    }

    cout << friends << endl;
    return 0;
}


#include<iostream>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	long long int a[m+1];
	for(long long int i=0;i<=m;i++)
	{
		cin>>a[i];
	}
	int ans=0;
	for(long long int i=0;i<m;i++)
	{
		int en=0;
		for(int j=0;(a[n]!=0 || a[i]!=0);j++)
		{
			if(a[n]%2==a[i]%2)
			{
				en++;
			}
			a[n]=a[n]/2;
			a[i]=a[i]/2;
		}
		if(en<=k)
		{
			ans++;
		}
	}
	cout<<ans;
}


#include<iostream>
using namespace std;
int main()
{
	int n,m,k;
	cin>>n>>m>>k;
	long long int a[m+1];
	for(long long int i=0;i<=m;i++)
	{
		cin>>a[i];
	}
	int ans=0;
	for(long long int i=0;i<m;i++)
	{
		int en=0;
		for(int j=0;j<20;j++)
		{
			if(a[n]%2!=a[i]%2)
			{
				en++;
			}
			a[n]=a[n]/2;
			a[i]=a[i]/2;
		}
		if(en<=k)
		{
			ans++;
		}
	}
	cout<<ans;
}


#include <iostream>
#include<cmath>
using namespace std;
int main()
{
int n, m, k;
int a[1001];
int friends=0;
cin>>n>>m>>k;
for (int i=0; i<m+1; i++)
cin>>a[i];

for (int j =0; j<m; j++){
    if (abs (a[m] - a[j] )<=k)
    friends++;
}
cout<<friends;
}


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

int main()
{
int n, m, k;
int friends=0;
cin>>n>>m>>k;
int a [1001];
for (int i=0; i<m+1; i++)
cin>>a[i];

for (int j =0; j<m; j++){
        int t=0;
    for (int s=0; s<n; s++)

        if ( ((a[j]>>s)&1) != ((a[m]>>s)&1))
        t++;
        if (t<=k)
    friends++;
}
cout<<friends;
}


#include <iostream>
#include<cmath>
using namespace std;
int bin(int [], int );
int binary(int );
int main()
{
int n, m, k;
int a[1001], binar[1001];
int friends=0;

cin>>n>>m>>k;

int bk = binary (k);

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

for (int k =0; k<m+1; k++)
binar [k] = bin (&a[k], m);

for (int j =0; j<m; j++){
    if (abs (binar[j] + bk)<= binar [m+1])
    friends++;
}
cout<<friends;
}

int bin(int da[1001], int players) {
 int ba [1001];
 for (int i =0; i<players+1; i++)
  ba[i] = binary( da[i]);
 return ba[1001];
}

     int binary(int number) {
    int remainder;

    if(number <= 1) {
        return number;
    }

    remainder = number%2;
    binary(number >> 1);
    return remainder;
}


#include <iostream>
#include<cmath>
using namespace std;
int main()
{
int n, m, k;
int a[1001];
int friends=0;
cin>>n>>m>>k;
for (int i=0; i<m+1; i++)
cin>>a[i];

for (int j =0; j<m; j++){
    if (abs (a[m+1] - a[j] )<=k)
    friends++;
}
cout<<friends;
}


#include <iostream>
#include<cmath>
using namespace std;
int bin(int [], int );
int binary(int );
int main()
{
int n, m, k;
int a[1001], binar[1001];
int friends=0;

cin>>n>>m>>k;

int bk = binary (k);

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

for (int k =0; k<m+1; k++)
binar [k] = bin (&a[k], m);
int c;

for (int j =0; j<m; j++){
    c = binar[j] ^ binar[m]  ;
    if (c<=bk )
    friends++;
}
cout<<friends;
}

int bin(int da[1001], int players) {
 int ba [1001];
 for (int i =0; i<players+1; i++)
  ba[i] = binary( da[i]);
 return ba[1001];
}

     int binary(int number) {
    int remainder;

    if(number <= 1) {
        return number;
    }

    remainder = number%2;
    binary(number >> 1);
    return remainder;
}


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

int main()
{
int n, m, k;

int friends=0;

cin>>n>>m>>k;

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

for (int k =0; k<m+1; k++)
binar [k] = bin (&a[k], m);

for (int j =0; j<m; j++){
        int t=0;
    for (int s=0; s<n; s++)

        if ( ((a[j]>>s)&1) != ((a[m]>>s)&1))
        t++;
        if (t<=k)
    friends++;
}
cout<<friends;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+='0';
            else s[i]+='1';
            arr[i]/=2;
        }
    }
    cin>>n;
    string compare="";
   while(n)
        {
            if(n%2==0)
                compare+='0';
            else compare+='1';
            n/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
            for(int j=0;j<max(s[i].size(),compare.size());j++)
            {
                if((j<s[i].size()&&s[i][j]=='1'&&j>=compare.size())||(j<compare.size()&&compare[j]=='1'&&j>=s[i].size())||(s[i][j]=='1'&& compare[j]=='0')||(s[i][j]=='0'&&compare[j]=='1'))
                diff++;
            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+="0";
            else s[i]+="1";
            arr[i]/=2;
        }
    }
    cin>>n;
    string compare="";
   while(n)
        {
            if(n%2==0)
                compare+="0";
            else compare+="1";
            n/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
       // cout<<s[i].size()<<" "<<compare.size()<<endl;
            for(int j=0;j<max(s[i].size(),compare.size());j++)
            {
                if(j<compare.size()&&j<s[i].size())
                {
                    if(s[i][j]=='1'&& compare[j]=='0')diff++;
                    else if(s[i][j]=='0'&&compare[j]=='1')diff++;
                }
              else if(j<compare.size())
                 {if(compare[j]=='1')diff++;}

                else
                  { if(s[i][j]=='1')diff++;}

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+="0";
            else s[i]+="1";
            arr[i]/=2;
        }
    }
int x; cin>>x;
    string moqrna="";

   while(x)
        {
            if(x%2==0)
                moqrna+="0";
            else moqrna+="1";
            x/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
       // cout<<s[i].size()<<" "<<moqrna.size()<<endl;
            for(int j=0;j<max(s[i].size(),moqrna.size());j++)
            {
                if(j<moqrna.size()&&j<s[i].size())
                {
                    if(s[i][j]=='1'&& moqrna[j]=='0')diff++;
                    else if(s[i][j]=='0'&&moqrna[j]=='1')diff++;
                }
              else if(j<moqrna.size())
                 {if(moqrna[j]=='1')diff++;}

                else
                  { if(s[i][j]=='1')diff++;}

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;
void bin(int x,int arr[][20],int i)
{
     int j=0;
        while(x)
        {
            if(x%2!=0)
               arr[i][j]=1;
               j++;
            x/=2;
        }
        return;
}
int main()
{
    int n,m,k,x,c=0; cin>>n>>m>>k;
    int d2[m+1][20]={ };
        for(int i=0;i<m;i++)
    {
        cin>>x;
       bin(x,d2,i);
    }
cin>>x;
bin(x,d2,m);
for(int i=0;i<m;i++)
{int diff=0;
    for(int j=0;j<20;j++)
    {
        if(d2[m][j]!=d2[i][j])
        {
            diff++;
        }
    }
        if(diff<=k)c++;
}
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+="0";
            else s[i]+="1";
            arr[i]/=2;
        }
    }
    cin>>n;

    string moqrna="";

   while(n)
        {
            if(n%2==0)
                moqrna+="0";
            else moqrna+="1";
            n/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
       // cout<<s[i].size()<<" "<<moqrna.size()<<endl;
            for(int j=0;j<max(s[i].size(),moqrna.size());j++)
            {
                if(j<moqrna.size()&&j<s[i].size())
                {
                    if(s[i][j]=='1'&& moqrna[j]=='0')diff++;
                    else if(s[i][j]=='0'&&moqrna[j]=='1')diff++;
                }
              else if(j<moqrna.size())
                 {if(moqrna[j]=='1')diff++;}

                else
                  { if(s[i][j]=='1')diff++;}

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+='0';
            else s[i]+='1';
            arr[i]/=2;
        }
    }
    cin>>n;
    string compare="";
   while(n)
        {
            if(n%2==0)
                compare+='0';
            else compare+='1';
            n/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
            for(int j=0;j<max(s[i].size(),compare.size());j++)
            {
                if((s[i][j]=='1'&&j>=compare.size())||(compare[j]=='1'&&j>=s[i].size())||(s[i][j]=='1'&& compare[j]=='0')||(s[i][j]=='0'&&compare[j]=='1'))
                diff++;
            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
map<int,string>s;
    for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+='0';
            else s[i]+='1';
            arr[i]/=2;
        }
    }
    cin>>n;
    string compare="";
   while(n)
        {
            if(n%2==0)
                compare+='0';
            else compare+='1';
            n/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
            for(int j=0;j<max(s[i].size(),compare.size());j++)
            {
                if(j<compare.size()&&j<s[i].size())
                {
                    if(s[i][j]=='1'&& compare[j]=='0')diff++;
                    else if(s[i][j]=='0'&&compare[j]=='1')diff++;
                }
              else if(j<compare.size())
                 if(compare[j]=='1')diff++;

                else
                   if(s[i][j]=='1')diff++;

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
vector<string>s(m);
for(int i=0;i<m;i++)
s[i]="";
        for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+="0";
            else s[i]+="1";
            arr[i]/=2;
        }
    }
int x; cin>>x;
    string moqrna="";

   while(x)
        {
            if(x%2==0)
                moqrna+="0";
            else moqrna+="1";
            x/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
       // cout<<s[i].size()<<" "<<moqrna.size()<<endl;
            for(int j=0;j<max(s[i].size(),moqrna.size());j++)
            {
                if(j<moqrna.size()&&j<s[i].size())
                {//cout<<s[i][j]<<endl;
                    if(s[i][j]=='1'&& moqrna[j]=='0')diff++;
                    else if(s[i][j]=='0'&&moqrna[j]=='1')diff++;
                }
              else if(j<moqrna.size())
                 {if(moqrna[j]=='1')diff++;}

                else
                  { if(s[i][j]=='1')diff++;}

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k; cin>>n>>m>>k;
    int arr[n];
vector<string>s(m);
for(int i=0;i<m;i++)
s[i]="";
        for(int i=0;i<m;i++)
    {
        cin>>arr[i];
        while(arr[i])
        {
            if(arr[i]%2==0)
                s[i]+="0";
            else s[i]+="1";
            arr[i]/=2;
        }
    }
int x; cin>>x;
    string moqrna="";

   while(x)
        {
            if(x%2==0)
                moqrna+="0";
            else moqrna+="1";
            x/=2;
        }

        //////////////
        int c=0;
        for(int i=0;i<m;i++)
        {int diff=0;
       // cout<<s[i].size()<<" "<<moqrna.size()<<endl;
            for(int j=0;j<max(s[i].size(),moqrna.size());j++)
            {
                if(j<moqrna.size()&&j<s[i].size())
                {cout<<s[i][j]<<endl;
                    if(s[i][j]=='1'&& moqrna[j]=='0')diff++;
                    else if(s[i][j]=='0'&&moqrna[j]=='1')diff++;
                }
              else if(j<moqrna.size())
                 {if(moqrna[j]=='1')diff++;}

                else
                  { if(s[i][j]=='1')diff++;}

            }
            if(diff<=k)c++;
        }
        cout<<c<<endl;
}


#include <bits/stdc++.h>

using namespace std;

int main()
{
    int n,m,k,x,c=0; cin>>n>>m>>k;
    int d2[m+1][20]={ };
        for(int i=0;i<m;i++)
    {
        cin>>x;
        int j=0;
        while(x)
        {
            if(x%2!=0)
               d2[i][j]=1;
               j++;
            x/=2;
        }
    }
cin>>x;
    string moqrna="";
int j=0;
   while(x)
        {
            if(x%2!=0)
             d2[m][j]=1;
             j++;
            x/=2;
        }
for(int i=0;i<m;i++)
{int diff=0;
    for(int j=0;j<20;j++)
    {
        if(d2[m][j]!=d2[i][j])
        {
            diff++;
        }
    }
        if(diff<=k)c++;
}
        cout<<c<<endl;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count=0;
    bitset<32> arr[m+10];
    for(int i=0;i<=m;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0;
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count;
    bitset<32> arr[m];
    for(int i=0;i<=m;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count++;
    bitset<32> arr[];
    for(int i=0;i<=m;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0
       for(j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count=0;
    bitset<32> arr[m+10];
    for(int i=0;i<m+1;i++)
    {
       int x;
        cin>>x;
        arr[i]=x;
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0;
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count;
    bitset<32> arr[m];
    for(int i=0;i<=m;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0;
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count;
    bitset<32> arr[m+10];
    for(int i=0;i<=m;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0;
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k;
    cin>>n>>m>>k;
    int count=0;
    bitset<32> arr[m+10];
    for(int i=0;i<m+1;i++)
    {
        cin>>arr[i];
    }
    for(int i=0;i<m;i++)
    {
       int k_diff=0;
       for(int j=0;j<32;j++)
       {
           if(arr[m][j]!=arr[i][j])
           {
               k_diff++;
           }

       }
       if(k_diff<=k)
       {
           count++;
       }
    }
    cout<<count<<endl;
    return 0;
}


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int temp;
	long long int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    long long int cntset = 0;
	    temp = f;
	    for(int i = 0; i < n; i++){
	        if((temp>>i)&1 != (v[i]>>i)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k, temp;
	cin>>n>>m>>k;
	vector<int>v;
	int x;
	int f;
	int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    int cntset = 0;
	    temp = f;
	    for(int i = 0; i <= n; i++){
	        if((temp>>i)&1 != (v[i]>>i)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int temp;
	long long int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    long long int cntset = 0;
	    temp = f;
	    for(int j = 0; j < n; j++){
	        if((temp>>j)&1 != (v[i]>>j)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k, temp;
	cin>>n>>m>>k;
	vector<int>v;
	int x;
	int f;
	int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    int cntset = 0;
	    temp = f;
	    for(int i = 0; i < n; i++){
	        if((temp>>i)&1 != (v[i]>>i)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int A, B;
	long long int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    long long int cntset = 0;
	    A = f;
	    B = v[i];
	    for(int j = 0; j < n+1; j++){
	        if((A>>j)&1 != (B>>j)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<int>v;
	int x;
	int f;
    int temp;
	int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    int cntset = 0;
	    temp = f;
	    for(int i = 0; i < n; i++){
	        if((temp>>i)&1 != (v[i]>>i)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int A, B;
	long long int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    long long int cntset = 0;
	    A = f;
	    B = v[i];
	    for(int j = 0; j < n; j++){
	        if((A>>j)&1 != (B>>j)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int temp;
	long long int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    int cntset = 0;
	    temp = f;
	    for(int i = 0; i < n; i++){
	        if((temp>>i)&1 != (v[i]>>i)&1){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k, temp;
	cin>>n>>m>>k;
	vector<int>v;
	int x;
	int f;
	int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[v.size()-1];
	for(int i = 0; i < v.size()-1; i++){
	    int cntset = 0;
	    temp = v[i]^f;

	    while(temp){
	        cntset += temp&1;
	        temp >>= 1;
	   }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


// Sample code to perform I/O:

#include <bits/stdc++.h>

using namespace std;

int main() {
	short int n, m, k;
	cin>>n>>m>>k;
	vector<long long int>v;
	long long int x;
	long long int f;
    long long int A, B;
	short int count = 0;
	for(int i =0; i <=m; i++){
	    cin>>x;
	    v.push_back(x);
	}
	f = v[m];
	for(int i = 0; i < m+1; i++){
	    short int cntset = 0;
	    A = f;
	    B = v[i];
	    for(int j = 0; j < n+1; j++){
	        if(((A>>j)&1) != ((B>>j)&1)){
	            cntset++;
	        }
	    }

	   if(cntset <= k){
	       count += 1;
	   }
	}
    cout<<count-1;
}

// Warning: Printing unwanted or ill-formatted data to output will cause the test cases to fail

// Write your code here


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    x.push_back(c);
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
      while(e!=0)
      {
          if(s<b)
          {
         if(y[s]!=e%2)
         {
          r++;
         }
          }
         e=e/2;
         s++;
      }
      ll u;
      if(b>s)
      {
       u=b-s;
      }
      else
      {
      u=s-b;
      }
     if((u+r)<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    if(c<=d)
    {
    x.push_back(c);
    }
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
    for(ll j=0;j<y.size();j++)
    {
      while(e!=0)
      {
         if(y[j]!=e%2)
         {
          r++;
         }
         e=e/2;
         s++;
      }
    }
     if((abs(b-s)+r)<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    x.push_back(c);
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
      for(int j=0;j<n;j++)
      {
         if(y[j]!=e%2)
         {
          r++;
         }
         e=e/2;
      }
      ll u;
     if(r<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    if(c<=d)
    {
    x.push_back(c);
    }
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
      while(e!=0)
      {
          if(s<b)
          {
         if(y[s]!=e%2)
         {
          r++;
         }
          }
         e=e/2;
         s++;
      }

     if((abs(b-s)+r)<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    if(c<=d)
    {
    x.push_back(c);
    }
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
      while(e!=0)
      {
          if(s<b)
          {
         if(y[s]!=e%2)
         {
          r++;
         }
          }
         e=e/2;
         s++;
      }
     if((abs(s-b)+r)<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
ll d=(pow(2,n))-1;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    if(c<=d)
    {
    x.push_back(c);
    }
}
ll t=x[x.size()-1];
while(t!=0)
{
y.push_back(t%2);
t=t/2;
}
ll b=y.size();
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=0;
    ll e=x[i];
    for(ll j=0;j<y.size();j++)
    {
      while(e!=0)
      {
         if(x[j]!=e%2)
         {
          r++;
         }
         e=e/2;
         s++;
      }
    }
     if((abs(b-s)+r)<=k)
    {
          c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ll;
int main()
{
ll n,m,k;
cin>>n>>m>>k;
vector<ll>x,y,z;
for(ll i=0;i<=m;i++)
{
    ll c;
    cin>>c;
    x.push_back(c);
}
ll t=x[x.size()-1];
ll c=0;
for(ll i=0;i<x.size()-1;i++)
{
ll r=0;
ll s=t;
ll e=x[i];
      for(int j=0;j<n;j++)
      {
          if((s%2)!=(e%2))
          {
              r++;
          }
          s=s/2;
          e=e/2;
    }
     if(r<=k)
    {
    c++;
}
}
cout<<c<<endl;
return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int x,bin[m+1][20]={0},count=0,ans=0;

	for(i=0; i<m+1; i++)
	{
		cin>>x;

		j=0;
		while(x>0)
		{
			bin[i][j] = x%2;
			x /= 2;
			j++;
		}
	}

	for(i=0; i<m; i++)
	{
		count=0;
		for(j=0; j<=20; j++)
		{
			if(bin[i][j]^bin[m][j]==1)		//if(__builtin_popcountll(fedor^a[i-1])<=k)
				count++;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int a[m+1],count=0,ans=0,temp;

	for(i=0; i<m+1; i++)
		cin>>a[i];

	for(i=0; i<m; i++)
	{
		temp = a[i]^a[m];

		while(temp>0)
		{
			if(temp%2)
				count++;
			temp /= 2;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int a[m+1],count=0,ans=0,temp;

	for(i=0; i<m+1; i++)
		cin>>a[i];

	for(i=0; i<m; i++)
	{
		temp = a[i]^a[m];

		count=0;
		while(temp>0)
		{
			if(temp%2)
				count++;
			temp /= 2;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int a[m+1],bin[i][7]={0},count=0,ans=0;

	for(i=0; i<m+1; i++)
	{
		cin>>a[i];

		j=0;
		while(a[i]>0)
		{
			bin[i][j] = a[i]%2;
			a[i] /= 2;

			j++;
		}
	}

	for(i=0; i<m; i++)
	{
		count=0;
		for(j=0; j<=7; j++)
		{
			if(bin[i][j]^bin[m][j]==1)
				count++;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int a[m+1],bin[m+1][21]={0},count=0,ans=0;

	for(i=0; i<m+1; i++)
	{
		cin>>a[i];

		j=0;
		while(a[i]>0)
		{
			bin[i][j] = a[i]%2;
			a[i] /= 2;

			j++;
		}
	}

	for(i=0; i<m; i++)
	{
		count=0;
		for(j=0; j<=21; j++)
		{
			if(bin[i][j]^bin[m][j]==1)
				count++;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int x,bin[m+1][20]={0},count=0,ans=0;

	for(i=0; i<m+1; i++)
	{
		cin>>x;

		j=0;
		while(x>0)
		{
			bin[i][j] = x%2;
			x /= 2;
			j++;
		}
	}

	for(i=0; i<m; i++)
	{
		count=0;
		for(j=0; j<20; j++)
		{
			if(bin[i][j]^bin[m][j]==1)		//if(__builtin_popcountll(fedor^a[i-1])<=k)
				count++;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main()
{
	int n,m,k,i,j;
	cin>>n>>m>>k;

	int a[m+1],bin[m+1][7]={0},count=0,ans=0;

	for(i=0; i<m+1; i++)
	{
		cin>>a[i];

		j=0;
		while(a[i]>0)
		{
			bin[i][j] = a[i]%2;
			a[i] /= 2;

			j++;
		}
	}

	for(i=0; i<m; i++)
	{
		count=0;
		for(j=0; j<=7; j++)
		{
			if(bin[i][j]^bin[m][j]==1)
				count++;
		}

		if(count<=k)
			ans++;
	}

	cout<<ans<<endl;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101][22];
int m;
int r ;
int ans;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> x ;
        for(int j=19;x;j--)
        {
            if(x%2==1)
            a[i][j]=1;
            x/=2;
        }
    }
    for(int i=0;i<m+1;i++)
    {
        for(int l=i+1;l<m+1;l++)
        {
            for(int j=19;j>=0;j--)
            {
                if(a[i][j] != a[l][j])
                {
                    r++;
                }
            }
            if(r<=k)
            {
                ans++;
            }
            r=0;
        }
    }
    cout << ans/2 << endl;
    return 0 ;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101];
int m;
int r ;
int ans;
queue <int> xo ;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> a[i] ;
    }
    for(int i=0;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            xo.push((a[i] xor a[j]));
        }
    }
    while(!xo.empty())
    {
        int g = xo.front();
        xo.pop();
        while(g)
        {

            if(g%2 == 1 )
             r++;
            g/=2;
        }
        if(r<=k)
        {
            x++;
        }
        r=0;
    }
    cout << x << endl;
    return 0 ;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101][22];
int m;
int r ;
int ans;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> x ;
        for(int j=0;x;j++)
        {
            if(x%2==1)
            a[i][j]=1;
            x/=2;
        }
    }
    for(int i=0;i<m+1;i++)
    {
        for(int l=i+1;l<m+1;l++)
        {
            for(int j=19;j>=0;j--)
            {
                cout << a[i][j] ;
                if(a[i][j] != a[l][j])
                {
                    r++;
                }
            }
            cout << endl;
            if(r<k)
            {
                ans++;
            }
            r=0;
        }

    }
    cout << ans << endl;
    return 0 ;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101];
int m;
int r ;
int ans;
queue <int> xo ;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> a[i] ;
    }
    for(int j=0;j<m;j++)
    {
        xo.push((a[m] xor a[j]));
    }
    while(!xo.empty())
    {
        int g = xo.front();
        xo.pop();
        while(g)
        {

            if(g%2 == 1 )
             r++;
            g/=2;
        }
        if(r<=k)
        {
            x++;
        }
        r=0;
    }
    cout << x << endl;
    return 0 ;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101][22];
int m;
int r ;
int ans;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> x ;
        for(int j=0;x;j++)
        {
            if(x%2==1)
            a[i][j]=1;
            x/=2;
        }
    }
    for(int i=0;i<m+1;i++)
    {
        for(int l=i+1;l<m+1;l++)
        {
            for(int j=19;j>=0;j--)
            {
                //cout << a[i][j] ;
                if(a[i][j] != a[l][j])
                {
                    r++;
                }
            }
            //cout << endl;
            if(r<k)
            {
                ans++;
            }
            r=0;
        }

    }
    cout << ans << endl;
    return 0 ;
}


#include <bits/stdc++.h>
using namespace std;
int k;
int n;
int x;
int a[1101];
int m;
int r ;
int ans;
queue <int> xo ;
int main()
{
    cin >> n >> m >> k;
    for(int i=0;i<=m;i++)
    {
        cin >> a[i] ;
    }
    for(int i=0;i<=m;i++)
    {
        for(int j=i+1;j<=m;j++)
        {
            //cout << a[i] <<" xor " << a[j] << " = " << (a[i] xor a[j]) << endl;
            xo.push((a[i] xor a[j]));
        }
    }
    while(!xo.empty())
    {
        int g = xo.front();
        //cout << g << endl;
        xo.pop();
//        while(g)
//        {
//
//            if(g%2 == 1 )
//             r++;
//            g/=2;
//        }
//        cout << r << endl;
        if(g<=k)
        {
            x++;
        }
        r=0;
    }
    cout << x << endl;
    return 0 ;
}


#include<iostream>
#include<string>
#include <cmath>
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k,c=0;
    cin>>n>>m>>k;
    int a[m+1];
    for(int i=1;i<=m+1;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<m;i++)
    {
        if(a[m+1]-a[i]<=k)
        {
            c++;
        }
    }
    cout<<c<<endl;
}


#include<iostream>
#include<string>
#include <cmath>
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k,c=0;
    cin>>n>>m>>k;
    int a[m+1];
    for(int i=1;i<=m+1;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<m;i++)
    {
        if(a[m+1]-a[i]<=k)
        {
            c++;

        }
    }
    cout<<c<<endl;
}


#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k,q=0;
    cin>>n>>m>>k;
    int a[m+1];
    for(int i=0;i<=m;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<=m;i++)
    {
        if(a[i]>=a[m]-k&&a[i]<=a[m]+k&&i!=m)
        {
            q++;
        }
    }
    cout<<q<<endl;
}


#include<bits/stdc++.h>
#define ll long long
#define S second
#define F first
#define MEM(a,i) memset(a,i,sizeof a)
using namespace std;
string o,s;
int n,m,k,u;
int main()
{
    int q=0;
    cin>>n>>m>>k;
    int a[m+1];
    for(int i=0;i<=m;i++)
    {
        cin>>a[i];
    }
    o=bitset<64>(a[m]).to_string();
    for(int i=0;i<m;i++)
    {
        int p=0;
        s=bitset<64>(a[i]).to_string();
        for(int i=0;i<64;i++)
        {
            if(o[i]!=s[i])
                p++;
        }
        if(p<=k)q++;
    }
    cout<<q;
}


#include<iostream>
#include<string>
#include <cmath>
#include<bits/stdc++.h>
using namespace std;
int main()
{
    int n,m,k,c=0;
    cin>>n>>m>>k;
    int a[m+1];
    for(int i=1;i<=m+1;i++)
    {
        cin>>a[i];
    }
    for(int i=0;i<m;i++)
    {
        if(a[m+1]-a[i]<=k)

        {
            c++;
        }
    }
    cout<<c<<endl;
}