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

// clang-format off
#define forn(i, x, y) for (int i = x; i < y; i++)
#define IOS ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(NULL)
#define all(v) v.begin(), v.end()
// clang-format on

using VI = vector<int>;

template <int n>
class UF
{
public:
    vector<int> par, rank, cnt;
    UF()
    {
        par = rank = vector<int>(n, 0);
        cnt = vector<int>(n, 1);
        forn(i, 0, n) par[i] = i;
    }
    void reset()
    {
        forn(i, 0, n) rank[i] = 0, cnt[i] = 1, par[i] = i;
    }
    int operator[](int x) { return (par[x] == x) ? (x) : (par[x] = operator[](par[x])); }
    int count(int x) { return cnt[operator[](x)]; }
    int operator()(int x, int y)
    {
        if ((x = operator[](x)) == (y = operator[](y)))
            return x;
        cnt[y] = cnt[x] = cnt[x] + cnt[y];
        if (rank[x] > rank[y])
            return par[x] = y;
        rank[x] += rank[x] == rank[y];
        return par[y] = x;
    }
};

int N;
int X[100], Y[100];

struct edge
{
    int u, v;
    double w;
};

int main()
{
    IOS;
    cin >> N;
    forn(i, 0, N) cin >> X[i] >> Y[i];

    vector<edge> edges;
    forn(i, 0, N)
    {
        edges.push_back({i, 100, 100.0 - Y[i]});
        edges.push_back({i, 101, Y[i] + 100.0});
        forn(j, 0, N)
            edges.push_back({i, j, hypot(X[i] - X[j], Y[i] - Y[j])});
    }
    sort(all(edges), [](edge a, edge b) {
        return a.w < b.w;
    });

    UF<102> uf;
    int n = edges.size();
    double res = 0.0;
    forn(i, 0, n)
    {
        edge &e = edges[i];
        uf(e.u, e.v);
        if (uf[100] == uf[101])
        {
            res = e.w / 2;
            break;
        }
    }

    cout << fixed << setprecision(10) << res << endl;

    return 0;
}

#pragma GCC optimize("-Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimize("unroll-loops")
// #include <atcoder/all>
// #include <bits/stdc++.h>
#include <complex>
#include <queue>
#include <set>
#include <unordered_set>
#include <list>
#include <chrono>
#include <random>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <stack>
#include <iomanip>
#include <fstream>

using namespace std;
// using namespace atcoder;

typedef long long ll;
typedef long double ld;
typedef pair<int, int> p32;
typedef pair<ll, ll> p64;
typedef pair<p64, p64> pp64;
typedef pair<double, double> pdd;
typedef vector<ll> v64;
typedef vector<int> v32;
typedef vector<vector<int>> vv32;
typedef vector<vector<ll>> vv64;
typedef vector<vector<p64>> vvp64;
typedef vector<p64> vp64;
typedef vector<p32> vp32;
typedef pair<ll, p64> tp;
ll MOD = 998244353;
double eps = 1e-12;
#define forn(i, e) for (ll i = 0; i < e; i++)
#define forsn(i, s, e) for (ll i = s; i < e; i++)
#define rforn(i, s) for (ll i = s; i >= 0; i--)
#define rforsn(i, s, e) for (ll i = s; i >= e; i--)
#define ln '\n'
#define dbg(x) cout << #x << " = " << x << ln
#define mp make_pair
#define pb push_back
#define fi first
#define se second
#define INF 2e18
#define fast_cin()                    \
    ios_base::sync_with_stdio(false); \
    cin.tie(NULL);                    \
    cout.tie(NULL)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((ll)(x).size())
#define zero ll(0)
#define set_bits(x) __builtin_popcountll(x)
// #define mint modint998244353

ll mpow(ll a, ll b)
{
    if (a == 0)
        return 0;
    if (b == 0)
        return 1;
    ll t1 = mpow(a, b / 2);
    t1 *= t1;
    t1 %= MOD;
    if (b % 2)
        t1 *= a;
    t1 %= MOD;
    return t1;
}

ll mpow(ll a, ll b, ll p)
{
    if (a == 0)
        return 0;
    if (b == 0)
        return 1;
    ll t1 = mpow(a, b / 2, p);
    t1 *= t1;
    t1 %= p;
    if (b % 2)
        t1 *= a;
    t1 %= p;
    return t1;
}

ll modinverse(ll a, ll m)
{
    ll m0 = m;
    ll y = 0, x = 1;
    if (m == 1)
        return 0;
    while (a > 1)
    {
        ll q = a / m;
        ll t = m;
        m = a % m, a = t;
        t = y;
        y = x - q * y;
        x = t;
    }
    if (x < 0)
        x += m0;
    return x;
}

mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());

ll range(ll l, ll r)
{
    return l + mt() % (r - l + 1);
}

ll rev(ll v)
{
    return mpow(v, MOD - 2);
}

ll nc2(ll n)
{
    return (n * (n - 1)) / 2;
}

ll ceil(ll p, ll q)
{
    return (p + q - 1) / q;
}

void solve()
{
    int k, n, m;
    cin >> k >> n >> m;
    v64 arr(k + 1);
    v64 ans(k + 1, 0);
    for (int i = 1; i <= k; i++)
    {
        cin >> arr[i];
        ans[i] = arr[i] * m / n;
    }
    m = m % n;
    // v64 f(k + 1);
    // v64 c(k + 1);
    vp64 temp(k + 1);
    ll sum = 0;
    for (int i = 1; i <= k; i++)
    {
        // f[i] = arr[i] * m / n;
        // c[i] = f[i] + 1;
        temp[i] = {(arr[i] * m) % n,
                   i};
        sum += temp[i].fi;
    }
    int cnt = sum / n;
    sort(temp.begin() + 1, temp.end(), greater<p64>());
    for (int i = 1; i <= cnt; i++)
    {
        ans[temp[i].se]++;
    }
    for (int i = 1; i <= k; i++)
    {
        cout << ans[i] << " ";
    }
}

int main()
{
    fast_cin();
    ll t = 1;
    // cin >> t;
    // mint a = 3;
    // cout << (1 - a).val() << endl;
    forn(i, t)
    {
        // cout << "Case #" << i+1 << ": ";
        solve();
    }
    return 0;
}