#include <vector>
#include <iostream>
#include <map>

using namespace std;

const double eps = 1e-12; // stała przybliżenia zera
double d = 0.85;

bool gauss(vector <vector<double>> &AB, vector<double> &X)
{
    int i,j,k,n;
    double m,s;
    n=AB.size(); // ilosc wierszy

    // usuwanie zer z przekatnej
    for(i = 0; i < n - 1; i++)
    {
        if(abs(AB[i][i]) < eps) // 0
        {
            for(j = 0; j < n - 1; j++)
            {
                if (j==i)
                    continue;
                if (AB[j][i] >= eps && AB[i][j] >= eps)
                {
                    vector<double> tmp = AB[i];
                    AB[i] = AB[j];
                    AB[j] = tmp;
                    i = 0;
                }
            }
        }
    }


    // eliminacja
    for(i = 0; i < n - 1; i++)
    {
        for(j = i + 1; j < n; j++)
        {
            // zero na przekatnej
            if(fabs(AB[i][i]) < eps) return false;
            m = -AB[j][i] / AB[i][i];
            for(k = i + 1; k <= n; k++)
                AB[j][k] += m * AB[i][k];
        }
    }

    // wyliczanie niewiadomych
    for(i = n - 1; i >= 0; i--)
    {
        s = AB[i][n];
        for(j = n - 1; j >= i + 1; j--)
            s -= AB[i][j] * X[j];
        // zero na przekatnej
        if(fabs(AB[i][i]) < eps) return false;
        X[i] = s / AB[i][i];
    }
    return true;
}


bool wczytaj(map<int, int> &mapa , vector <double> &ilosc, vector< vector<double> > &macierz_sasiedztwa)
{
    int currId = 0;

    int src, dst;
    int count = 0;
    while (!cin.eof())
    {
        int idSrc, idDst;

        cin >> src >> dst;
        if (cin.eof())
            break;

        if (mapa.count(src) == 0)
        {
            mapa[src] = currId;
            idSrc = currId;
            currId++;
        }
        else
            idSrc = mapa[src];

        if (mapa.count(dst) == 0)
        {
            mapa[dst] = currId;
            idDst = currId;
            currId++;
        }
        else
            idDst = mapa[dst];


        // powiekszanie wektorow

        //if (idSrc > count)
        //  count = idSrc;
        //if (idDst > count)
        //  count = idDst;
        //while(ilosc.size() <= count)
        //  ilosc.push_back( 0 );
        //while(macierz_sasiedztwa.size() <= count)
        //{
        //  macierz_sasiedztwa.push_back(vector<double>());
        //}
        //for(int i=0; i<macierz_sasiedztwa.size(); i++)
        //{
        //  while (macierz_sasiedztwa[i].size() <= count)
        //  {
        //      macierz_sasiedztwa[i].push_back( 0 );
        //  }
        //}


        /*ilosc[idSrc]++;*/
        //macierz_sasiedztwa[idDst][idSrc] = 1;

    }

    return true;
}




void wypisz_macierz(vector< vector<double> > &sasiedztwo)
{
    for(int i=0; i<sasiedztwo.size(); i++)
    {
        for(int j=0; j<sasiedztwo[i].size(); j++)
        {
            cout << sasiedztwo[i][j] << "\t";
        }
        cout << endl;
    }
}

void pomnoz_razy_macierz_diagonalna(vector<double> &ilosc, vector< vector<double> > &sasiedztwo)
{

    for(int i=0; i<ilosc.size(); i++)
    {
        // dodanie krawedzi do wszystkich
        if (!(ilosc[i] > 0))
        {
            ilosc[i] = sasiedztwo[i].size()-1;
            for (int j=0; j<sasiedztwo[i].size(); j++)
            {
                if (i==j)
                    continue;
                sasiedztwo[j][i] = 1;
            }
        }

        for(int j=0; j<sasiedztwo[i].size(); j++)
        {
            sasiedztwo[j][i] *= d/ilosc[i];
        }
    }
}

void dodaj_kolumne(vector< vector<double> > &sasiedztwo)
{
    for(int i=0; i<sasiedztwo.size(); i++)
    {
        sasiedztwo[i].push_back( (1.0-d) / double(sasiedztwo.size()) );
    }
}


void I_odj_macierz(vector< vector<double> > &sasiedztwo)
{
    for(int i=0; i<sasiedztwo.size(); i++)
    {
        for(int j=0; j<sasiedztwo[i].size(); j++)
        {
            sasiedztwo[i][j] = 0-sasiedztwo[i][j];
            sasiedztwo[i][j] += i==j;
        }
    }
}



int main()
{



    vector<double> ilosc;
    vector< vector<double> > sasiedztwo;
    map<int, int> mapa;


    wczytaj(mapa, ilosc, sasiedztwo);

    //wypisz_macierz(sasiedztwo);

    pomnoz_razy_macierz_diagonalna(ilosc, sasiedztwo);

    //wypisz_macierz(sasiedztwo);

    I_odj_macierz(sasiedztwo);

    dodaj_kolumne(sasiedztwo);

    wypisz_macierz(sasiedztwo);

    vector<double> X;
    for(int i=0; i<sasiedztwo.size(); i++)
        X.push_back( 0 );

    bool done;
    done = gauss(sasiedztwo, X);

    int abc = 0;


    //vector<double> wers;
    //vector<vector<double>> AB;
    //wers.push_back(0);
    //wers.push_back(1);
    //wers.push_back(2);

    //wers.push_back(1);
    //AB.push_back(wers);
    //wers.clear();

    //wers.push_back(1);
    //wers.push_back(0);
    //wers.push_back(3);

    //wers.push_back(1);
    //AB.push_back(wers);
    //wers.clear();

    //wers.push_back(1);
    //wers.push_back(1);
    //wers.push_back(1);

    //wers.push_back(1);
    //AB.push_back(wers);
    //wers.clear();

    //bool done;
    //done = gauss(AB, X);





    return 0;
}