### BUGGY CODE ###

import sys
readline = sys.stdin.readline

class Sparsetable:
    def __init__(self, B):
        self.B = B
        self.N = len(B)
        A = list(range(self.N))
        self.bn = self.N.bit_length()
        self.res = [[None]*self.bn for _ in range(self.N)]
        for i in range(self.N):
            self.res[i][0] = A[i]
        
        for dn in range(1, self.bn):
            rn = 1<<(dn-1)
            for h in range(self.N-2*rn+1):
                self.res[h][dn] = self.spf(self.res[h][dn-1], self.res[h+rn][dn-1])
    
    def spf(self, x, y):
        if self.B[x] > self.B[y]:
            return x
        return y
    
    def query(self, h1, h2):
        h2 -= 1
        hl = h2-h1+1
        bh = hl.bit_length()-1
        rh = 1<<bh
        return self.spf(self.res[h1][bh], self.res[h2-rh+1][bh])
    

N, M = map(int, readline().split())
A = [0] + list(map(int, readline().split())) + [0]
for i in range(1, N):
    A[i] += A[i-1]

B = [list(map(int, readline().split())) for _ in range(N)]
B = list(map(list, zip(*B)))

table = [[0]*(N+1) for _ in range(N+1)]

for j in range(M):
    St = Sparsetable(B[j])
    stack = [(0, N)]
    
    while stack:
        l, r = stack.pop()
        
        am = St.query(l, r)
        b = B[j][am]
        table[l][r-1] += b
        table[l][am-1] -= b
        table[am+1][r-1] -= b
        table[am+1][am-1] += b
        if am != l:
            stack.append((l, am))
        if am+1 != r:
            stack.append((am+1, r))
    
for r in range(N-1, -1, -1):
    for l in range(1, r+1):
        table[l][r] += table[l-1][r]
for r in range(N-2, -1, -1):
    for l in range(r+1):
        table[l][r] += table[l][r+1]

ans = 0
for i in range(N):
    for j in range(i+1, N+1):
        ans = max(ans, table[i][j-1] - (A[j-1] - A[i]))

print(ans)


### FIXED CODE ###

import sys
readline = sys.stdin.readline

N, M = map(int, readline().split())
A = [0] + list(map(int, readline().split()))
for i in range(1, N):
    A[i] += A[i-1]

INF = 10**9+7
B = [list(map(int, readline().split())) for _ in range(N)] + [[INF]*M] + [[0]*M]
right = [[0]*M for _ in range(N)]

for m in range(M):
    L = list(range(N))
    L.sort(key = lambda x: B[x][m])
    RR = list(range(1, N+3))
    LL = list(range(-1, N+1))
    for vn in L:
        vn += 1
        right[vn-1][m] = RR[vn]-1
        RR[LL[vn]] = RR[vn]
        LL[RR[vn]] = LL[vn]

diff = [0]*(N+1)
for m in range(M):
    diff[0] += B[0][m]
    pre = B[0][m]
    for i in range(1, N):
        if B[i][m] > pre:
            diff[i] += B[i][m]-pre
            pre = B[i][m]

offset = 0
ans = 0
for l in range(N):
    offset += diff[l]
    for m in range(M):
        if B[l][m] < B[l-1][m]:
            oldr = right[l-1][m]
            diff[oldr] -= B[oldr][m] - B[l-1][m]
            offset += B[l][m] - B[l-1][m]
            cnt = l
            while cnt < N and right[cnt][m] <= oldr:
                rcm = right[cnt][m]
                diff[rcm] += B[rcm][m] - B[cnt][m]
                cnt = rcm
    ans = max(ans, offset)
    roff = offset
    for r in range(l+1, N):
        roff += diff[r]
        ans = max(ans, roff - (A[r]-A[l]))
        #print(l, r, roff - (A[r] - A[l]))

print(ans)