#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;
using LL = long long;

const int N = 2.5e5 + 5, M = 18;
const LL Inf = 1e18;

int n, k; 
LL a[N], f[N];
int b[N], rt[N], p[N];

struct S {
  int l, r, v;
}; 

namespace Seg {
  const int T = N * 32;
  const int V = 1e9;

  int tot, lc[T], rc[T], siz[T];
  LL sum[T];

  void Add (int &k, int t, int x, int L = 1, int R = V) {
    k = ++tot;
    siz[k] = siz[t] + 1;  
    sum[k] = sum[t] + x;
    if (L == R) return; 
    int mid = (L + R) >> 1;
    if (x <= mid) {
      rc[k] = rc[t];
      Add(lc[k], lc[t], x, L, mid);
    }
    else {
      lc[k] = lc[t];
      Add(rc[k], rc[t], x, mid + 1, R);
    }
  }

  LL Query (int lk, int rk, int x, int L = 1, int R = V) {
    if (L == R) return 1ll * x * L;
    int mid = (L + R) >> 1, rcnt = siz[rc[rk]] - siz[rc[lk]];
    if (x <= rcnt)
      return Query(rc[lk], rc[rk], x, mid + 1, R);
    else 
      return Query(lc[lk], lc[rk], x - rcnt, L, mid) + sum[rc[rk]] - sum[rc[lk]]; 
  }

  int Query2 (int lk, int rk, int x, int L = 1, int R = V) {
    if (L == R) return L; 
    int mid = (L + R) >> 1, rcnt = siz[rc[rk]] - siz[rc[lk]];
    if (x <= rcnt) 
      return Query2(rc[lk], rc[rk], x, mid + 1, R);
    else
      return Query2(lc[lk], lc[rk], x - rcnt, L, mid);
  }

  LL Query_kmax (int l, int r, int k) {
    return Query(rt[l - 1], rt[r], k);
  }

  int Query_kth (int l, int r, int k) {
    return Query2(rt[l - 1], rt[r], k);
  }
}

LL G (int l, int r) {
  return Seg::Query_kmax(l, r, k) - a[r] + a[l - 1];
}

void Solve (int l, int r, int L, int R) {
  if (l > r) return; 
  int mid = (l + r) >> 1, mp = L;
  LL mv = -Inf;
  for (int p = L; p <= min(mid - k + 1, R); ++p) {
    LL v = G(p, mid);
    if (v >= mv)
      mv = v, mp = p; 
  }
  f[mid] = mv, p[mid] = mp;
  Solve(l, mid - 1, L, mp);
  Solve(mid + 1, r, mp, R);
}

namespace Seg2 {
  #define lc (k << 1)
  #define rc ((k << 1) | 1)

  const int T = N * 4;
  int tag[T];

  void Build () {
    fill(tag, tag + (n * 4) + 1, -1);
  }

  void Node_assign (int k, int x) {
    tag[k] = x; 
  }

  void Pushdown (int k) {
    if (tag[k] != -1) {
      Node_assign(lc, tag[k]);
      Node_assign(rc, tag[k]);
      tag[k] = -1;
    }
  }

  void Assign (int k, int l, int r, int x, int L = 1, int R = n) {
    if (l <= L && r >= R) {
      Node_assign(k, x);
      return; 
    }
    Pushdown(k);
    int mid = (L + R) >> 1;
    if (l <= mid) {
      Assign(lc, l, r, x, L, mid);
    }
    if (r > mid) {
      Assign(rc, l, r, x, mid + 1, R);
    }
  }

  void Dfs (int k, int L = 1, int R = n) {
    if (L == R) {
      cout << (tag[k] != -1 && tag[k] <= b[L] ? '1' : '0'); 
      return; 
    }
    Pushdown(k);
    int mid = (L + R) >> 1;
    Dfs(lc, L, mid);
    Dfs(rc, mid + 1, R);
  }

  #undef lc 
  #undef rc
}

int main () {
  // freopen("s1g1_7.in", "r", stdin);
  // freopen("s1g1_7.out", "w", stdout);
  cin.tie(0)->sync_with_stdio(0);
  cin >> n >> k;
  for (int i = 1; i <= n; ++i) {
    cin >> a[i], a[i] += a[i - 1];
  }
  for (int i = 1; i <= n; ++i) { 
    cin >> b[i];
    Seg::Add(rt[i], rt[i - 1], b[i]);
  } 
  Solve(k, n, 1, n);
  LL ans = -Inf;
  for (int i = k; i <= n; ++i) {
    ans = max(ans, f[i]);
  }
  cout << ans << '\n';
  int la = 0; 
  vector<S> sv;
  for (int i = k; i <= n; ++i) {
    if (f[i] == ans) {
      int &j = p[i];
      for (int t = la; t <= j; ++t) {
        if (G(t, i) == ans)
          sv.push_back(S({t, i, Seg::Query_kth(t, i, k)}));
      } 
      la = j;
    }
  }
  auto cmp = [&](S a, S b) -> bool {
    return a.v > b.v;
  }; 
  sort(sv.begin(), sv.end(), cmp);
  Seg2::Build();
  for (auto s : sv) {
    Seg2::Assign(1, s.l, s.r, s.v);
  }
  Seg2::Dfs(1), cout << '\n';
  return 0; 
}