#include<bits/stdc++.h>

using namespace std;

#define i32 int
#define i64 long long
#define f64 double
#define F0R(i, n) for(int i = 0; i<n; i++)
#define FOR(i, s, e) for(int i = s; i<e; i++)
#define vec vector
#define arr array

struct SegNode {
    arr<i64, 2> mx{-1, 0};
    arr<i64, 2> mn{-1, 0};
};

struct SegTree {
    i32 n;
    vec<SegNode> data;
    vec<i64> lazy;

    SegTree(i32 in) {
        n = 1;
        while(n<in) {
            n*=2;
        }
        data = vec<SegNode>(n*2);
        lazy = vec<i64>(n*2);
    }

    void propagate(i32 i) {
        data[i].mn[1] += lazy[i];
        data[i].mx[1] += lazy[i];
        if(i*2 < n*2) {
            lazy[i*2] += lazy[i];
            lazy[i*2+1] += lazy[i];
        }
        lazy[i] = 0;
    }
    
    SegNode merge(SegNode l, SegNode r) {
        if(l.mn[0] == -1) {
            return r;
        }
        else if(r.mn[0] == -1) {
            return l;
        }

        SegNode res = {};
        if(l.mx[0]+l.mx[1] > r.mx[0]+r.mx[1]) {
            res.mx = l.mx;
        }
        else {
            res.mx = r.mx;
        }
        if(l.mn[0] + l.mn[1] < r.mn[0]+r.mn[1]) {
            res.mn = l.mn;
        }
        else {
            res.mn = r.mn;
        }

        return res;
    }

    SegNode query(i32 l, i32 r, i32 i = 1, i32 ll = 0, i32 rr =  -1) {
        if(rr==-1) rr = n;

        if(ll>=r || rr<=l) {
            return {};
        }
        propagate(i);

        if(ll>=l && rr <=r) {
            return data[i];
        }

        i32 m = (ll+rr)/2;
        SegNode left = query(l, r, i*2, ll, m);
        SegNode right = query(l, r, i*2+1, m, rr);

        return merge(left, right);
    }

    void update(i32 l, i32 r, i64 add, i32 i = 1, i32 ll = 0, i32 rr = -1) {
        if(rr==-1) rr = n;

        propagate(i);

        if(ll>=r || rr <= l) {
            return;
        }


        if(ll>=l && rr<=r) {
            lazy[i] += add;
            propagate(i);
            return;
        }

        i32 m = (ll+rr)>>1;
        update(l, r, add, (i<<1), ll, m);
        update(l, r, add, (i<<1)+1, m, rr);

        data[i] = merge(data[(i<<1)], data[(i<<1)+1]);
    }

    void set(i32 i, i32 val) {
        update(i, i+1, 0); // to propagate all the nodes up to my value
        i+=n;
        // cerr<<data[i].mx[0] <<endl;
        assert(data[i].mx[0] == -1);
        data[i].mx[0] = val;
        data[i].mn[0] = val;
        while(i>1) {
            i>>=1;
            data[i] = merge(data[i<<1], data[(i<<1)+1]);
        }
    }
};

i32 main() {
    cout << setprecision(15);

    i32 n, m, d;
    cin >> n >> m >> d;

    SegTree st(n+m);

    vec<arr<i32, 2>> v(n+m);

    F0R(i, n) {
        cin >> v[i][0];
        v[i][1] = i;
    }

    F0R(i, m) {
        cin >> v[i+n][0];
        v[i+n][1] = i+n;
    }

    auto v_s = v;
    sort(v_s.begin(), v_s.end());

    F0R(i, n+m) {
        v[v_s[i][1]][1] = i;
    }

    i64 ans = 0;

    auto add = [&](i32 i) {
        i32 j = v[i][1];
        st.update(j, n+m, -d);
        st.set(j, v[i][0]);

        SegNode l = st.query(0, j+1);
        i64 lval = l.mx[0]+l.mx[1];
        SegNode r = st.query(j, n+m);
        i64 rval = r.mn[0]+r.mn[1];
        
        ans = max(ans, lval-rval);
    };

    F0R(i, n) {
        add(i);
    }

    F0R(i, m) {
        add(i+n);
        cout << ((f64)ans)/2.0 << '\n';
    }
}