import heapq

def dijkstra_heap(s,C):

  #始点sから各頂点への最短距離

  d = [float("inf")] * 10

  used = [False] * 10

  d[s] = 0

  used[s] = True

  edgelist = []

  #edgelist : (sからの暫定(未確定)最短距離,頂点)のリスト

  #edge[s] : sから出る枝の(重み,終点)の配列

  for i,w in enumerate(C[s]):

    heapq.heappush(edgelist,[w,i]) #sの隣の点は枝の重さがそのまま暫定最短距離となる

  while len(edgelist):

    #まだ使われてない頂点の中から最小の距離のものを探す→確定させる

    minedge = heapq.heappop(edgelist)

    #minedge : (sからの(確定)最短距離,頂点)

    v = minedge[1]

    if used[v]:

      continue

    d[v] = minedge[0]

    used[v] = True

    for i,w in enumerate(C[v]):

      if not used[i]:

        heapq.heappush(edgelist,[d[v]+w,i])

  return d



H, W = list(map(int, input().split()))

C = [[] for _ in range(10)]

for i in range(10):

  c = list(map(int, input().split()))

  for j in range(10):

    C[j].append(c[j])

d = dijkstra_heap(1,C)

#print(d)

ans = 0

for i in range(H):

  A = list(map(int, input().split()))

  for a in A:

    if a>=0:

      ans += d[a]

print(ans)
#Warshall Floyd

H, W = list(map(int, input().split()))



def solve():

    d = []

    for i in range(10): #ひとまず枝があるペアは枝の長さをセット

        d.append(list(map(int, input().split())))



    A=[0]*H

    for i in range(H):

        A[i] = list(map(int, input().split()))



    #三重ループ

    for k in range(10):

        for i in range(10):

            for j in range(10):

                d[i][j] = min(d[i][j], d[i][k]+d[k][j])



    ans = 0

    for i in range(H):

        for j in range(W):

            if A[i][j]!=-1:

                ans += d[A[i][j]][1]

    return ans

print((solve()))

import heapq


def dijkstra_heap(s, C):
    # 始点sから各頂点への最短距離
    d = [float("inf")] * 10
    used = [False] * 10
    d[s] = 0
    used[s] = True
    edgelist = []
    # edgelist : (sからの暫定(未確定)最短距離,頂点)のリスト
    # edge[s] : sから出る枝の(重み,終点)の配列
    for i, w in enumerate(C[s]):
        heapq.heappush(edgelist, [w, i])  # sの隣の点は枝の重さがそのまま暫定最短距離となる
    while len(edgelist):
        # まだ使われてない頂点の中から最小の距離のものを探す→確定させる
        minedge = heapq.heappop(edgelist)
        # minedge : (sからの(確定)最短距離,頂点)
        v = minedge[1]
        if used[v]:
            continue
        d[v] = minedge[0]
        used[v] = True
        for i, w in enumerate(C[v]):
            if not used[i]:
                heapq.heappush(edgelist, [d[v] + w, i])
    return d


H, W = list(map(int, input().split()))
C = [[] for _ in range(10)]
for i in range(10):
    c = list(map(int, input().split()))
    for j in range(10):
        C[j].append(c[j])
d = dijkstra_heap(1, C)
# print(d)
ans = 0
for i in range(H):
    A = list(map(int, input().split()))
    for a in A:
        if a >= 0:
            ans += d[a]
print(ans)

# Warshall Floyd
H, W = list(map(int, input().split()))


def solve():
    d = []
    for i in range(10):  # ひとまず枝があるペアは枝の長さをセット
        d.append(list(map(int, input().split())))
    A = [0] * H
    for i in range(H):
        A[i] = list(map(int, input().split()))
    # 三重ループ
    for k in range(10):
        for i in range(10):
            for j in range(10):
                d[i][j] = min(d[i][j], d[i][k] + d[k][j])
    ans = 0
    for i in range(H):
        for j in range(W):
            if A[i][j] != -1:
                ans += d[A[i][j]][1]
    return ans


print((solve()))

-import heapq +# Warshall Floyd +H, W = list(map(int, input().split())) -def dijkstra_heap(s, C): -    # 始点sから各頂点への最短距離 -    d = [float("inf")] * 10 -    used = [False] * 10 -    d[s] = 0 -    used[s] = True -    edgelist = [] -    # edgelist : (sからの暫定(未確定)最短距離,頂点)のリスト -    # edge[s] : sから出る枝の(重み,終点)の配列 -    for i, w in enumerate(C[s]): -        heapq.heappush(edgelist, [w, i])  # sの隣の点は枝の重さがそのまま暫定最短距離となる -    while len(edgelist): -        # まだ使われてない頂点の中から最小の距離のものを探す→確定させる -        minedge = heapq.heappop(edgelist) -        # minedge : (sからの(確定)最短距離,頂点) -        v = minedge[1] -        if used[v]: -            continue -        d[v] = minedge[0] -        used[v] = True -        for i, w in enumerate(C[v]): -            if not used[i]: -                heapq.heappush(edgelist, [d[v] + w, i]) -    return d +def solve(): +    d = [] +    for i in range(10):  # ひとまず枝があるペアは枝の長さをセット +        d.append(list(map(int, input().split()))) +    A = [0] * H +    for i in range(H): +        A[i] = list(map(int, input().split())) +    # 三重ループ +    for k in range(10): +        for i in range(10): +            for j in range(10): +                d[i][j] = min(d[i][j], d[i][k] + d[k][j]) +    ans = 0 +    for i in range(H): +        for j in range(W): +            if A[i][j] != -1: +                ans += d[A[i][j]][1] +    return ans -H, W = list(map(int, input().split())) -C = [[] for _ in range(10)] -for i in range(10): -    c = list(map(int, input().split())) -    for j in range(10): -        C[j].append(c[j]) -d = dijkstra_heap(1, C) -# print(d) -ans = 0 -for i in range(H): -    A = list(map(int, input().split())) -    for a in A: -        if a >= 0: -            ans += d[a] -print(ans) +print((solve()))