//不等,不问,不犹豫,不回头.

//这类题真的好难搞啊.....

//首先要想统计一个子节点的贡献,必须知道他所有祖宗的状态,所以就有了这种做法,在dfs时一遍枚举

//当前结点的贡献一遍往下递归.这样当到最底层时,其所有祖宗的状态就已经知道了,其叶节点的贡献也就

//容易知道了.回溯时再向父结点转移.

#include<bits/stdc++.h>

#define _ 0

#define db double

#define RE register

#define ll long long

#define P 1000000007

#define INF 1000000000

#define get(x) x=read()

#define PLI pair<ll,int>

#define PII pair<int,int>

#define max(a,b) (a>b?a:b)

#define min(a,b) (a<b?a:b)

#define pb(x) push_back(x)

#define ull unsigned long long

#define getc(c) scanf("%s",c+1)

#define put(x) printf("%d\n",x)

#define putl(x) printf("%lld\n",x)

#define rep(i,x,y) for(RE int i=x;i<=y;++i)

#define fep(i,x,y) for(RE int i=x;i>=y;--i)

#define go(x) for(int i=link[x],y=a[i].y;i;y=a[i=a[i].next].y)

using namespace std;

const int N=2500;

int n,m,w[N][15],f[N][15],num,dp[N][N];

inline int read()

{

    int x=0,ff=1;

    char ch=getchar();

    while(!isdigit(ch)) {if(ch=='-') ff=-1;ch=getchar();}

    while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}

    return x*ff;

}

inline void dfs(int x,int s,int sz)//1打仗,0后勤.

{

    rep(i,0,sz) dp[x][i]=0;

    if(sz==1)

    {

        rep(i,0,n-2) if(!(s&1<<i)) dp[x][0]+=f[x][i+1];

        rep(i,0,n-2) if(s&1<<i)    dp[x][1]+=w[x][i+1];

        return;

    }

    rep(k,0,1)

    {

        dfs(x<<1,s<<1|k,sz>>1);dfs(x<<1|1,s<<1|k,sz>>1);

        rep(i,0|k,min(sz,m)) rep(j,0,i)

            dp[x][i]=max(dp[x][i],dp[x<<1][j]+dp[x<<1|1][i-j]);

    }

}

int main()

{

    //freopen("1.in","r",stdin);

    get(n);get(m);num=1<<n-1;

    rep(i,num,num*2-1) rep(j,1,n-1) get(w[i][j]);

    rep(i,num,num*2-1) rep(j,1,n-1) get(f[i][j]);

    dfs(1,0,(1<<n)-1);

    int ans=0;

    rep(i,0,m) ans=max(ans,dp[1][i]);

    put(ans);

    return (0^_^0);

}

//以吾之血,祭吾最后的亡魂

//不等,不问,不犹豫,不回头.

//观察这道网络收费的题,如果我们将贡献放到非叶子节点上的话,进行dp就比较合理了

//首先观察题意可以归纳出以下结论:若两个叶结点不同,必然贡献f[i][j]的贡献,相同的话若状态为lca

//的多数叶子结点的状态的话,则无贡献.否则贡献为2*f[i][j].

//首先要解决的问题便是点对之间的贡献如何处理.因为这个限制我们在处理一个点时,必须考虑其他点

//的影响,这使得求解起来非常麻烦.考虑将两个点对的贡献放到其lca处.我们额外给非叶子结点状态0/1

//表示其子树内哪个状态比较多,0表示子树内1偏多,1表示子树内0偏多,如果一个叶子结点与其状态不同

//必然付出f的代价.否则无代价.发现这和题目的限制是相应的.之前一直不理解这个意思,现在恍然大悟.

//当状态不同时,他要累加上其他所有点的代价,因为不管另一个点是什么,他已经会造成1的代价了.

//至于另一个如果也造成代价的话,我们枚举另一个点时会计算上的.

//之后发现一个点的贡献与其所有的祖宗结点相关,和战争调度类似在dfs时直接带上祖宗的状态即可.

#include<bits/stdc++.h>

#define _ 0

#define db double

#define RE register

#define ll long long

#define P 1000000007

#define INF 1000000000

#define get(x) x=read()

#define PLI pair<ll,int>

#define PII pair<int,int>

#define max(a,b) (a>b?a:b)

#define min(a,b) (a<b?a:b)

#define pb(x) push_back(x)

#define ull unsigned long long

#define getc(c) scanf("%s",c+1)

#define put(x) printf("%d\n",x)

#define putl(x) printf("%lld\n",x)

#define rep(i,x,y) for(RE int i=x;i<=y;++i)

#define fep(i,x,y) for(RE int i=x;i>=y;--i)

#define go(x) for(int i=link[x],y=a[i].y;i;y=a[i=a[i].next].y)

using namespace std;

const int N=(1<<11)+10;

int dp[N][N],v[N][N],n,ori[N],cv[N],lq[N],rq[N];

inline int read()

{

    int x=0,ff=1;

    char ch=getchar();

    while(!isdigit(ch)) {if(ch=='-') ff=-1;ch=getchar();}

    while(isdigit(ch)) {x=(x<<1)+(x<<3)+(ch^48);ch=getchar();}

    return x*ff;

}

inline void dfs(int x,int l,int r,int s,int dep)

{

    rep(i,0,r-l+1) dp[x][i]=INF;

    if(l==r)

    {

        dep--;

        dp[x][0]=dp[x][1]=0;

        if(ori[l]) dp[x][1]=cv[l];//注意这里1指的是0的状态比1多,所以此时其实上x的状态为0.

        else dp[x][0]=cv[l];

        rep(i,1,dep)

        {

            int mid=(lq[i]+rq[i])>>1;

            if(s&1<<dep-i)

            {

                if(l<=mid) dp[x][0]+=v[l][rq[i]]-v[l][mid];

                else dp[x][0]+=v[l][mid]-v[l][lq[i]-1];

            }

            else

            {

                if(l<=mid) dp[x][1]+=v[l][rq[i]]-v[l][mid];

                else dp[x][1]+=v[l][mid]-v[l][lq[i]-1];

            }

        }

        return;

    }

    int mid=l+r>>1;

    int len=r-l+1;

    lq[dep]=l;rq[dep]=r;

    dfs(x<<1,l,mid,s<<1,dep+1);

    dfs(x<<1|1,mid+1,r,s<<1,dep+1);

    rep(i,0,len/2-1) rep(j,0,i) dp[x][i]=min(dp[x][i],dp[x<<1][j]+dp[x<<1|1][i-j]);

//注意这里0的个数只能限制为0 - len/2-1.因为我们这里的0状态实际上是文中的模式A.

//而上面我们已经强制让这个点选了状态0,说明此时1的状态多余0的状态,所以0的数量只能不足一半.

    dfs(x<<1,l,mid,s<<1|1,dep+1);

    dfs(x<<1|1,mid+1,r,s<<1|1,dep+1);

    rep(i,len/2,len) rep(j,0,i) dp[x][i]=min(dp[x][i],dp[x<<1][j]+dp[x<<1|1][i-j]);

}

int main()

{

    //freopen("1.in","r",stdin);

    get(n);n=1<<n;//所有的叶子结点个数.

    rep(i,1,n) get(ori[i]);

    rep(i,1,n) get(cv[i]);

    rep(i,1,n-1) rep(j,i+1,n) get(v[i][j]),v[j][i]=v[i][j];

    rep(i,1,n) rep(j,1,n) v[i][j]+=v[i][j-1];

    memset(dp,0x3f,sizeof(dp));

    dfs(1,1,n,0,1);

    int ans=INT_MAX;

    rep(i,0,n) ans=min(ans,dp[1][i]);

    put(ans);

    return (0^_^0);

}

//以吾之血,祭吾最后的亡魂