#include <bits/stdc++.h>
using namespace std;

#define FOR(i, n) for (int i = 0; i < int(n); ++i)
#define FO(i, a, b) for (int i = (a); i < int(b); ++i)
#define OF(i, a, b) for (int i = (b)-1; i >= int(a); --i)

#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MAX(a, b) ((b) < (a) ? (a) : (b))

#define REMIN(a, b) ((a) = min(a, b))
#define REMAX(a, b) ((a) = max(a, b))

#define ALL(c) (c).begin(), (c).end()

#define SQR(x) ((x) * (x))

//

// 1-based indices
class Splay {

  struct Node {
    //
    // EDIT HERE:
    long long y = 0;
    long long yAdd = 0;
    //
    int num = 1;
    //

    int c[2] = {0, 0}; // children
    int p = 0;         // parent
  };

  vector<Node> v;

public:
  void propagate(int x) {
    if (!x)
      return;

    v[x].y += v[x].yAdd;

    if (v[x].c[0])
      v[v[x].c[0]].yAdd += v[x].yAdd;

    if (v[x].c[1])
      v[v[x].c[1]].yAdd += v[x].yAdd;

    v[x].yAdd = 0;
  }

  void aggregate(int x) {
    v[x].num = 1;
    FOR(ch, 2) if (v[x].c[ch]) v[x].num += v[v[x].c[ch]].num;
  }

  void aggregate_to_root(int x) {
    while (x) {
      aggregate(x);
      x = v[x].p;
    }
  }

  Splay() : v(1) {}
  Splay(int size) : v(size + 1) {}

  int is_ith(int x) const { return v[v[x].p].c[1] == x; }

  void rotate(int x) {
    // cerr << "rotate " << x << endl;

    int ith = is_ith(x);
    int p = v[x].p;       // parent
    int g = v[p].p;       // grand-parent
    int i = v[x].c[!ith]; // inner child

    // propagate(g);
    propagate(p);
    propagate(x);
    // propagate(i);

    v[x].p = g;
    if (g)
      v[g].c[is_ith(p)] = x;

    v[x].c[!ith] = p;
    v[p].p = x;

    v[p].c[ith] = i;
    v[i].p = p;

    aggregate(p);
    aggregate(x);
  }

  void splay_to_root(int x) {
    // cerr << "splay_to_root " << x << endl;
    for (;;) {
      int p = v[x].p; // parent
      if (!p)
        break;

      int g = v[p].p;
      if (!g) {
        rotate(x);
        break;
      }

      if (is_ith(x) == is_ith(p)) {
        rotate(p);
        rotate(x);
      } else {
        rotate(x);
        rotate(x);
      }
    }
    propagate(x);
    aggregate(x);
  }

  // assumes:
  //   each element in x <= each element in y
  int merge(int x, int y) {
    splay_to_root(x);

    while (v[y].c[0])
      y = v[y].c[0];
    splay_to_root(y);

    v[x].p = y;
    v[y].c[0] = x;

    return y;
  }

  // split tree into 2 trees of elements (_ < x) and (_ >= x)
  pair<int, int> split(int x) {
    splay_to_root(x);
    int c0 = v[x].c[0];
    if (c0) {
      v[x].c[0] = 0;
      v[c0].p = 0;
    }
    return {c0, x};
  }

  // find first element that satisfies `pred(idx)`,
  // assuming `pred` is monotonic: first `false`, then `true`
  template <class PRED> int lower_bound(int x, const PRED &pred) {
    splay_to_root(x);
    // cerr << "lower_bound " << x << endl;
    int cand = 0;
    for (;;) {
      auto r = pred(x);
      if (r) {
        // cerr << "  cand " << x << endl;
        cand = x;
      }

      int next = v[x].c[!r];
      // cerr << "  next " << next << endl;
      if (!next) {
        splay_to_root(x);
        break;
      }

      x = next;
    }
    return cand;
  }

  // repeat for all x, while fun(x) == true
  template <class FUN> void each_descendant(int x, const FUN &fun) {
    if (!x)
      return;

    each_descendant(v[x].c[0], fun);
    if (!fun(x))
      return;
    each_descendant(v[x].c[1], fun);
  }

  template <class FUN> void each(int x, const FUN &fun) {
    splay_to_root(x);
    each_descendant(x, fun);
  }

  // this can't splay, because can be called from within lambdas
  int next(int x, bool forward = true) {
    propagate(x);
    if (v[x].c[forward]) {
      x = v[x].c[forward];
      propagate(x);
      while (v[x].c[!forward]) {
        x = v[x].c[!forward];
        propagate(x);
      }
      return x;
    } else
      for (;;) {
        int p = v[x].p;
        if (!p)
          return 0;

        propagate(p);

        if (is_ith(x) != forward)
          return p;
        x = p;
      }
  }

  int prev(int x) { return next(x, false); }

  int first(int x) {
    splay_to_root(x);
    while (v[x].c[0])
      x = v[x].c[0];
    splay_to_root(x);
    return x;
  }

  int last(int x) {
    splay_to_root(x);
    while (v[x].c[1])
      x = v[x].c[1];
    splay_to_root(x);
    return x;
  }

  // helpers
  Node &operator[](int i) { return v[i]; }
};

//

const int N = 100'000 + 9;

int n, k;
int input[N][2];

int res[N][3];

// long long dp[N][2];
// bitset<N> from[N / 2];

bool test(long long limit) {
  // cerr << "test " << limit << endl;

  Splay splay(N);
  int nextIndex = 1;
  int anyIndex = 0;
  long long level = 0;

  splay[nextIndex].y = 0;
  anyIndex = nextIndex;
  ++nextIndex;

  int erasedFront = 0;

  FOR(i, n) {
    // find intersection (element to duplicate)
    int x = anyIndex;
    int foundX = 0;
    splay.splay_to_root(x);
    while (x) {
      splay.propagate(x);
      auto y0 = splay[x].y;
      REMAX(y0, level);

      auto prev = splay.prev(x);
      if (prev == 0) { // first element too small
        x = splay[x].c[1];
        continue;
      }
      // splay.splay_to_root(prev);
      auto y1 = splay[prev].y;
      REMAX(y1, level);

      auto cand0 = y0 + input[i][1];
      auto cand1 = y1 + input[i][0];

      // splay.splay_to_root(x);

      if (cand1 <= cand0) {
        foundX = x;
        x = splay[x].c[0];
      } else {
        x = splay[x].c[1];
      }
    }

    if (!anyIndex)
      return true;

    int dup = splay.last(anyIndex);
    if (foundX)
      dup = splay.prev(foundX);

    // cerr << "foundX y==" << splay[foundX].y << endl;

    assert(dup);

    splay.splay_to_root(dup);
    REMAX(splay[dup].y, level);
    auto dupY = splay[dup].y;

    auto dupNext = splay.next(dup);

    if (dupNext) {
      assert(splay[dupNext].c[0] == 0);
      splay[dupNext].c[0] = nextIndex;
      splay[nextIndex].p = dupNext;
      splay.aggregate_to_root(dupNext);
      splay.splay_to_root(nextIndex);
    } else {
      assert(splay[dup].c[1] == 0);
      splay[dup].c[1] = nextIndex;
      splay[nextIndex].p = dup;
      splay.aggregate_to_root(dup);
      splay.splay_to_root(nextIndex);
    }
    // splay[nextIndex].y = max(0LL, dupY);
    splay[nextIndex].y = dupY;

    auto yMod = input[i][0] - input[i][1];
    splay[nextIndex].y += yMod;
    if (splay[nextIndex].c[1])
      splay[splay[nextIndex].c[1]].yAdd += yMod;

    splay[nextIndex].yAdd += input[i][1];
    ++nextIndex;

    level = max(0LL, level + min(input[i][0], input[i][1]));

    bool dup_was_before = false;
    bool dup_was_after = false;

    // remove too big elements from beginning and end

    for (;;) {
      if (anyIndex == 0)
        break;

      splay.splay_to_root(anyIndex);
      anyIndex = splay.first(anyIndex);
      splay.splay_to_root(anyIndex);
      if (max(level, splay[anyIndex].y) < limit)
        break;

      ++erasedFront;
      if (anyIndex == dup)
        dup_was_before = true;

      anyIndex = splay[anyIndex].c[1];
      if (anyIndex)
        splay[anyIndex].p = 0;
    }

    for (;;) {
      if (anyIndex == 0)
        break;

      splay.splay_to_root(anyIndex);
      anyIndex = splay.last(anyIndex);
      splay.splay_to_root(anyIndex);
      if (max(level, splay[anyIndex].y) < limit)
        break;

      if (anyIndex == dup)
        dup_was_after = true;

      anyIndex = splay[anyIndex].c[0];
      if (anyIndex)
        splay[anyIndex].p = 0;
    }

    splay.splay_to_root(anyIndex);

    res[i][0] = erasedFront;
    res[i][2] = erasedFront + splay[anyIndex].num;

    if (dup_was_before)
      res[i][1] = res[i][0];
    else if (dup_was_after)
      res[i][1] = res[i][2];
    else {
      splay.splay_to_root(dup);
      res[i][1] =
          erasedFront + (splay[dup].c[0] ? splay[splay[dup].c[0]].num : 0) + 1;
    }

    assert(res[i][0] <= res[i][1]);
    assert(res[i][1] <= res[i][2]);

    // cerr << "res[" << i << "] == " << res[i][0] << " " << res[i][1] << " "
    //      << res[i][2] << endl;

    // // PRINT
    // {
    //   splay.splay_to_root(anyIndex);
    //   cerr << erasedFront << " erased, then (" << splay[anyIndex].num << "):
    //   "; int xx = anyIndex; if (xx) {
    //     xx = splay.first(xx);
    //     while (xx) {
    //       splay.splay_to_root(xx);
    //       cerr << splay[xx].y << " ";
    //       xx = splay.next(xx);
    //     }
    //   }
    //   cerr << ", level:" << level << endl;
    // }
  }

  if (level >= limit)
    return true;

  splay.splay_to_root(anyIndex);
  return k < erasedFront || erasedFront + splay[anyIndex].num <= k;
}

int main() {
  ios_base::sync_with_stdio(0);

  cin >> n >> k;

  bool swapped = false;
  if (k >= n / 2) {
    swapped = true;
    k = n - k;
  }

  FOR(j, 2) FOR(i, n) cin >> input[i][j ^ swapped];

  // bool testResult = test(8);
  // cerr << "test result " << testResult << endl;
  // return 0;

  long long a = 0;
  long long b = 1LL * N * (int)1e9;

  while (a + 1 < b) {
    auto mid = (a + b) / 2;

    if (test(mid))
      a = mid;
    else
      b = mid;
  }

  test(a + 1);

  cout << a << endl;

  vector<int> result;
  OF(x, 0, n) {
    if (k >= res[x][1]) {
      --k;
      result.push_back(0);
    } else {
      result.push_back(1);
    }
  }

  OF(i, 0, n) { cout << ((result[i] ^ swapped) ? 'B' : 'A'); }
  cout << endl;

  assert(k == 0);

  return 0;
}