// {{{ by unolight
#include <bits/stdc++.h>
#include <unistd.h>
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC diagnostic ignored "-Wunused-function"
#define SZ(x) ((int)(x).size())
#define ALL(x) begin(x),end(x)
#define RALL(x) rbegin(x),rend(x)
#define REP(i,n) for ( int i=0; i<int(n); i++ )
#define REP1(i,a,b) for ( int i=(a); i<=int(b); i++ )
#define MP make_pair
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef pair<int,int> PII;
typedef vector<int> VI;

namespace { namespace unolight {
// Read Input
template<class T> void _R( T &x ) { cin>>x; }
void _R( int &x ) { scanf("%d",&x); }
void _R( int64_t &x ) { scanf("%" PRId64,&x); }
void _R( double &x ) { scanf("%lf",&x); }
void _R( char &x ) { scanf(" %c",&x); }
void _R( char *x ) { scanf("%s",x); }
void R() {}
template<class T, class... U> void R( T& head, U&... tail ) { _R(head); R(tail...); }
// Write Output
template<class T> void _W( const T &x ) { cout<<x; }
void _W( const int &x ) { printf("%d",x); }
void _W( const int64_t &x ) { printf("%" PRId64,x); }
void _W( const double &x ) { printf("%.16f",x); }
void _W( const char &x ) { putchar(x); }
void _W( const char *x ) { printf("%s",x); }
template<class T> void _W( const vector<T> &x ) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W( const T& head, const U&... tail ) { _W(head); putchar(sizeof...(tail)?' ':'\n'); W(tail...); }

#ifdef UNOLIGHT
#include "dump.hpp"
#else
#define dump(...)
#endif

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}
// }}}

void main() {
    int n;
    R(n);
    VI a(n);
    REP(i,n) R(a[i]);
    chmin(n,8);
    vector<VI> g(200);
    for ( int s=1; s<1<<n; s++ ) {
        VI f;
        int sum=0;
        REP(i,n) if ( s>>i&1 ) {
            sum=(sum+a[i])%200;
            f.PB(i+1);
        }
        if ( SZ(g[sum]) ) {
            W("Yes");
            W(SZ(f),f);
            W(SZ(g[sum]),g[sum]);
            return;
        }
        g[sum]=f;
    }
    W("No");
}

 // {{{ main
}}
int main() { unolight::main(); return 0; }
// }}}

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;

ll a[505][505];
ll b[505][505];

const int INF = 1000000000;

int dist[1000005];
vector <pair <int, int>> graf[1000005];
int n, m;

int hes(int i, int j, int k){
    return k*n*m + (i-1)*m+j;
}

int main(){
    ios_base::sync_with_stdio(false);
	cout.precision(10);
	cout << fixed;

    cin >> n >> m;
    for(int i=1; i<=n; i++){
        for(int j=1; j<m; j++){
            cin >> a[i][j];
        }
    }
    for(int i=1; i<n; i++){
        for(int j=1; j<=m; j++){
            cin >> b[i][j];
        }
    }
    for(int i=1; i<=n; i++){
        for(int j=1; j<=m; j++){
            if(j < m) graf[hes(i, j, 0)].push_back({hes(i, j+1, 0), a[i][j]});
            if(j < m) graf[hes(i, j, 1)].push_back({hes(i, j+1, 0), a[i][j]});
            if(j > 1) graf[hes(i, j, 0)].push_back({hes(i, j-1, 0), a[i][j-1]});
            if(j > 1) graf[hes(i, j, 1)].push_back({hes(i, j-1, 0), a[i][j-1]});
            if(i < n) graf[hes(i, j, 0)].push_back({hes(i+1, j, 0), b[i][j]});
            if(i < n) graf[hes(i, j, 1)].push_back({hes(i+1, j, 0), b[i][j]});
            if(i > 1) graf[hes(i, j, 0)].push_back({hes(i-1, j, 1), 2});
            if(i > 1) graf[hes(i, j, 1)].push_back({hes(i-1, j, 1), 1});
        }
    }
    for(int i=2; i<=2*n*m; i++) dist[i] = INF;
    set <pair <int, int>> q;
    q.insert({0, 1});
    while(!q.empty()){
        pair <int, int> pr = *q.begin();
        q.erase(q.begin());
        int v = pr.second;
        for(auto c : graf[v]){
            if(dist[c.first] > c.second + dist[v]){
                q.erase({dist[c.first], c.first});
                dist[c.first] = c.second + dist[v];
                q.insert({dist[c.first], c.first});
            }
        }
    }
    cout << min(dist[n*m], dist[2*n*m]);
    return 0;
}
