#line 2 "header.hpp"

//%snippet.set('header')%
//%snippet.fold()%
#ifndef HEADER_H
#define HEADER_H

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

// varibable settings
const long long INF = 1e18;
template <class T> constexpr T inf = numeric_limits<T>::max() / 2.1;

#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for (ll i = (ll)(a); i < (ll)(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define _rrep(i, n) rrepi(i, 0, n)
#define rrepi(i, a, b) for (ll i = (ll)((b)-1); i >= (ll)(a); --i)
#define r_rep(...) _overload3(__VA_ARGS__, rrepi, _rrep, )(__VA_ARGS__)
#define each(i, a) for (auto &&i : a)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define mt(...) make_tuple(__VA_ARGS__)
#define ub upper_bound
#define lb lower_bound
#define lpos(A, x) (lower_bound(all(A), x) - A.begin())
#define upos(A, x) (upper_bound(all(A), x) - A.begin())
template <class T> inline void chmax(T &a, const T &b) { if ((a) < (b)) (a) = (b); }
template <class T> inline void chmin(T &a, const T &b) { if ((a) > (b)) (a) = (b); }
template <typename X, typename T> auto make_table(X x, T a) { return vector<T>(x, a); }
template <typename X, typename Y, typename Z, typename... Zs> auto make_table(X x, Y y, Z z, Zs... zs) { auto cont = make_table(y, z, zs...); return vector<decltype(cont)>(x, cont); }

#define cdiv(a, b) (((a) + (b)-1) / (b))
#define is_in(x, a, b) ((a) <= (x) && (x) < (b))
#define uni(x) sort(all(x)); x.erase(unique(all(x)), x.end())
#define slice(l, r) substr(l, r - l)

typedef long long ll;
typedef long double ld;
using vl = vector<ll>;
using vvl = vector<vl>;
using pll = pair<ll, ll>;

template <typename T>
using PQ = priority_queue<T, vector<T>, greater<T>>;
void check_input() { assert(cin.eof() == 0); int tmp; cin >> tmp; assert(cin.eof() == 1); }

#if defined(PCM) || defined(LOCAL)
#else
#define dump(...) ;
#define dump_1d(...) ;
#define dump_2d(...) ;
#define cerrendl ;
#endif

#endif /* HEADER_H */
//%snippet.end()%
#line 2 "solve.cpp"
template<class T=ll> using vec = vector<T>;
struct Fast { Fast() { std::cin.tie(0); ios::sync_with_stdio(false); } } fast;

vec<vec<int>> e;

// snippet:GridGraph {{{
template<class Cost=ll>
struct GridGraph {
    using Pos = int;
    int dim;  // 次元
    int h, w;
    int n;    // 頂点数
    vector<int> size;
    vector<int> b;
    int dx[4] = {1, -1, 0, 0};
    int dy[4] = {0, 0, 1, -1};
    GridGraph() {}
    GridGraph(vector<int> _size) : size(_size) {
        dim = sz(size);
        h = size[0];
        w = size[0];
        n = 1;
        rep(i, dim) n *= size[i];
        b.resize(dim);
        b[0] = 1;
        rep(i, 1, dim) b[i] = b[i-1] * size[i-1];
    }

    Pos uid(const vector<int>& r) {
        Pos res = 0;
        rep(i, dim) res += r[i] * b[i];
        return res;
    }
    int operator()(const vector<int>& r) { return uid(r); }

    vector<int> raw(Pos x){
        vector<int> res(dim);
        r_rep(i, dim){
            res[i] = x / b[i];
            x %= b[i];
        }
        return res;
    }

    vector<int> get_adj(int u){
        auto r = raw(u);
        int i = r[0];
        int j = r[1];
        int remcost = r[2];
        vector<int> adj;
        rep(dir, 4) {
            int ni = i + dx[dir];
            int nj = j + dy[dir];
            if (is_in(ni, 0, h) && is_in(nj, 0, w)){
                if (remcost >= e[ni][nj]) adj.push_back(uid({ni, nj, remcost - e[ni][nj]}));
            }
        }
        return adj;
    }

    vector<Cost> dijkstra(vector<Pos> starts) {  // 多点スタート{{{
        vector<Cost> dist(n, 300);           // 最短距離
        // PQ<pair<Cost, Pos>> pq;
        queue<pair<Cost, Pos>> pq;
        each(start, starts) {
            dist[start] = 0;
            pq.push(make_pair(0, start));
        }
        while (!pq.empty()) {
            auto cp = pq.front();
            pq.pop();
            auto [cost, u] = cp;
            auto vs = get_adj(u);
            for (const auto& v : vs) {
                Cost new_cost = cost + 1;
                if (new_cost < dist[v]) {
                    dist[v] = new_cost;
                    pq.push(make_pair(new_cost, v));
                }
            }
        }
        return dist;
    };/*}}}*/

    vector<Cost> dijkstra(Pos start) {  // 1点スタート{{{
        vector<Pos> starts = {start};
        return dijkstra(starts);
    };/*}}}*/
};
// snippet:Graph }}}

int solve() {
    int n,v,sx,sy,gx,gy;cin>>n>>v>>sy>>sx>>gy>>gx;
    sx--;sy--;gx--;gy--;

    e = vec<vec<int>>(n, vec<int>(n));
    rep(i, n)rep(j, n){
        cin>>e[i][j];
    }

    GridGraph<int> g(vec<int>({n, n, 2000}));
    auto d = g.dijkstra(g.uid({sx, sy, min(v, 1999)}));

    int ans = 300;
    for(int r=0; r<2000; r++){
        if (d[g.uid({gx, gy, r})] != 300){
            chmin(ans, d[g.uid({gx, gy, r})]);
        }
    }
    cout << (ans==300 ? -1 : ans) << endl;

    return 0; 
}


int main(){/*{{{*/
    solve();
    check_input();
    return 0;
}/*}}}*/