#include <bits/stdc++.h>

#define el '\n'

typedef long long ll;
typedef long double ld;

#define Beevo ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;

void testCase() {
    int i,j,k,n, m;

    cin>>n >> m;

    int x[n], y[n];
    for (i = 0; i < n; i++)
        cin >> x[i] >> y[i];

    vector<int> g[n];

    int u, v;
    while (m--) {
        cin >> u >> v;

        u--, v--;

        g[u].push_back(v);
        g[v].push_back(u);
    }

    ld matX[n][n + 1], matY[n][n + 1];

    memset(matX, 0, sizeof matX);
    memset(matY, 0, sizeof matY);

    for (i = 0; i < n; i++) {
        if (~x[i]) {
            matX[i][i] = 1, matX[i][n] = x[i];

            continue;
        }

        matX[i][i] = -(int)g[i].size();

        for (auto &l: g[i]) {
            if (x[l] == -1)
                matX[i][l] = 1;
            else
                matX[i][n] -= x[l];
        }
    }

    for (i = 0; i < n; i++) {
        if (~y[i]) {
            matY[i][i] = 1, matY[i][n] = y[i];

            continue;
        }

        matY[i][i] = -(int)g[i].size();

        for (auto &l: g[i]) {
            if (y[l] == -1)
                matY[i][l] = 1;
            else
                matY[i][n] -= y[l];
        }
    }

    ld resX[n], resY[n];

    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(abs(matX[i][i]) < abs(matX[j][i]))
            {
                for(k=0;k<n+1;k++)
                {
                    /* swapping matX[i][k] and matX[j][k] */
                    matX[i][k]= matX[i][k] + matX[j][k];
                    matX[j][k]= matX[i][k] - matX[j][k];
                    matX[i][k]= matX[i][k] - matX[j][k];
                }
            }
        }
    }

    /* performing Gaussian elimination */
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            ld f= matX[j][i] / matX[i][i];
            for(k=0;k<n+1;k++)
            {
                matX[j][k]= matX[j][k] - f * matX[i][k];
            }
        }
    }
    /* Backward substitution for discovering values of unknowns */
    for(i=n-1;i>=0;i--)
    {
        resX[i]=matX[i][n];

        for(j=i+1;j<n;j++)
        {
            if(i!=j)
            {
                resX[i]= resX[i] - matX[i][j] * resX[j];
            }
        }
        resX[i]= resX[i] / matX[i][i];
    }


    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(abs(matY[i][i]) < abs(matY[j][i]))
            {
                for(k=0;k<n+1;k++)
                {
                    /* swapping matX[i][k] and matX[j][k] */
                    matY[i][k]= matY[i][k] + matY[j][k];
                    matY[j][k]= matY[i][k] - matY[j][k];
                    matY[i][k]= matY[i][k] - matY[j][k];
                }
            }
        }
    }

    /* performing Gaussian elimination */
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            ld f= matY[j][i] / matY[i][i];
            for(k=0;k<n+1;k++)
            {
                matY[j][k]= matY[j][k] - f * matY[i][k];
            }
        }
    }
    /* Backward substitution for discovering values of unknowns */
    for(i=n-1;i>=0;i--)
    {
        resY[i]=matY[i][n];

        for(j=i+1;j<n;j++)
        {
            if(i!=j)
            {
                resY[i]= resY[i] - matY[i][j] * resY[j];
            }
        }
        resY[i]= resY[i] / matY[i][i];
    }

    for (i = 0; i < n; i++)
        cout << fixed << setprecision(7) << resX[i] << ' ' << resY[i] << el;
}

signed main() {
    Beevo

    int t = 1;
//    cin >> t;

    while (t--)
        testCase();

    return 0;
}