#include <bits/stdc++.h>
#define fr first
#define sc second
#define all(a) (a).begin(), (a).end()

using namespace std;

#ifdef ONPC
mt19937 rnd(223);
mt19937_64 rnd64(223);
#else
mt19937 rnd(chrono::high_resolution_clock::now()
            .time_since_epoch().count());
mt19937_64 rnd64(chrono::high_resolution_clock::now()
            .time_since_epoch().count());
#endif

#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

using ll = long long;
using ld = double;

const ll llinf = 1e18 + 100;

const int maxn = 1e6 + 100, inf = 1e9 + 100;

struct node;

using ptr = node*;

struct node {

    static ptr null;

    int sz = 0, w = 0, y = rnd();
    array<int, 2> f = {inf, inf};
    ptr l = null, r = null;

    node() = default;

    node(int s_) : sz(1), w(s_) {
        f[w] = 0;
    }
};

ptr node::null = new node();

auto null = node::null;

void upd(ptr t) {
    if (t != null) {
        t->sz = 1 + t->l->sz + t->r->sz;
        t->f[0] = min(t->l->f[0], t->r->f[0] + t->l->sz + 1);
        t->f[1] = min(t->l->f[1], t->r->f[1] + t->l->sz + 1);
        t->f[t->w] = t->l->sz;
    }
}

void split(ptr t, ptr &l, ptr &r, int sz) {
    if (t == null) {
        l = r = null;
        return;
    }
    if (t->l->sz < sz) {
        split(t->r, t->r, r, sz - t->l->sz - 1);
        upd(t);
        l = t;
    } else {
        split(t->l, l, t->l, sz);
        upd(t);
        r = t;
    }
}

void merge(ptr &t, ptr l, ptr r) {
    if (l == null) {
        t = r;
        return;
    }
    if (r == null) {
        t = l;
        return;
    }
    if (l->y < r->y) {
        merge(l->r, l->r, r);
        t = l;
        upd(t);
    } else {
        merge(r->l, l, r->l);
        t = r;
        upd(t);
    }
}

void print1(ptr t) {
    if (t == null)
        return;
    print1(t->l);
    cerr << t->w;
    print1(t->r);
}

void print(ptr t) {
    print1(t);
    cerr << '\n';
}

void solve() {
    int n, k;
    cin >> n >> k;
    array<string, 2> a;
    cin >> a[0] >> a[1];
    int bal = 0;
    for (char c : a[0])
        if (c == 'B')
            bal++;
        else
            bal--;
    // B - 0
    int tg = (bal < 0);
    ptr r1 = null, r2 = null;
    for (int i = 0; i < n; i++) {
        merge(r1, r1, new node(a[0][i] != 'B'));
        merge(r2, r2, new node(a[1][i] != 'B'));
    }
    vector<pair<int, int>> ops;
    auto rotate = [&](ptr t, int i) {
        ptr t1, t2;
        split(t, t1, t2, i);
        merge(t, t2, t1);
    };
    auto swp = [&](int i, int j) {
        i = (i % n + n) % n;
        j = (j % n + n) % n;
        ops.push_back({i, j});
        rotate(r1, i);
        rotate(r2, j);
        ptr t1, t2, q1, q2;
        split(r1, t1, t2, k);
        split(r2, q1, q2, k);
        merge(r1, q1, t2);
        merge(r2, t1, q2);
        rotate(r1, n - i);
        rotate(r2, n - j);
        // print(r1);
        // print(r2);
        // cerr << '\n';
    };
    // print(r1);
    // print(r2);
    // cerr << '\n';
    while (1) {
        int i = r1->f[!tg], j = r2->f[tg];
        assert(((i >= maxn) == (j >= maxn)));
        if (i >= maxn)
            break;
        swp(i - k, j);
        swp(i - k + 1, j);
    }
    cout << ops.size() << '\n';
    for (auto w : ops)
        cout << w.fr + 1 << ' ' << w.sc + 1 << '\n';
}

int main() {
#ifdef ONPC
    freopen("../a.in", "r", stdin);
    // freopen("../a.out", "w", stdout);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout << fixed;
    cout.precision(20);
    int ts = 1;
    // cin >> ts;
    while (ts--)
        solve();
    cerr << "\n\nConsumed " << TIME << endl;
}