#include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-11;

int w, h;
int bo[40][40];
int c[4];

struct edge {
    int to, cost;
};

int V;
vector<edge> G[1000000];
ll d[1000000];

void addedge(int st, int ed, int co) {
    edge e;
    e.to = ed;
    e.cost = co;
    G[st].push_back(e);
}

void dijkstra(int s) {
    priority_queue<plglg, vector<plglg>, greater<plglg> > que;
    fill(d, d + V + 10, llmax);
    d[s] = 0;
    que.push(plglg(0, s));

    while (!que.empty()) {
        plglg p = que.top();
        que.pop();
        ll v = p.second;
        if (d[v] < p.first) {
            continue;
        }
        int len = G[v].size();
        for (int i = 0; i < len; i++) {
            edge e = G[v][i];
            if (d[e.to] > d[v] + e.cost) {
                d[e.to] = d[v] + e.cost;
                que.push(plglg(d[e.to], e.to));
            }
        }
    }
}

int calcost(int mark, int k, int l) {
    int ans;
    if (l == k) {
        if (mark == 0) {
            ans = 0;
        } else {
            ans = c[0];
        }
    } else if (l == (k + 1) % 4) {
        if (mark == 3) {
            ans = 0;
        } else {
            ans = c[3];
        }
    } else if (l == (k + 2) % 4) {
        if (mark == 2) {
            ans = 0;
        } else {
            ans = c[2];
        }
    } else {
        if (mark == 1) {
            ans = 0;
        } else {
            ans = c[1];
        }
    }
    return ans;
}

int main() {
    while (1) {
        cin >> w >> h;
        if (w == 0) {
            break;
        }
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                cin >> bo[i][j];
            }
        }
        for (int i = 0; i < 4; i++) {
            cin >> c[i];
        }
        V = w * h * 4 + 1;
        for (int i = 0; i < w * h * 4 + 1; i++) {
            G[i].clear();
        }
        for (int i = 0; i < h; i++) {
            for (int j = 0; j < w; j++) {
                for (int k = 0; k < 4; k++) {
                    for (int l = 0; l < 4; l++) {
                        int x = i + dx[l];
                        int y = j + dy[l];
                        if (x >= 0 && x < h && y >= 0 && y < w) {
                            addedge((i * w + j) * 4 + k, (x * w + y) * 4 + l, calcost(bo[i][j], k, l));
                        }
                    }
                }
            }
        }
        for (int i = 0; i < 4; i++) {
            addedge(w * h * 4 - i - 1, w * h * 4, 0);
        }
        // for (int i = 0; i < h; i++) {
        //     for (int j = 0; j < w; j++) {
        //         for (int k = 0; k < 4; k++) {
        //             int len = G[(i * w + j) * 4 + k].size();
        //             for (int l = 0; l < len; l++) {
        //                 edge e = G[(i * w + j) * 4 + k][l];
        //                 cout << e.to << " " << e.cost << " ";
        //             }
        //             cout << " ";
        //         }
        //         cout << " ";
        //     }
        //     cout << endl;
        // }
        dijkstra(1);
        // for (int i = 0; i < h; i++) {
        //     for (int j = 0; j < w; j++) {
        //         for (int k = 0; k < 4; k++) {
        //             cout << d[(i * w + j) * 4 + k] << " ";
        //         }
        //         cout << " ";
        //     }
        //     cout << endl;
        // }
        ll ans = d[w * h * 4];
        cout << ans << endl;
    }
}



Measured memory_bytes: 26912