#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;

const double EPS = 1.0e-10;

class Edge
{
public:
    int to, cost;
    Edge(){};
    Edge(int to0, int cost0){to = to0; cost = cost0;}
};

void shortestPath(const vector<vector<Edge> >& edges, int start, vector<int>& dist)
{
    dist.assign(edges.size(), INT_MAX);
    dist[start] = 0;
    priority_queue<pair<int,int> ,vector<pair<int,int> >, greater<pair<int,int> > > q;
    q.push(make_pair(0, start));

    while(!q.empty()){
        pair<int, int> p = q.top();
        q.pop();
        int v = p.second;
        if(dist[v] < p.first)
            continue;
        for(unsigned i=0; i<edges[v].size(); ++i){
            Edge e = edges[v][i];
            if(dist[v] + e.cost < dist[e.to]){
                dist[e.to] = dist[v] + e.cost;
                q.push(make_pair(dist[e.to], e.to));
            }
        }
    }

    replace(dist.begin(), dist.end(), INT_MAX, -1);
}

int elementaryMatrix(vector<vector<double> >& mat)
{
    const int n = mat.size();
    const int m = mat[0].size();
    int y = 0;
    int x = 0;
    while(y < n && x < m){
        int tmp = y;
        for(int i=y+1; i<n; ++i){
            if(abs(mat[i][x]) > abs(mat[tmp][x]))
                tmp = i;
        }
        if(abs(mat[tmp][x]) > EPS){
            mat[y].swap(mat[tmp]);
            for(int i=y+1; i<n; ++i){
                for(int j=m-1; j>=x; --j){
                    mat[i][j] -= mat[y][j] * (mat[i][x] / mat[y][x]);
                }
            }
            ++ y;
        }
        ++ x;
    }
    mat.resize(y);
    return y;
}

bool linearSystem(vector<vector<double> >& mat, vector<double>& x)
{
    int n = mat[0].size() - 1;
    if(elementaryMatrix(mat) != n || mat[n-1][n-1] == 0)
        return false;

    x.resize(n);
    for(int i=n-1; i>=0; --i){
        x[i] = mat[i][n];
        for(int j=i+1; j<n; ++j)
            x[i] -= mat[i][j] * x[j];
        x[i] /= mat[i][i];
    }
    return true;
}

const int INF = INT_MAX / 4;

int main()
{
    for(;;){
        int n, start, goal;
        cin >> n >> start >> goal;
        if(n == 0)
            return 0;
        -- start;
        -- goal;

        vector<int> q(n);
        for(int i=0; i<n; ++i)
            cin >> q[i];

        vector<vector<Edge> > edges(n);
        for(int i=0; i<n; ++i){
            for(int j=0; j<n; ++j){
                int a;
                cin >> a;
                if(a != 0)
                    edges[i].push_back(Edge(j, a));
            }
        }

        vector<int> dist;
        shortestPath(edges, goal, dist);
        if(dist[start] == -1){
            cout << "Impossible" << endl;
            continue;
        }

        vector<vector<double> > mat(n, vector<double>(n+1, 0.0));
        for(int i=0; i<n; ++i){
            mat[i][i] = 1.0;
            if(i == goal || dist[i] == -1)
                continue;

            if(q[i] == 0){
                for(unsigned j=0; j<edges[i].size(); ++j){
                    int to = edges[i][j].to;
                    int cost = edges[i][j].cost;
                    mat[i][to] = -1.0 / edges[i].size();
                    mat[i][n] += (double)cost / edges[i].size();
                }
            }else{
                int m = 0;
                for(unsigned j=0; j<edges[i].size(); ++j){
                    int to = edges[i][j].to;
                    int cost = edges[i][j].cost;
                    if(dist[i] - cost == dist[to])
                        ++ m;
                }
                for(unsigned j=0; j<edges[i].size(); ++j){
                    int to = edges[i][j].to;
                    int cost = edges[i][j].cost;
                    if(dist[i] - cost == dist[to]){
                        mat[i][to] = -1.0 / m;
                        mat[i][n] += (double)cost / m;
                    }
                }
            }
        }

        vector<double> x;
        linearSystem(mat, x);
        printf("%.10f\n", x[start]);
    }
}

Measured memory_bytes: 1428