#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 10003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
//pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    inline int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    inline int  len2(){
    return x * x + y * y;
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pnt v1, v2;

inline bool cmp(pnt p1, pnt p2){
    return p1 * p2 > 0 || (p1 * p2 == 0 && p1.len2() < p2.len2());
    //     return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());

}

inline int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
//     for(int i = 1; i < bsz; i++)
//  b[i] = b[i] - b[0];
//     b[0] = b[0] - b[0];
    for(int i = bsz - 1; i != -1; i--)
    b[i] = b[i] - b[0];

    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 2; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

inline bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <cmath>
#include <utility>
#include <algorithm>
#define X first
#define Y second
#define DO int
#define REP(i,n) for (int i=1;i<=n;++i)
using namespace std;

pair<DO,DO> a[3030];
int n;
DO ans;

inline DO Dist(int x,int y) {
    return ((a[x].X-a[y].X)*(a[x].X-a[y].X)+(a[x].Y-a[y].Y)*(a[x].Y-a[y].Y));
    return 0;
}

int main() {
    scanf("%d",&n);
    REP(i,n)
        scanf("%d%d",&a[i].X,&a[i].Y);
    sort(a+1,a+n+1);
    REP(i,1000000) {
        int x=rand()%n+1;
        int y=rand()%n+1;
        int z=rand()%n+1;
        ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    }
    for (int x=n;x;--x)
        REP(y,x-1)
            if (Dist(x,y)>ans) REP(z,y/7)
                ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    printf("%.20lf\n",sqrt(ans)/2);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (const pnt & a){
    return pnt(x - a.x, y - a.y);
    }
    inline int operator * (const pnt & a)const{
    return x * a.y - y * a.x;
    }
    inline int len2() const{
    return x * x + y * y;
    }
    void Epr(){
    epr("x y: %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c1[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0, sz;

inline int Dist(const pnt & a, const pnt & b){
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

inline bool cmp(const pnt & p1, const pnt & p2){
    return p1 * p2 > 0 || (p1 * p2 == 0 && p1.len2() < p2.len2());
    //     return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}
bool cmpX(pnt p1, pnt p2){
    return p1.x < p2.x || (p1.x == p2.x && p1.y < p2.y);
}

void convex_full(){
    sz = 0;
    for(int i = 0; i < bsz; i++){
    if ((b[i] - b[0]) * (b[bsz - 1] - b[0]) < 0)
        continue;
    for(; sz > 1 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
//     epr("first part\n");
//     for(int i = 0; i < sz; i++)
//  c[i].Epr();
//     epr("\n");
    int cur = 0;
    for(int i = bsz - 1; i >= 0; i--){
    if ((b[i] - b[0]) * (b[bsz - 1] - b[0]) > 0)
        continue;
    for(; cur > 1 && (c1[cur - 1] - c1[cur - 2]) * (b[i] - c1[cur - 1]) <= 0; cur--);
    c1[cur++] = b[i];
    }
    for(int i = 1; i < cur - 1; i++)
    c[sz++] = c1[i];

}

inline int two_far_point(){
    convex_full();
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz + 5; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

inline bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    sort(a, a + n, cmpX);

/*
    for(int i = 0; i < n; i++)
    b[bsz++] = a[i];
    convex_full();
    for(int i = 0; i < sz; i++)
    c[i].Epr();
    return 0;
    */

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = Dist(a[i], a[j]);
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}

//  for(int i = 0; i < bsz; i++)
//  if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
//      swap(b[0], b[i]);
//     for(int i = bsz - 1; i != -1; i--)
//  b[i] = b[i] - b[0];
//
//     sort(b + 1, b + bsz, cmp);
//     int sz = 0;
//     for(int i = 0; i < bsz; i++){
//  for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
//      c[sz++] = b[i];
//     }
//


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int len2(){
    return x * x + y * y;
    }
    void Epr(){
    epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
vector < pnt > b;
pnt c[maxn];
int dist[maxn];
int n;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < (int)b.size(); i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b.begin(), b.end(), cmp);
    int sz = 0;
    for(int i = 0; i < (int)b.size(); i++){
    for(;sz > 1 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
    c[i].Epr();
   */
    for(int i = 0; i < sz * 3; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    b.clear();
//     epr("R: %d\n", r);

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b.pb(a[i]);
  /*  epr("SZ_B: %d\n", b.size());
    for(int i = 0; i < (int)b.size(); i++)
    b[i].Epr();
  */
    return two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2) / 2 << endl;

    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    inline int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    inline int  len2(){
    return x * x + y * y;
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pnt v1, v2;

inline bool cmp(pnt p1, pnt p2){
    return p1 * p2 > 0 || (p1 * p2 == 0 && p1.len2() < p2.len2());
    //     return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());

}

inline int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
//     for(int i = 1; i < bsz; i++)
//  b[i] = b[i] - b[0];
//     b[0] = b[0] - b[0];
    for(int i = bsz - 1; i; i--)
    b[i] = b[i] - b[0];

    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 2; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

inline bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
	return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
	return x * a.y - y * a.x;
    }
    int len2(){
	return x * x + y * y;
    }
    void Epr(){
	epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
vector < pnt > b;
pnt c[maxn];
int dist[maxn];
int n;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < (int)b.size(); i++)
	if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
	    swap(b[0], b[i]);
    sort(b.begin(), b.end(), cmp);
    int sz = 0;
    for(int i = 0; i < (int)b.size(); i++){
	for(;sz > 1 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
	c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
	c[i].Epr();
   */
    for(int i = 0; i < sz * 2; i++){
	ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
	v1 = c[(cur1 + 1) % sz] - c[cur1];
	v2 = c[(cur2 + 1) % sz] - c[cur2];
	if (v1 * v2 >= 0)
	    cur2 = (cur2 + 1) % sz;
	else
	    cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    b.clear();
//     epr("R: %d\n", r);

    for(int i = 0; i < n; i++)
	if ((a[v] - a[i]).len2() >= r)
	    b.pb(a[i]);
  /*  epr("SZ_B: %d\n", b.size());
    for(int i = 0; i < (int)b.size(); i++)
	b[i].Epr();
  */
    return two_far_point() >= r;
}

int main(){
    freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
	scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
	for(int j = 0; j < n; j++)
	    dist[j - i] = (a[i] - a[j]).len2();
	sort(dist, dist + n);
	int l = 0;
	int r = n;
	while(r - l > 1){
	    if (solve(i, dist[(l + r) / 2]))
		l = (l + r) / 2;
	    else
		r = (l + r) / 2;
	}
// 	epr("l: %d\n\n", l);
	ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2) / 2 << endl;

    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
	return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
	return x * a.y - y * a.x;
    }
    int len2(){
	return x * x + y * y;
    }
    void Epr(){
	epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
vector < pnt > b;
pnt c[maxn];
int dist[maxn];
int n;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < (int)b.size(); i++)
	if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
	    swap(b[0], b[i]);
    sort(b.begin(), b.end(), cmp);
    int sz = 0;
    for(int i = 0; i < (int)b.size(); i++){
	for(;sz > 1 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
	c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
	c[i].Epr();
   */
    for(int i = 0; i < sz * 2; i++){
	ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
	v1 = c[(cur1 + 1) % sz] - c[cur1];
	v2 = c[(cur2 + 1) % sz] - c[cur2];
	if (v1 * v2 >= 0)
	    cur2 = (cur2 + 1) % sz;
	else
	    cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    b.clear();
//     epr("R: %d\n", r);

    for(int i = 0; i < n; i++)
	if ((a[v] - a[i]).len2() >= r)
	    b.pb(a[i]);
  /*  epr("SZ_B: %d\n", b.size());
    for(int i = 0; i < (int)b.size(); i++)
	b[i].Epr();
  */
    return two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
	scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
	for(int j = 0; j < n; j++)
	    dist[j - i] = (a[i] - a[j]).len2();
	sort(dist, dist + n);
	int l = 0;
	int r = n;
	while(r - l > 1){
	    if (solve(i, dist[(l + r) / 2]))
		l = (l + r) / 2;
	    else
		r = (l + r) / 2;
	}
// 	epr("l: %d\n\n", l);
	ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2) / 2 << endl;

    return 0;
}


#include <cstdio>
#include <cmath>
#include <utility>
#include <algorithm>
#define X first
#define Y second
#define DO int
#define REP(i,n) for (int i=1;i<=n;++i)
using namespace std;

pair<DO,DO> a[3030];
int n;
DO ans;

inline DO Dist(int x,int y) {
    return ((a[x].X-a[y].X)*(a[x].X-a[y].X)+(a[x].Y-a[y].Y)*(a[x].Y-a[y].Y));
    return 0;
}

int main() {
    scanf("%d",&n);
    REP(i,n)
        scanf("%lf%lf",&a[i].X,&a[i].Y);
    sort(a+1,a+n+1);
    REP(i,1000000) {
        int x=rand()%n+1;
        int y=rand()%n+1;
        int z=rand()%n+1;
        ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    }
    for (int x=n;x;--x)
        REP(y,x-1)
            if (Dist(x,y)>ans) REP(z,y/7)
                ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    printf("%.20lf\n",sqrt(ans)/2);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n, m;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
//  if ((c[cur1] - c[cur2]).len2() > ans2){
//      ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
//  }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

// bool check(pnt p1, pnt p2, int r){
//     return (p1 - p2).len2() >= r;
// }

bool solve(int v, int r){
    bsz = 0;

    for(int i = v; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    long long x, y;
    pnt(){}
    pnt(long long x, long long y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    long long operator * (pnt a){
    return x * a.y - y * a.x;
    }
    long long  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
vector < pnt > b;
pnt c[maxn];
long long dist[maxn];
int n;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < (int)b.size(); i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b.begin(), b.end(), cmp);
    int sz = 0;
    for(int i = 0; i < (int)b.size(); i++){
    for(;sz > 1 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    long long ans2 = 0;
    pnt v1, v2;
  /*  for(int i = 0; i < sz; i++)
    c[i].Epr();
   */
    for(int i = 0; i < sz * 3; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
//     epr("ans2 %d\n", ans2);
    return ans2;
}

bool solve(int v, int r){
    b.clear();
//     epr("R: %d\n", r);

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b.pb(a[i]);
  /*  epr("SZ_B: %d\n", b.size());
    for(int i = 0; i < (int)b.size(); i++)
    b[i].Epr();
  */
    return two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    long long ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;

    return 0;
}


#include <cstdio>
#include <cmath>
#include <utility>
#include <algorithm>
#define X first
#define Y second
#define DO double
#define REP(i,n) for (int i=1;i<=n;++i)
using namespace std;

pair<DO,DO> a[3030];
int n;
DO ans;

inline DO Dist(int x,int y) {
    return ((a[x].X-a[y].X)*(a[x].X-a[y].X)+(a[x].Y-a[y].Y)*(a[x].Y-a[y].Y));
    return 0;
}

int main() {
    scanf("%d",&n);
    REP(i,n)
        scanf("%lf%lf",&a[i].X,&a[i].Y);
    sort(a+1,a+n+1);
    REP(i,1000000) {
        int x=rand()%n+1;
        int y=rand()%n+1;
        int z=rand()%n+1;
        ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    }

    for (int x=n;x;--x)
        REP(y,x-1)
            if (Dist(x,y)>ans) REP(z,y/7)
                ans=max(ans,min(Dist(x,y),min(Dist(x,z),Dist(y,z))));
    printf("%.20lf\n",sqrt(ans)/2);
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n, m;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz + 10; i++){
    ans2 = max(ans2, (c[cur1] - c[cur2]).len2());

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

   return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = i; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n - i);
    int l = 0;
    int r = n - i;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprlong longf(stderr, __VA_ARGS__)

const long long maxn = 10003;
const long long inf = 1e9;

struct pnt{
    long long x, y;
    pnt(){}
    pnt(long long x, long long y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    long long operator * (pnt a){
    return x * a.y - y * a.x;
    }
    long long  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
long long dist[maxn];
long long n;
long long bsz = 0;
// pair < long long, long long > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

long long two_far_point(){
    for(long long i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    long long sz = 0;
    for(long long i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    long long cur1 = 0, cur2 = 0;
    long long ans2 = 0;
    pnt v1, v2;
    for(long long i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(long long v, long long r){
    bsz = 0;

    for(long long i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    long long ans2 = 0;
//     scanf("%d", &n);
    cin >> n;
    for(long long i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(long long i = 0; i < n; i++){
    for(long long j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    long long l = 0;
    long long r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    //     epr("B %d:\n", bsz);
    sort(b + 1, b + bsz, cmp);
//     epr("E:\n");
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
        c[sz++] = b[i];
    }
//     epr("SZ_C: %d\n", sz);
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
//      ansp = mp(cur1, cur2);
    }
    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include <cstdio>
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cassert>
#include <ctime>
#include <cstdlib>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>

using namespace std;

#define fr first
#define sc second
#define mp make_pair
#define pb push_back

#define epr(...) fprintf(stderr, __VA_ARGS__)

const int maxn = 3003;
const int inf = 1e9;

struct pnt{
    int x, y;
    pnt(){}
    pnt(int x, int y): x(x), y(y){};
    pnt operator - (pnt a){
    return pnt(x - a.x, y - a.y);
    }
    int operator * (pnt a){
    return x * a.y - y * a.x;
    }
    int  len2(){
    return x * x + y * y;
    }
    void Epr(){
//  epr("x y %d %d\n", x, y);
    }
};

pnt a[maxn];
pnt b[maxn];
pnt c[maxn];
int dist[maxn];
int n;
int bsz = 0;
pair < int, int > ansp;

bool cmp(pnt p1, pnt p2){
    return (p1 - b[0]) * (p2 - b[0]) > 0 || ((p1 - b[0]) * (p2 - b[0]) == 0 && (p1 - b[0]).len2() < (p2 - b[0]).len2());
}

int two_far_point(){
    for(int i = 0; i < bsz; i++)
    if (b[i].y < b[0].y || (b[i].y == b[0].y && b[i].x < b[0].x))
        swap(b[0], b[i]);
    sort(b + 1, b + bsz, cmp);
    int sz = 0;
    for(int i = 0; i < bsz; i++){
    for(;sz >= 2 && (c[sz - 1] - c[sz - 2]) * (b[i] - c[sz - 1]) <= 0; sz--);
    c[sz++] = b[i];
    }
    int cur1 = 0, cur2 = 0;
    int ans2 = 0;
    pnt v1, v2;
    for(int i = 0; i < sz * 3; i++){
//  ans2 = max(ans2, (c[cur1] - c[cur2]).len2());
    if ((c[cur1] - c[cur2]).len2() > ans2){
        ans2 = (c[cur1] - c[cur2]).len2();
        ansp = mp(cur1, cur2);
    }

    v1 = c[(cur1 + 1) % sz] - c[cur1];
    v2 = c[(cur2 + 1) % sz] - c[cur2];
    if (v1 * v2 >= 0)
        cur2 = (cur2 + 1) % sz;
    else
        cur1 = (cur1 + 1) % sz;
    }
    return ans2;
}

bool check(pnt p1, pnt p2, int r){
    return (p1 - p2).len2() >= r;
}

bool solve(int v, int r){
    bsz = 0;

    for(int i = 0; i < n; i++)
    if ((a[v] - a[i]).len2() >= r)
        b[bsz++] = a[i];

    if (bsz == 0) return 0;
    int r1 = two_far_point();
    if (r1 >= r){
//  assert(check(c[ansp.fr], c[ansp.sc], r));
    return 1;
    }
    return 0;
   // return (bsz == 0) ? 0 : two_far_point() >= r;
}

int main(){
//     freopen("in", "r", stdin);
//     freopen("out", "w", stdout);
    int ans2 = 0;
    scanf("%d", &n);
    for(int i = 0; i < n; i++)
    cin >> a[i].x >> a[i].y;
    //  scanf("%d%d", &a[i].x, &a[i].y);

    for(int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
        dist[j - i] = (a[i] - a[j]).len2();
    sort(dist, dist + n);
    int l = 0;
    int r = n;
    while(r - l > 1){
        if (solve(i, dist[(l + r) / 2]))
        l = (l + r) / 2;
        else
        r = (l + r) / 2;
    }
//  epr("l: %d\n\n", l);
    ans2 = max(ans2, dist[l]);
    }
    cout.precision(15);
//     epr("ans2 %d\n", ans2);
    cout << fixed << sqrt(ans2 * 1.0) / 2 << endl;
//     cout << ans2 << endl;
    return 0;
}


#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int n,m,k,ans,a[100100];
int work(int x)
{
    int res=0;
    for(int i=0;i<=21;i++)
     if((x&(1<<i))^(m&(1<<i)))res++;
    return res;
}
int main()
{
    scanf("%d%d%d",&m,&n,&k);
    int x,y;
    for(int i=1;i<=n;i++)
        scanf("%d",&a[i]);
    scanf("%d",&m);
    for(int i=1;i<=n;i++)
        if(work(a[i])<=k)ans++;
    printf("%d",ans);
    return 0;
}


#include <iostream>
using namespace std;
int main (){
  int n,m,k,arr[1002],friends=0;cin>>n>>m>>k;
  for (int i=1;i<=m+1;i++) cin>>arr[i];
  for (int i=1;i<=m;i++){  int counter=0;
     for (int j=arr[i],d=arr[m+1];j!=0&&d!=0;j/=2,d/=2){
        if (d%2!=j%2)counter++;
     }
     if (counter!=1&&counter<=k)friends++;
  } cout <<friends;
}


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


//
//  main.cpp
//  RaisingBacteria
//
//  Created by Nishtha Mehrotra on 13/12/19.
//  Copyright © 2019 Nishtha Mehrotra. All rights reserved.
//

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

/*long long int func(long long int x) {
    long long int ans = 0;
    while(x) {
        if(x&1) {
            x--;
            ans++;
        }
        else {
            x = (x>>1);
        }
    }
    return ans;
}*/

int countDiffBits(int x, int y) {
    int c = 0;
    int t = x ^ y;
    while(t) {
        c += (t&1);
        t >>= 1;
    }
    return c;
}

int func2(int n, int m, int k, vector <int> a) {
    int i, ans = 0;
    for (i = 0; i < m; i++) {
        int c = countDiffBits(a[i], a[m]);
        ans += ((c > k)?0:1);
    }
    return ans;
}

int main(int argc, const char * argv[]) {
    int n, m, k, i, j;
    vector <int> a;
    cin >> n >> m >> k;
    for (i = 0; i <= m; i++) {
        cin >> j;
        a.push_back(j);
    }
    int ans = func2(n, m, k, a);
    cout << ans << endl;
    return 0;
}
//536870911
//268,435,456


#include <iostream>
#include<algorithm>
#include <string>
#include<sstream>
#include <iomanip>
#include <cmath>
#include <math.h>
#include <functional>
#include <ostream>
#include <set>
#include <iterator>
#include <vector>
#include <stack>
#include <cctype>
#include <deque>
#include <queue>
#include <map>
#include <cstdint>
#include<vector>
#include <xstring>
#include <list>
#include<unordered_map>
#include <stdio.h>

#define pi 3.14159265359;
using namespace std;
void solve(int A, int B)
{
	int count = 0;

	// since, the numbers are less than 2^31
	// run the loop from '0' to '31' only
	for (int i = 0; i < 32; i++) {

		// right shift both the numbers by 'i' and
		// check if the bit at the 0th position is different
		int k,l;
		k = (A >> i);
		l = (B >> i);
		if (((A >> i) & 1) != ((B >> i) & 1)) {
			count++;
		}
	}

	cout << "Number of different bits : " << count << endl;
}
int main()
{
	int n, m, k;
	int count = 0,counter=0;
	int arr[1001];
	cin >> n >> m >> k;
	for (int i = 0; i < m+1; i++)
	{
		cin >> arr[i];

	}
	for (int i = 0; i < m; i++)
	{
		count = 0;
		for (int j = 0; j < n; j++)
		{
			if (((arr[i] >> j) & 1) != ((arr[m] >> j) & 1)) {
				count++;
			}
		}
		if (count <= k) {
			counter++;
		}
	}
	cout << counter << endl;
	return 0;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
#include <string>
using namespace std;

void outVector(vector<int>& a) {
	for (int i = 0; i < a.size(); i++) {
		cout << a[i] << " ";
	}
	cout << "\n";
}

int revBit(int a) {
	int c = 0;
	while (a > 0) {
		c += a % 2;
		a /= 2;
	}
	c += a;
	return c;
}

int main() {
	int n, m, k;
	cin >> n >> m >> k;
	vector<int> num(m + 1);
	for (int i = 0; i < m + 1; i++) {
		cin >> num[i];
	}
	int ans = 0;
	for (int i = 0; i < m; i++) {
		if (k >= revBit(num[i] ^ num[m]))
			ans++;
	}
	cout << ans << "\n";
	return 0;
}


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

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

	vector<unsigned int> xs(m);
	for (int i = 0; i < m; i++) {
		cin >> xs[i];
	}

	unsigned int fedor, friends = 0;
	cin >> fedor;

	for (unsigned int x : xs) {
		unsigned int same = 0;
		unsigned int temp_fedor = fedor;

		for (int i = 0; i < n; i++) {
			same += temp_fedor % 2 == x % 2;

			temp_fedor = temp_fedor / 2;
			x = x / 2;

			if (same >= n-k) {
				friends++;
				break;
			}
		}
	}

	cout << friends;

	return 0;
}


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

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

	vector<unsigned int> xs(m);
	for (int i = 0; i < m; i++) {
		cin >> xs[i];
	}

	unsigned int fedor, friends = 0;
	cin >> fedor;

	for (unsigned int x : xs) {
		unsigned int diff = 0;
		unsigned int temp_fedor = fedor;

		for (int i = 0; i < n; i++) {
			diff += temp_fedor % 2 != x % 2;

			temp_fedor = temp_fedor / 2;
			x = x / 2;

			if (diff > k) {
				break;
			}

			if (i == n - 1) {
				friends++;
			}
		}
	}

	cout << friends;

	return 0;
}


#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
   int n,m,s[100002],cnt = 0,k,l,z=0;
   cin>>n>>m>>k;
   for(int i=0;i<m+1;i++)
   {
       cin>>s[i];
   }
    int j = s[m];
       l=0;
       while(j>0)
       {
           z += j%2;
           j /=2;
        }

   for(int i=0;i<m;i++)
   {  int u=0;
       l=0;
        int j = s[i];
         while(j>0)
       {
           u += j%2;
           j /=2;
        }
         j = (s[i] & s[m]);

       while(j>0)
       {
           l += j%2;
           j /=2;
        }

       if(abs(u+z-2*l)<=k)
       cnt++;
   }
   cout<<cnt;

}


#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
   int n,m,s[100002],cnt = 0,k,l,z=0;
   cin>>n>>m>>k;
   for(int i=0;i<m+1;i++)
   {
       cin>>s[i];
   }
    int j = s[m];
       l=0;
       while(j>0)
       {
           z += j%2;
           j /=2;
        }

   for(int i=0;i<m;i++)
   {  int u=0;

        int j = s[i];
         while(j>0)
       {
           u += j%2;
           j /=2;
        }
         j = (s[i] & s[m]);
       while(j>0)
       {
           l += j%2;
           j /=2;
        }

       if(abs(u+z-2*l)<=k)
       cnt++;
   }
   cout<<cnt;

}


#include <iostream>
#include <stdio.h>
using namespace std;

int main()
{
   int n,m,s[100002],cnt = 0,k,l,z=0;
   cin>>n>>m>>k;
   for(int i=0;i<m+1;i++)
   {
       cin>>s[i];
   }
    int j = s[m];
       l=0;
       while(j>0)
       {
           z += j%2;
           j /=2;
        }

   for(int i=0;i<m;i++)
   {  int u=0;
       l=0;
        int j = s[i];
         while(j>0)
       {
           u += j%2;
           j /=2;
        }
        cout<<u<<" ";
         j = (s[i] & s[m]);
         cout<<j<<" ";
       while(j>0)
       {
           l += j%2;
           j /=2;
        }
        cout<<l<<" ";
       if(abs(u+z-2*l)<=k)
       cnt++;
   }
   cout<<cnt;

}


#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <set>
#include <sstream>
#include <map>
#include <deque>
#include <queue>
#pragma warning(disable:4996)
//#include <bits/stdc++.h>
using namespace std;
int main() {
	int N, M, K, players[1001];
	cin >> N >> M >> K;
	for (int i = 0; i <= M; i++) {
		cin >> players[i];
	}
	int count = 0;
	for (int i = 0; i < M; i++) {
		int dif = 0;
		for (int j = 0; j < N; j++) {
			if ((players[M] & (1 << j)) ^ (players[i] & (1 << j))) {
				dif++;
			}
		}
		if (dif <= K) count++;
	}
	cout << count;
}


#include <iostream>

using namespace std;

void find(int n, int m, int k, int* soldiers) {
	int friends = 0;
	int sdiff = 0;
	int** type = new int*[m + 1];
	for (int i = 0; i < m + 1; i++) {
		type[i] = new int[n];
		for (int j = n; j >= 1; j--) {
			//cout << i << ", " << j << " check : " << (pow(2, j - 1)) << endl;
			if (soldiers[i] / (int)(pow(2, j - 1)) == 1) {
			//	cout << soldiers[i] << "가 " << (pow(2, j - 1)) << "로 나눠짐" << endl;
				type[i][j - 1] = 1;
				soldiers[i] = soldiers[i] % (int)pow(2, j - 1);
			}
			else
				type[i][j - 1] = 0;
		}
	}

	//for (int i = 0; i < m + 1; i++) {
	//	for (int j = 0; j < n; j++)
	//		cout << type[i][j];
	//	cout << endl;
	//}

	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			if (type[i][j] != type[m][j]) {
				sdiff++;
			}
		}
		if (sdiff <= k)
			friends++;
		sdiff = 0;
	}

	for (int i = 0; i < m + 1; i++) {
		delete[] type[i];
	}
	delete[] type;

	cout << friends << endl;

}

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

	int* soldiers = new int[m + 1];

	for (int i = 0; i < m + 1; i++) {

		cin >> soldiers[i];

	}

	cout << endl;
	find(n, m, k, soldiers);
	return 0;

}


#include <iostream>

using namespace std;

void find(int n, int m, int k, int* soldiers) {
	int friends = 0;
	int sdiff = 0;
	int** type = new int*[m + 1];
	for (int i = 0; i < m + 1; i++) {
		type[i] = new int[n];
		for (int j = n; j >= 1; j--) {
			//cout << i << ", " << j << " check : " << (pow(2, j - 1)) << endl;
			if (soldiers[i] / (int)(pow(2, j - 1)) == 1) {
			//	cout << soldiers[i] << "가 " << (pow(2, j - 1)) << "로 나눠짐" << endl;
				type[i][j - 1] = 1;
				soldiers[i] = soldiers[i] % (int)pow(2, j - 1);
			}
			else
				type[i][j - 1] = 0;
		}
	}

	//for (int i = 0; i < m + 1; i++) {
	//	for (int j = 0; j < n; j++)
	//		cout << type[i][j];
	//	cout << endl;
	//}

	for (int i = 0; i < m; i++) {
		for (int j = 0; j < n; j++) {
			if (type[i][j] != type[m][j]) {
				sdiff++;
			}
		}
		if (sdiff <= k)
			friends++;
		sdiff = 0;
	}

	for (int i = 0; i < m + 1; i++) {
		delete[] type[i];
	}
	delete[] type;

	cout << friends << endl;

}

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

	int* soldiers = new int[m + 1];

	for (int i = 0; i < m + 1; i++) {

		cin >> soldiers[i];

	}

	cout << endl;
	find(n, m, k, soldiers);

	system("pause");
	return 0;

}


#include <iostream>
#include <string>
#include<vector>
#include <map>
#include<set>
#include<math.h>
#include<algorithm>
#define ll long long int
using namespace std;
int main()
{
	ll n, m, k, x, y, count = 0;
	cin >> n >> m >> k;
	vector<ll>a;
	for (int i = 0; i < m; i++)
	{
		cin >> x;
		a.push_back(x);
	}
	cin >> y;
	for (int i = 0; i < m; i++)
	{
		x = y;
		ll q=n, counter = 0;
		while (q--)
		{
			if (x & 1 && !(a[i] & 1))
				counter++;
			else if (!(x & 1) && a[i] & 1)
				counter++;
			x = x >> 1;
			a[i] = a[i] >> 1;
		}
		if (counter <= k)count++;
	}
	cout << count;
	return 0;
}


#include <iostream>
#include <string>
#include<vector>
#include <map>
#include<set>
#include<math.h>
#include<algorithm>
#include<bitset>
#define ll long long int
using namespace std;
int main()
{
	ll n, m, k, x, y, count = 0;
	cin >> n >> m >> k;
	vector<ll>a;
	for (int i = 0; i < m; i++)
	{
		cin >> x;
		a.push_back(x);
	}
	cin >> y;
	for (int i = 0; i < m; i++)
	{
		bitset<20> x = y,t=a[i];
		ll q=n, counter = 0;
		while (q--)
			if (x[q] != t[q])counter++;
		if (counter <= k)count++;
	}
	cout << count;
	return 0;
}


#include <iostream>
using namespace std;

int main() {
    int n, m, k, answer = 0;
    cin >> n>> m >> k;
    int *mas = new int[m+1];
    int *ma = new int[n];
    for(int i = 0; i <= m; i++)
        cin >> mas[i];

    for(int i = 0; i < n; i++){
        ma[i] = mas[m] % 2;
        mas[m] /= 2;
    }
    for(int i = 0; i < m; i++) {
        int count = 0, same = 0, val;
        for (int j = 0; j < n; j++) {
            val = mas[i] % 2;
            mas[i] /= 2;
            if(val == 1 || ma[j] == 1){
                count++;
                if(val == ma[j])
                    same++;
            }
        }
        if(count - same <= k)
            answer++;
    }
    cout << answer;
    return 0;
}


#include <iostream>
#include <vector>
#include <bitset>
#include <string>
using namespace std;

int main() {

	int a, b, c,l, p=0,m=0;
	bitset<20> e;

	cin >> a >> b >> c;

	vector<int> d;

	for (int i = 0; i < b + 1; i++) {
		cin >> l;
		d.push_back(l);
	}
	for (int i = 0; i < b ; i++) {

		e = (bitset<20>(d[i]) ^ bitset<20>(d[b]));

		for(int n=0;n<20;n++){

			if (e[n] == 1)
				p = p + 1;
		}
		if (p <= c)
			m = m + 1;
		p = 0;
	}
	cout << m;
	return 0;
}


#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <bitset>
#include <intrin.h>
#include <stdio.h>
#include <chrono>
#include <stack>
#include <ctime>
#include <iomanip>
#include <cmath>
#include <unordered_map>
#include <functional>
#define f(n) for(ll i=0;i<n;i++)
#define mp make_pair
#define pii pair<int,int>
#define all(x) x.begin(),x.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define INF 2e9
#define MOD 1000000007  //998244353
#define eps 0.00001
#define pi 3.1415926535

inline int mul(int a, int b) {
	return int(a * 1ll * b % MOD);
}

inline int norm(int a) {
	if (a >= MOD)
		a -= MOD;
	if (a < 0)
		a += MOD;
	return a;
}

inline int binPow(int a, int k) {
	int ans = 1;
	while (k > 0) {
		if (k & 1)
			ans = mul(ans, a);
		a = mul(a, a);
		k >>= 1;
	}
	return ans;
}

inline int subtract(int a, int b) {
	return norm(a - b);
}

inline int sum(int a, int b) {
	return int((a + b) % MOD);
}

inline int inv(int a) {   //a/k=a*inv(k) divizion with MOD q^-1
	return binPow(a, MOD - 2);
}

//**************************************START*****************************
ll gcd(ll a, ll b) {
	if (a == 0)return b;
	return gcd(b%a, a);
}

int main() {
	srand(chrono::system_clock::now().time_since_epoch().count());
	ios::sync_with_stdio(false);
	cin.tie(nullptr); cout.tie(nullptr);
	ll n,ans=0;
	ll m, k;
	cin >> n >> m >> k;
	vector<ll>a(m+1);
	for (int i = 0; i < m + 1; i++) {
		cin >> a[i];
	}
	for (int i = 0; i < m; i++) {
		ll b = a[i] & a[m];
		int cnt = 0;
		for (int j = 32; j >= 0; j--) {
			if (((a[i] >> j) & 1) != ((a[m]>>j)&1))cnt++;
		}
		if (cnt <= k)ans++;

	}
	cout << ans;
}


#include <iostream>
#include<cmath>
#include<algorithm>
#include<map>
#include<vector>
#include<string>

using namespace std;

int main() {
    int m1[1001], n, m, k,o=1, h[20] = { 0 },ind=0,sp=0,p=0;
    cin >> n >> m >> k;
    for (int i = 0; i < m + 1; i++) {
        cin >> m1[i];
    }
    while (o <= m1[m]) { o *= 2; ind++;}
    while (o > 0) { o /= 2; ind--; if (o <= m1[m]) { m1[m] -= o; h[ind] = 1; } }
    for (int i = 0; i < m; i++) {
        o = 1; ind = 0;
        while (o <= m1[i]) { o *= 2; ind++; }
        o /= 2;
        for (int j = ind; j < 21; j++) {
            if (h[j] == 1) { sp++; }
        }
        while (o > 0) {
            ind--;
            if (o <= m1[i]) {
                m1[i] -= o;
                if (h[ind] == 0) {
                    sp++;
                    if (sp > k) { break; }
                }
            }
            else {
                if (h[ind] == 1) {
                    sp++;
                    if (sp > k) { break; }
                }
            }
            o /= 2;
        }
        if (sp <= k) { p++;}
        sp = 0;
    }
    cout << p << endl;
    return 0;
}


#include <iostream>
#include <cstdio>
#include <complex>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <bitset>
#include <regex>

using namespace std;

typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;

typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;

typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;

#define REP(i, begin, end) for (auto i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define FOR(i, begin, end) REP(i,begin,end)
#define F0R(i, end) FOR(i, 0, end)
#define TR(it, begin, end) for (auto it = (begin); (it) != (end); (it)++) // for stl containers

#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define present(c,x) ((c).find(x) != (c).end())   // map and set
#define cpresent(c,x) (find(all(c),x) != (c).end()) // containers
#define tr1(x)                cerr << #x << ": " << x << endl;
#define tr2(x, y)             cerr << #x << ": " << x << " | " << #y << ": " << y << endl;
#define tr3(x, y, z)          cerr << #x << ": " << x << " | " << #y << ": " << y << " | " << #z << ": " << z << endl;
#define tr4(a, b, c, d)       cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << endl;
#define tr5(a, b, c, d, e)    cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << endl;
#define tr6(a, b, c, d, e, f) cerr << #a << ": " << a << " | " << #b << ": " << b << " | " << #c << ": " << c << " | " << #d << ": " << d << " | " << #e << ": " << e << " | " << #f << ": " << f << endl;

namespace io {
	template<typename Test, template<typename...> class Ref>
	struct is_specialization : std::false_type {};

	template<template<typename...> class Ref, typename... Args>
	struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
	// https://stackoverflow.com/questions/16337610/how-to-know-if-a-type-is-a-specialization-of-stdvector

	void setIn(string s) { freopen(s.c_str(), "r", stdin); }
	void setOut(string s) { freopen(s.c_str(), "w", stdout); }
	void setIO(string s = "") {
		ios_base::sync_with_stdio(0); cin.tie(0);
		if (sz(s)) { setIn(s + ".in"), setOut(s + ".out"); }
	}

	// INPUT
	// double input seems slow on CF
	void re(double& x) { string t; cin >> t; x = stod(t); }
	void re(ld& x) { string t; cin >> t; x = stold(t); }
	template<class T> void re(T& x) { cin >> x; }
	template<class Arg, class... Args> void re(Arg& first, Args&... rest) {
		re(first); re(rest...);
	}
	template<class T1, class T2> istream& operator>>(istream& is, pair<T1, T2>& p) {
		is >> p.fi >> p.se; return is;
	}
	template<class T> istream& operator>>(istream& is, vector<T>& a) {
		REP(i, 0, sz(a)) is >> a[i];
		return is;
	}

	// OUTPUT
	template<class T> void pr(const T& x) { cout << x << '\n'; }
	template<class Arg, class... Args> void pr(const Arg& first, const Args&... rest) {
		cout << first << ' '; pr(rest...);
	}
	template<class T1, class T2> ostream& operator<<(ostream& os, const pair<T1, T2>& a) {
		os << '{' << a.fi << ", " << a.se << '}'; return os;
	}
	template<class K, class V> ostream& operator<<(ostream& os, const map<K, V>& m) {
		os << '{';
		TR(it, m.begin(), m.end()) {
			os << ", "[it == m.begin()] << *it;
		}
		os << " }";
		return os;
	}
	template<class T> ostream& operator<<(ostream& os, const set<T>& s) {
		os << '{';
		TR(it, s.begin(), s.end()) {
			os << ", "[it == s.begin()] << *it;
		}
		os << " }";
		return os;
	}
	template<class T> ostream& operator<<(ostream& os, const vector<T>& a) {
		os << '[';
		REP(i, 0, sz(a)) {
			if (i) {
				os << ", ";
				if (is_specialization<T, vector>::value) os << '\n';
			}
			os << a[i];
		}
		os << ']';
		return os;
	}
}
using namespace io;

inline void prep() {
	ios::sync_with_stdio(0);
	cin.tie(0);
#ifdef LOCAL
	freopen("../__in.txt", "r", stdin);
	freopen("../__out.txt", "w", stdout);
#endif
}

void solve();

int main() {
	prep();
	int t = 1;
	//re(t);
	while (t--) {
		solve();
	}
	return 0;
}

const int MOD = 1000000007;
const int MX = 101;

// Actual solution

void solve()
{
	int n, m, k;
	re(n, m, k);
	vi a(m + 1);
	for (auto& aa : a) re(aa);
	int man = a[m];
	ll res = 0;
	for (int i = 0; i < m; i++) {
		bitset<21> bs(man^a[i]);
		res += (bs.count() <= k);
	}
	pr(res);
}


#include<iostream>
#include<vector>
using namespace std;
int main() {
	int n, m, k, counter = 0;
	cin >> n >> m >> k;

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

	for(int i=0; i<m; ++i) {
		int ans = (v[i] ^ v[m]), sum = 0;
		while(ans > 0) {
			ans = ans & (ans - 1);
			++sum;
		}

		if(sum <= k)
			++counter;
	}

	cout << counter;
}


#include <iostream>
#include <vector>
#include <string>
#include <bitset>

using namespace std;
const int LENG = 20;

using Type = bitset <LENG>;

int main() {
	// ...
	int n, m, k, cont(0);
	cin >> n >> m >> k;

	vector <Type> d;
	for (int i(0); i < m+1; i++) {
		long long v;
		cin >> v;

		d.push_back(Type(v));
	}

	// refr
	Type Fedor = d.back();

	for (int i(0); i < m; i++) {
		if (Type(Fedor ^ d[i]).count() <= k)
			cont++;
	}

	cout << cont;

	return 0;
}


#include <iostream>
#include <vector>
#include <string>
#include <bitset>

using namespace std;
const int LENG = 1000000;

using Type = bitset <LENG>;

int main() {
	// ...
	int n, m, k, cont(0);
	cin >> n >> m >> k;

	vector <Type> d;
	for (int i(0); i < m+1; i++) {
		long long v;
		cin >> v;

		d.push_back(Type(v));
	}

	// refr
	Type Fedor = d.back();

	for (int i(0); i < m; i++) {
		if (Type(Fedor ^ d[i]).count() <= k)
			cont++;
	}

	cout << cont;

	return 0;
}


#include <iostream>
#include <vector>

using namespace std;

int n, m, k, x;

vector<bool> ToBits(long long x) {
	vector<bool> army;
	while (x > 0) {
		army.push_back(x % 2);
		x /= 2;
	}
	return army;
}

int main() {
	cin >> n >> m >> k;
	vector<vector<bool>> armys(m + 1);
	for (int i = 0; i < m + 1; ++i) {
		cin >> x;
		armys[i] = ToBits(x);
	}

	int friends = 0;
	for (int i = 0; i < m; ++i) {
		int not_same_warrior = 0;
		if (armys.back().size() > armys[i].size()) {
			not_same_warrior += armys.back().size() - armys[i].size();
			for (int j = 0; j < armys[i].size(); ++j) {
				if (armys.back()[j] != armys[i][j])
					++not_same_warrior;
			}
		} else if (armys.back().size() < armys[i].size()) {
			not_same_warrior += armys[i].size() - armys.back().size();
			for (int j = 0; j < armys.back().size(); ++j) {
				if (armys.back()[j] != armys[i][j])
					++not_same_warrior;
			}
		}

		if (not_same_warrior <= k)
			++friends;
		not_same_warrior = 0;
	}

	cout << friends;
}


#include <iostream>
#include <vector>

using namespace std;

int n, m, k, x;

vector<int> ToBits(int x) {
	vector<int> army;
	for (int k = n; k >= 0; --k) {
		if (x & (1 << k)) army.push_back(1);
		else army.push_back(0);
	}
	return army;
}

int main() {
	cin >> n >> m >> k;
	vector<vector<int>> armys(m + 1);
	for (int i = 0; i < m + 1; ++i) {
		cin >> x;
		armys[i] = ToBits(x);
	}

	int friends = 0;
	int not_same_warrior = 0;
	const vector<int>& fedya = armys.back();
	for (int i = 0; i < m; ++i) {
		for (int j = 0; j < n; ++j) {

			if (armys[i][j] != fedya[j])
				++not_same_warrior;
		}
		if (not_same_warrior <= k)
			++friends;
		not_same_warrior = 0;
	}

	cout << friends;
}


#include <iostream>
#include <vector>

using namespace std;

int n, m, k, x;

vector<bool> ToBits(long long x) {
	vector<bool> army;
	while (x > 0) {
		army.push_back(x % 2);
		x /= 2;
	}
	reverse(army.begin(), army.end());
	return army;
}

int main() {
	cin >> n >> m >> k;
	vector<vector<bool>> armys(m + 1);
	for (int i = 0; i < m + 1; ++i) {
		cin >> x;
		armys[i] = ToBits(x);
	}

	int friends = 0;
	for (int i = 0; i < m; ++i) {
		int not_same_warrior = 0;
		if (armys.back().size() > armys[i].size())
			not_same_warrior += armys.back().size() - armys[i].size();
		else if (armys.back().size() < armys[i].size())
			not_same_warrior += armys[i].size() - armys.back().size();

		for (int j = 0; j < armys.back().size(); ++j) {
			if (j >= armys[i].size())
				break;

			if (armys.back()[j] != armys[i][j])
				++not_same_warrior;
		}
		if (not_same_warrior < k)
			++friends;
		not_same_warrior = 0;
	}

	cout << friends;
}


#include <iostream>
#include <vector>

using namespace std;

int n, m, k, x;

vector<int> ToBits(int x) {
	vector<int> army;
	for (int k = n - 1; k >= 0; --k) {
		if (x & (1 << k)) army.push_back(1);
		else army.push_back(0);
	}
	return army;
}

int main() {
	cin >> n >> m >> k;
	vector<vector<int>> armys(m + 1);
	for (int i = 0; i < m + 1; ++i) {
		cin >> x;
		armys[i] = ToBits(x);
	}

	int friends = 0;
	int not_same_warrior = 0;
	const vector<int>& fedya = armys.back();
	for (int i = 0; i < m; ++i) {
		for (int j = 0; j < n; ++j) {

			if (armys[i][j] != fedya[j])
				++not_same_warrior;
		}
		if (not_same_warrior <= k)
			++friends;
		not_same_warrior = 0;
	}

	cout << friends;
}


#include <iostream>
#include <vector>

using namespace std;

int n, m, k, x;

vector<bool> ToBits(long long x) {
	vector<bool> army;
	while (x > 0) {
		army.push_back(x % 2);
		x /= 2;
	}
	reverse(army.begin(), army.end());
	return army;
}

int main() {
	cin >> n >> m >> k;
	vector<vector<bool>> armys(m + 1);
	for (int i = 0; i < m + 1; ++i) {
		cin >> x;
		armys[i] = ToBits(x);
	}

	int friends = 0;
	for (int i = 0; i < m; ++i) {
		int not_same_warrior = 0;
		for (int j = 0; j < armys.back().size(); ++j) {
			if (j >= armys[i].size()) {
				not_same_warrior += armys.back().size() - armys[i].size();
				break;
			}

			if (armys.back()[j] != armys[i][j])
				++not_same_warrior;
		}
		if (not_same_warrior < k)
			++friends;
		not_same_warrior = 0;
	}

	cout << friends;
}


#include <iostream>
#include <string>
#include<algorithm>
#include <cstdio>
#include <vector>
#include<numeric>
using namespace std;
int myxor(int x, int y)
{
	return (x | y) & (~x | ~y);
}
std::string toBinary(int n)
{
	std::string r;
	while (n != 0) { r = (n % 2 == 0 ? "0" : "1") + r; n /= 2; }
	return r;
}
void main()
{

	int a, b, v;
	cin >> a>> b>> v;
	int r = 0;
	int c = 0;
	int x;
	string g;
	vector <int> d;
	for (size_t i = 0; i < b+1; i++)
	{

		cin >> x;
		d.push_back(x);

		if(i==b)
		for (int k = 0; k <i; ++k)
		{

			c= myxor(x, d[k]);
			g = toBinary(c);
			c = count(g.begin(), g.end(), '1');
			if (c <= v)++r;

		}
	}

	cout << r;
}


#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
int main(){
	int n, m, k, ans = 0;
	cin >> n >> m >> k;
	vector<int>a(m + 1);
	for (int i = 0; i < m + 1; i++) {
		cin >> a[i];
	}
	for (int i = 0; i < m; i++) {
		int j = 0;
		int cnt = 0;
		while (a[i] >> j > 0 || a[m] >> j > 0) {
			if (((a[i] >> j) & 1) != ((a[m] >> j) & 1)) {
				cnt++;
			}
			j++;
		}
		if (cnt <= k) {
			ans++;
		}
	}
	cout << ans;
}


#include<iostream>
#include<string>
#include<fstream>
#include<algorithm>
#include<cmath>
#include<map>
#include<vector>
using namespace std;
ofstream fo("test.out");
ifstream fi("test.inp");
int  n, m, k, dem, maxx, rs, sum, cnt;
int rsmin,rsmax;
//long long a[100005], rs;
//map<string,int>rs;
#define N 100005
int a[1005];
int Bit[1005][25];
void ChangeToBit(int x,int i)
{
	int j = 0;
	while (x != 0)
	{
		Bit[i][j]=x%2;
		x /= 2;
		j++;
	}
	reverse(Bit[i], Bit[i] + 25);
}
int main()
{
	cin >> n >> m >> k;
	for (int i = 0; i <= m; i++)
	{
		cin >> a[i];
		ChangeToBit(a[i], i);
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = 0; j <25; j++)
		{
			if (Bit[i][j] != Bit[m][j])
				dem++;
		}
		if (dem <= k) rs++;
		dem = 0;
	}
	cout << rs;
}


#include<iostream>
#include<string>
#include<fstream>
#include<algorithm>
#include<cmath>
#include<map>
#include<vector>
using namespace std;
ofstream fo("test.out");
ifstream fi("test.inp");
int  n, m, k, dem, maxx, rs, sum, cnt;
int rsmin,rsmax;
//long long a[100005], rs;
//map<string,int>rs;
#define N 100005
int a[1005];
int Bit[1005][25];
void ChangeToBit(int x,int i)
{
	int j = 0;
	while (x != 0)
	{
		Bit[i][j]=x%2;
		x /= 2;
		j++;
	}
	reverse(Bit[i], Bit[i] + j);
}
int main()
{
	cin >> n >> m >> k;
	for (int i = 0; i <= m; i++)
	{
		cin >> a[i];
		ChangeToBit(a[i], i);
	}
	for (int i = 0; i < m; i++)
	{
		for (int j = n -1; j >= 0; j--)
		{
			if (Bit[i][j] != Bit[m][j])
				dem++;
		}
		if (dem <= k) rs++;
		dem = 0;
	}
	cout << rs;
}


#include<iostream>
#include<fstream>
#include<cmath>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include<vector>
#include <queue>
using namespace std;
typedef long long ll ;
string r="" ;
string tobe(int a){
	 if(a==1){
		 return r+"1";
	 }

	 if(a%2==0){
		return tobe(a/2)+"0";
	 }
	 else{
		return tobe((a-1)/2)+"1";
	 }

}

string make_good(string s ,int b){
	for(int i=0;i<s.length()-b;i++)
		s = "0"+s;
	return s;
}
int main()
{
	int n  , m , k ;
	cin >> n >> m >> k ;
	int arr[101];
	for(int i=0;i<m;i++)
	{
		cin >> arr[i];
	}
	int a ;
	cin >> a ;
	string s = make_good(tobe(a) , n);

	//cout << s ;
	string arrs[101];
	for(int i=0;i<m;i++)
	{
		arrs[i] = make_good(tobe(arr[i]) , n );
	}
	int count =k , out=0;
	for(int i=0;i<m;i++)
	{
		for(int x=0;x<n;x++)
		{
			if(s[x]!=arrs[i][x])
				count--;
		}
		if(count>=0)
			out++;
		count = k ;
	}
	cout << out ;
	return 0;
}


#include<iostream>
#include<fstream>
#include<cmath>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include<vector>
#include <queue>
using namespace std;
typedef long long ll ;
int main()
{
	int n  , m , k ;
	cin >> n >> m >> k ;
	int arr[101];
	for(int i=0;i<m;i++)
	{
		cin >> arr[i];
	}
	int a ;
	cin >> a ;
	int out = 0;
	for(int i=0;i<m;i++)
	{
		if((a|arr[i]) <= pow(2.0,k)-1)
			out++;
	}
	cout << out ;

	return 0;
}


#include<iostream>
#include<fstream>
#include<cmath>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include<vector>
#include <queue>
using namespace std;
typedef long long ll ;
int main()
{
	/*int a , b ;
	cin >>a >> b ;
	cout << (a^b) << endl ;
	*/
	int n  , m , k ;
	cin >> n >> m >> k ;
	int arr[1010];
	for(int i=0;i<m;i++)
	{
		cin >> arr[i];
	}
	int a , count=0;
	cin >> a ;
	int out = 0;
	for(int i=0;i<m;i++)
	{
	//	cout << "asdasd"<<endl;
		for(int q=0,t=1;q<n;q++,t*=2){
		//cout << ((a^arr[i])|t) <<" " << (a^arr[i])<< " " << t<< endl ;
		if(((a^arr[i])|t)!=(a^arr[i])){
			count++;
		}}
		if(n-count<=k)
			out++;
		count=0;

	}
	cout << out ;

	return 0;
}


#include<iostream>
#include<fstream>
#include<cmath>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include<vector>
#include <queue>
using namespace std;
typedef long long ll ;
int main()
{	/*
	int a , b ;
	cin >>a >> b ;
	cout << (a|b) << endl ;
	*/
	int n  , m , k ;
	cin >> n >> m >> k ;
	int arr[101];
	for(int i=0;i<m;i++)
	{
		cin >> arr[i];
	}
	int a ;
	cin >> a ;
	int out = 0;
	for(int i=0;i<m;i++)
	{
		if((a^arr[i]) <= pow(2.0,k)-1)
			out++;
	}
	cout << out ;

	return 0;
}


#include<iostream>
#include<fstream>
#include<cmath>
#include<string>
#include<set>
#include <map>
#include<algorithm>
#include<vector>
#include <queue>
using namespace std;
typedef long long ll ;
int main()
{
	/*int a , b ;
	cin >>a >> b ;
	cout << (a^b) << endl ;
	*/
	int n  , m , k ;
	cin >> n >> m >> k ;
	int arr[101];
	for(int i=0;i<m;i++)
	{
		cin >> arr[i];
	}
	int a , count=0;
	cin >> a ;
	int out = 0;
	for(int i=0;i<m;i++)
	{
	//	cout << "asdasd"<<endl;
		for(int q=0,t=1;q<n;q++,t*=2){
		//cout << ((a^arr[i])|t) <<" " << (a^arr[i])<< " " << t<< endl ;
		if(((a^arr[i])|t)!=(a^arr[i])){
			count++;
		}}
		if(n-count<=k)
			out++;
		count=0;

	}
	cout << out ;

	return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {
    int n, m, k, result = 0;
    cin >> n >> m >> k;
    int* mass = new int[m] { 0 };
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[0]);
        if (bit.count() <= k) ++result;
    }
    cout << result;
    cin.get();
    cin.get();
    return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {
    int n, m, k, result = 0;
    cin >> n >> m >> k;
    int* mass = new int[m] { 0 };
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[0]);
        if (bit.count() <= k) ++result;
    }
    cout << result;
    return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {

    int n, m, k, result = 0;
    int mass[1010];
    cin >> n >> m >> k;
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[i]);
        if (bit.count() <= k) ++result;
    }
    cout << result;
    return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {
    int n, m, k, result = 0;
    cin >> n >> m >> k;
    int* mass = new int[m];
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[i]);
        if (bit.count() <= k) ++result;
    }
    delete[] mass;
    cout << result;
    return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {
    int n, m, k, result = 0;
    cin >> n >> m >> k;
    int* mass = new int[m];
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[i]);
        if (bit.count() <= k) ++result;
    }
    cout << result;
    return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {

	int n, m, k, result = 0;
	int mass[1010];
	cin >> n >> m >> k;
	for (int i = 0; i <= m; ++i) {
		cin >> mass[i];
	}
	for (int i = 0; i < m; ++i) {
		bitset<32> bit(mass[m] ^ mass[i]);
		if (bit.count() <= k) ++result;
	}
	cout << result;
	return 0;
}


#include <iostream>
#include <bitset>

using namespace std;

int main() {
    int n, m, k, result = 0;
    cin >> n >> m >> k;
    int* mass = new int[m];
    for (int i = 0; i <= m; ++i) {
        cin >> mass[i];
    }
    for (int i = 0; i < m; ++i) {
        bitset<16> bit(mass[m] ^ mass[0]);
        if (bit.count() <= k) ++result;
    }
    cout << result;
    return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<bool> v,v1;
	vector <vector <bool> > vv;
	long a,b,i,n,m,k,j,s=0,c=0;
	cin>>n>>m>>k;
	b=1;
	for(i=0;i<n;i++)
		b*=2;
	b--;
	v1.assign(b,0);
	vv.assign(m+1,v1);
	for(i=0;i<=m;i++)
	{
		cin>>a;
		j=b-1;
		while(a!=0)
		{
			vv[i][j]=a%2;
			a/=2;
			j--;
		}
	}
	for(i=0;i<m;i++)
	{
		c=0;
		for(j=0;j<b;j++)
			if(vv[i][j]!=vv[m][j])
				c++;
		if(c<=k)
			s++;
	}
cout<<s;
return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<long> v;
	long a,b,i,n,m,k,s=0;
	cin>>n>>m>>k;
	for(i=0;i<=m;i++)
	{
		cin>>a;
		v.push_back(a);
	}
	for(i=0;i<m;i++)
		if((v[i]-v[m]<=k)||(v[m]-v[i]<=k))
			s++;
	cout<<s;
return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<long> v;
	long a,b,i,n,m,k,s=0;
	cin>>n>>m>>k;
	for(i=0;i<=m;i++)
	{
		cin>>a;
		v.push_back(a);
	}
	for(i=0;i<m;i++)
		if(max(v[i],v[m])-min(v[i],v[m])<=k)
			s++;

	cout<<s;
return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<bool> v,v1;
	vector <vector <bool> > vv;
	long a,b,i,n,m,k,j,s=0,c=0;
	cin>>n>>m>>k;
	b=1;
	for(i=0;i<n;i++)
		b*=2;
	//b--;
	v1.assign(b,0);
	vv.assign(m+1,v1);
	for(i=0;i<=m;i++)
	{
		cin>>a;
		j=b-1;
		while(a!=0)
		{
			vv[i][j]=a%2;
			a/=2;
			j--;
		}
	}
	for(i=0;i<m;i++)
	{
		c=0;
		for(j=0;j<b;j++)
			if(vv[i][j]!=vv[m][j])
				c++;
		if(c<=k)
			s++;
	}
cout<<s;
return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<bool> v,v1;
	vector <vector <bool> > vv;
	long long a,b,i,n,m,k,j,s=0,c=0;
	cin>>n>>m>>k;
	/*b=1;
	for(i=0;i<n;i++)
		b*=2;
	b--;*/
	v1.assign(n,0);
	vv.assign(m+1,v1);
	for(i=0;i<=m;i++)
	{
		cin>>a;
		j=0;
		while(a!=0)
		{
			vv[i][j]=a%2;
			a/=2;
			j++;
		}
	}
	for(i=0;i<m;i++)
	{
		c=0;
		for(j=0;j<n;j++)
			if(vv[i][j]!=vv[m][j])
				c++;
		if(c<=k)
			s++;
	}
cout<<s;
return 0;
}


#include <iostream>
#include <string>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <iterator>
using namespace std;

int main()
{
	vector<long> v,v1;
	vector <vector <long> > vv;
	long a,b,i,n,m,k,j,s=0,c=0;
	cin>>n>>m>>k;
	b=1;
	for(i=0;i<n;i++)
		b*=2;
	b--;
	v1.assign(b,0);
	vv.assign(m+1,v1);
	for(i=0;i<=m;i++)
	{
		cin>>a;
		j=b-1;
		while(a!=0)
		{
			vv[i][j]=a%2;
			a/=2;
			j--;
		}
	}
	for(i=0;i<m;i++)
	{
		c=0;
		for(j=0;j<b;j++)
			if(vv[i][j]!=vv[m][j])
				c++;
		if(c<=k)
			s++;
	}
cout<<s;
return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
    vector<int> lst1,lst2,lst3;
    int x, y, z,a,ans=0,count,j=0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);
    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){ lst3.push_back(a % 2);
    a /= 2;
    }
    reverse(lst3.begin(), lst3.end());
    for (int l = 0; l < y; l++){
        for (int i = 0; i < y; i++){
            while (j < x){
                lst2.push_back(lst1[i] % 2);
                lst1[i] /= 2;
                j++;
            }
            j = 0;
            reverse(lst2.begin(), lst2.end());
        }for (int k = 0; k < x&&count!=0; k++){
            if (lst2[k] != lst3[k]){ count--; }
            if (k == x - 1){ ans += 1; }

        }
        lst2.clear();
        count = z;
    }
    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<long long> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(static_cast<long long>(a % 2)));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(static_cast<long long>(lst1[i] % 2)));
                lst1[i] /= 2;
            }
            cout << lst2 << endl;
            for (int k = 0; k < x; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (count==0&&k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }

    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<long long> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(static_cast<long long>(a % 2)));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(static_cast<long long>(lst1[i] % 2)));
                lst1[i] /= 2;
            }

            for (int k = 0; k < x; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (count>=0&&k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }

    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<int> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(static_cast<long long>(a % 2)));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(static_cast<long long>(lst1[i] % 2)));
                lst1[i] /= 2;
            }

            for (int k = 0; k < x&&count != 0; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }

    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<long long> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(static_cast<long long>(a % 2)));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(static_cast<long long>(lst1[i] % 2)));
                lst1[i] /= 2;
            }
            cout << lst2 << endl;
            for (int k = 0; k < x; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (count>=0&&k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }

    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<int> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(a % 2));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(lst1[i] % 2));
                lst1[i] /= 2;
            }

            for (int k = 0; k < x&&count != 0; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }
    cout << ans << endl;
       return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<long long> lst1;
    string lst2 = "", lst3 = "";
    int x, y, z, a, ans = 0, count, j = 0;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);

    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    for (int i = 0; i < x; i++){
        lst3.append(to_string(static_cast<long long>(a % 2)));
        a /= 2;
    }

        for (int i = 0; i < y; i++){
            for (j = 0; j < x; j++){
                lst2.append(to_string(static_cast<long long>(lst1[i] % 2)));
                lst1[i] /= 2;
            }

            for (int k = 0; k < x&&count != 0; k++){
                if (lst2[k] != lst3[k]){ count--; }
                if (k == x - 1){ ans += 1; }

            }lst2 = ""; count = z;
        }

    cout << ans << endl;

    return 0;
}


#include <iostream>
#include <iomanip>
#include <cmath>
#include <ctype.h>
#include <string>
#include <array>
#include <vector>
#include <algorithm>
#include <bitset>
using namespace std;
int main(){
    vector<int> lst1, lst2, lst3;
    int x, y, z, a, ans = 0, count, j = 0;
    string str1, str2;
    cin >> x >> y >> z;
    count = z;
    lst1.resize(y);
    for (int i = 0; i < y; i++){ cin >> lst1[i]; }
    cin >> a;
    str1 = bitset<20>(a).to_string();
    for (int l = 0; l < y; l++){
        str2 = bitset<20>(lst1[l]).to_string();
    for (int k = 0; k < 20&&count != 0; k++){
        if (str2[k] != str1[k]){ count--; }
        if (k == 19){ ans += 1; }

    }
    count = z;
    }
    cout << ans << endl;

    return 0;
}


#include<iostream>
#include<bitset>
#include<string>
using namespace std;
int main()
{
    bitset<8> friends;
    int type_sol, players, diff_bit, *ply, count = 0;
    cin >> type_sol >> players >> diff_bit;
    ply = new int[players + 1];
    for (int i = 0; i < players + 1; i++)
    {
        cin >> ply[i];
    }
    for (int i = 0; i < players; i++)
    {
        friends = ply[players] ^ ply[i];
        if (friends.count() <= diff_bit)
            count++;
    }
    cout << count << endl;
    //system("pause");
    return 0;
}


#include<iostream>
#include<bitset>
#include<string>
using namespace std;
int main()
{
    bitset<11> friends;
    int type_sol, players, diff_bit, *ply, count = 0;
    cin >> type_sol >> players >> diff_bit;
    ply = new int[players + 1];
    for (int i = 0; i < players + 1; i++)
    {
        cin >> ply[i];
    }
    for (int i = 0; i < players; i++)
    {
        friends = ply[players] ^ ply[i];
        if (friends.count() <= diff_bit)
            count++;
    }
    cout << count << endl;
    //system("pause");
    return 0;
}


#include<iostream>
#include<bitset>
#include<string>
using namespace std;
int main()
{
    bitset<20> friends;
    int type_sol, players, diff_bit, *ply, count = 0;
    cin >> type_sol >> players >> diff_bit;
    ply = new int[players + 1];
    for (int i = 0; i < players + 1; i++)
    {
        cin >> ply[i];
    }
    for (int i = 0; i < players; i++)
    {
        friends = ply[players] ^ ply[i];
        if (friends.count() <= diff_bit)
            count++;
    }
    cout << count << endl;
    //system("pause");
    return 0;
}


#pragma comment(linker,"/STACK:268435456")
#include <iostream>
#include <iomanip>
#include <fstream>
#include <set>
#include <algorithm>
#include <vector>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <sstream>
#include <bitset>
#include <iterator>
#include <list>
#include <ctime>
#include <functional>

#define FR(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,c,n) for(int (i)=(c);(i)<(n);(i)++)
#define REP(it,v,cont) for((cont)::iterator (it)=(v).begin();(it)!=(v).end();++(it))
#define CLR(a,c) memset((a),(c),sizeof (a))
#define ALL(v) (v).begin(),(v).end()
#define VCPRINT(v) for(int iii = 0;iii < (v).size();iii++) cout<<(v)[iii]<<" ";cout<<endl;
#define SETPRINT(v,cont) for((cont)::iterator iiit = (v).begin();iiit != (v).end();iiit++) cout<<*iiit<<" ";cout<<endl;

bool ascending (int i,int j) { return (i<j); }
bool descending (int i,int j) { return (i>j); }

typedef long long ll;
typedef unsigned long long ull;
#define PII pair<int,int>
#define PLL pair<long long,long long>
#define PULI pair<unsigned long long,int>
#define PIL pair<int,long long>
#define PSI pair<string,int>
#define PSS pair<string,string>
#define PDD pair<double,double>
#define PIB pair<int,bool>
typedef long double ld;

using namespace std;

int find(int i)
{
	i = i - ((i >> 1) & 0x55555555);
	i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
	return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

int main()
{
	int n,m,k;cin>>n>>m>>k;
	vector<int> V;
	FR(i,m){ int a;cin>>a;V.push_back(a);}
	int num;cin>>num;
	int ans = 0;

	FR(i,V.size()) ans += ((n-find(num&V[i]))<=k);
	cout<<ans<<endl;
}


#pragma comment(linker,"/STACK:268435456")
#include <iostream>
#include <iomanip>
#include <fstream>
#include <set>
#include <algorithm>
#include <vector>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <sstream>
#include <bitset>
#include <iterator>
#include <list>
#include <ctime>
#include <functional>

#define FR(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,c,n) for(int (i)=(c);(i)<(n);(i)++)
#define REP(it,v,cont) for((cont)::iterator (it)=(v).begin();(it)!=(v).end();++(it))
#define CLR(a,c) memset((a),(c),sizeof (a))
#define ALL(v) (v).begin(),(v).end()
#define VCPRINT(v) for(int iii = 0;iii < (v).size();iii++) cout<<(v)[iii]<<" ";cout<<endl;
#define SETPRINT(v,cont) for((cont)::iterator iiit = (v).begin();iiit != (v).end();iiit++) cout<<*iiit<<" ";cout<<endl;

bool ascending (int i,int j) { return (i<j); }
bool descending (int i,int j) { return (i>j); }

typedef long long ll;
typedef unsigned long long ull;
#define PII pair<int,int>
#define PLL pair<long long,long long>
#define PULI pair<unsigned long long,int>
#define PIL pair<int,long long>
#define PSI pair<string,int>
#define PSS pair<string,string>
#define PDD pair<double,double>
#define PIB pair<int,bool>
typedef long double ld;

using namespace std;

int find(int i)
{
	i = i - ((i >> 1) & 0x55555555);
	i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
	return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

int main()
{
	int n,m,k;cin>>n>>m>>k;
	vector<int> V;
	FR(i,m){ int a;cin>>a;V.push_back(a);}
	int num;cin>>num;
	int ans = 0;

	FR(i,V.size()) ans += (find(num^V[i])<=k);
	cout<<ans<<endl;
}


#pragma comment(linker,"/STACK:268435456")
#include <iostream>
#include <iomanip>
#include <fstream>
#include <set>
#include <algorithm>
#include <vector>
#include <map>
#include <list>
#include <queue>
#include <stack>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <sstream>
#include <bitset>
#include <iterator>
#include <list>
#include <ctime>
#include <functional>

#define FR(i,n) for(int (i)=0;(i)<(n);(i)++)
#define FOR(i,c,n) for(int (i)=(c);(i)<(n);(i)++)
#define REP(it,v,cont) for((cont)::iterator (it)=(v).begin();(it)!=(v).end();++(it))
#define CLR(a,c) memset((a),(c),sizeof (a))
#define ALL(v) (v).begin(),(v).end()
#define VCPRINT(v) for(int iii = 0;iii < (v).size();iii++) cout<<(v)[iii]<<" ";cout<<endl;
#define SETPRINT(v,cont) for((cont)::iterator iiit = (v).begin();iiit != (v).end();iiit++) cout<<*iiit<<" ";cout<<endl;

bool ascending (int i,int j) { return (i<j); }
bool descending (int i,int j) { return (i>j); }

typedef long long ll;
typedef unsigned long long ull;
#define PII pair<int,int>
#define PLL pair<long long,long long>
#define PULI pair<unsigned long long,int>
#define PIL pair<int,long long>
#define PSI pair<string,int>
#define PSS pair<string,string>
#define PDD pair<double,double>
#define PIB pair<int,bool>
typedef long double ld;

using namespace std;

int find(int i)
{
	i = i - ((i >> 1) & 0x55555555);
	i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
	return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
}

int main()
{
	int n,m,k;cin>>n>>m>>k;
	vector<int> V;
	FR(i,n){ int a;cin>>a;V.push_back(a);}
	int num;cin>>num;
	int ans = 0;
	FR(i,V.size()) ans += find(num&V[i])>=k;
	cout<<ans<<endl;
}


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
	int n;
	int m;
	int k;
	int test;
	int arr[1000];
	int count=0;
	int ans;
	int l=0;
	int anss=0;
	for(int i=0;i<20;i++)
	{
		arr[i]=0;
	}
	cin>>n;
	cin>>m;
	cin>>k;
	for(int i=0;i<m;i++)
	{
		cin>>arr[i];
	}
	cin>>ans;
	for(int i=0;i<m;i++)
	{
		test=ans;
		while(count<n)
		{
			if(test%2==0 && arr[i]%2==0)
				l++;
			else if( test%2==1 && arr[i]%2==1)
				l++;
			arr[i]=arr[i]/2;
			test=test/2;
			count++;
		}
		count=0;
		if(n-l<=k)
			anss++;
		l=0;
	}
	cout<<anss<<endl;
	return 0;
}


#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
	int n;
	int m;
	int k;
	int test;
	int arr[20];
	int count=0;
	int ans;
	int l=0;
	int anss=0;
	for(int i=0;i<20;i++)
	{
		arr[i]=0;
	}
	cin>>n;
	cin>>m;
	cin>>k;
	for(int i=0;i<m;i++)
	{
		cin>>arr[i];
	}
	cin>>ans;
	for(int i=0;i<m;i++)
	{
		test=ans;
		while(count<n)
		{
			if(test%2==0 && arr[i]%2==0)
				l++;
			else if( test%2==1 && arr[i]%2==1)
				l++;
			arr[i]=arr[i]/2;
			test=test/2;
			count++;
		}
		count=0;
		if(n-l<=k)
			anss++;
		l=0;
	}
	cout<<anss<<endl;
	return 0;
}


#include<stdio.h>
#include<string>
using namespace std;

int tipos,soldados,diferencia,arr[1000+10],original,ind,ind2,auxdif,j,cont;
char bina[30],binaux[30];

int main(){
	scanf("%d%d%d",&tipos,&soldados,&diferencia);
	for(int i=0;i<=soldados;i++) scanf("%d",&arr[i]);
	while(arr[soldados]>0){
		bina[ind]=arr[soldados]%2+'0';
		arr[soldados]/=2;
		ind++;
	}
	for(int i=0;i<soldados;i++){
		ind2=0;
		while(arr[i]>0){
			binaux[ind2]=arr[i]%2+'0';
			arr[i]/=2;
			ind2++;
		}
		for(int h=ind2;h<30;h++) binaux[h]='2';
		auxdif=diferencia;
		for(j=0;j<ind;j++){
			if(bina[j]!=binaux[j]){
				if(auxdif>0) auxdif--;
				else{
					auxdif--;
					break;
				}
			}
		}
		if(j==ind){
			if(binaux[j]!='2'){
				while(binaux[j]!='2'&&auxdif>=0){
					j++;
					auxdif--;
				}
			}
		}
		if(auxdif>=0) cont++;
	}
	printf("%d\n",cont);
}


#include<stdio.h>
#include<string>
using namespace std;

int tipos,soldados,diferencia,arr[1000+10],original,ind,ind2,auxdif,j,cont;
char bina[30],binaux[30];

int main(){
	scanf("%d%d%d",&tipos,&soldados,&diferencia);
	for(int i=0;i<=soldados;i++) scanf("%d",&arr[i]);
	while(arr[soldados]>0){
		bina[ind]=arr[soldados]%2+'0';
		arr[soldados]/=2;
		ind++;
	}
	for(int i=0;i<soldados;i++){
		ind2=0;
		while(arr[i]>0){
			binaux[ind2]=arr[i]%2+'0';
			arr[i]/=2;
			ind2++;
		}
		for(int h=ind2;h<30;h++) binaux[h]='2';
		auxdif=diferencia;
		for(j=0;j<ind;j++){
			if(bina[j]!=binaux[j]){
				if(auxdif>0) auxdif--;
				else{
					auxdif--;
					break;
				}
			}
		}
		if(j==ind){
			if(binaux[j]!='2'){
				while(binaux[j]!='2'||auxdif>0){
					j++;
					auxdif--;
				}
			}
		}
		if(auxdif>=0) cont++;
	}
	printf("%d\n",cont);
}


#include<stdio.h>
#include<string>
using namespace std;

int tipos,soldados,diferencia,arr[1000+10],original,ind,ind2,auxdif,j,cont;
char bina[30],binaux[30];

int main(){
	scanf("%d%d%d",&tipos,&soldados,&diferencia);
	for(int i=0;i<=soldados;i++) scanf("%d",&arr[i]);
	while(arr[soldados]>0){
		bina[ind]=arr[soldados]%2+'0';
		arr[soldados]/=2;
		ind++;
	}
	for(int i=0;i<soldados;i++){
		ind2=0;
		while(arr[i]>0){
			binaux[ind2]=arr[i]%2+'0';
			arr[i]/=2;
			ind2++;
		}
		for(int h=ind2;h<30;h++) binaux[h]='2';
		auxdif=diferencia;
		for(j=0;j<ind;j++){
			if(bina[j]!=binaux[j]){
				if(auxdif>0) auxdif--;
				else{
					auxdif--;
					break;
				}
			}
		}
		if(j==ind){
			if(binaux[j]!='2'){
				while(binaux[j]!='2'||auxdif>=0){
					j++;
					auxdif--;
				}
			}
		}
		if(auxdif>=0) cont++;
	}
	printf("%d\n",cont);
}


#include<stdio.h>
using namespace std;

int tipos, soldados, diferencia,arr[1000+10],cont,auxdif,xor;

int main(){
	scanf("%d%d%d",&tipos,&soldados,&diferencia);
	for(int i=0;i<=soldados;i++) scanf("%d",&arr[i]);
	for(int i=0;i<soldados;i++){
		if((arr[soldados]^arr[i])==0) cont++;
		else{
			xor=arr[soldados]^arr[i];
			auxdif=diferencia;
			while(xor>0&&auxdif>=0){
				if(xor%2==1) auxdif--;
				xor/=2;
			}
			if(auxdif>=0) cont++;
		}
	}
	printf("%d\n",cont);
}