#include <bits/stdc++.h>

using std::bitset;
using std::cin, std::cout, std::endl, std::flush, std::cerr;
using std::min, std::max;
using std::pair, std::tuple;
using std::set, std::map, std::multiset;
using std::tie;
using std::vector, std::array, std::queue, std::deque, std::string;
using std::views::iota, std::views::reverse;

template <class A> constexpr int sz(A&& a) {
    return int(std::size(std::forward<A>(a)));
}

using i32 = int32_t;
using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;
using usize = size_t;

template <class T> using Vec = std::vector<T>;

constexpr int INF = 1e8;

std::mt19937 mt(114514);
struct Node {
    array<Node*, 2> c{nullptr, nullptr};
    std::mt19937::result_type pri;

    // Fill in stuff here
    int sz;
    int x;
    array<int, 2> locs = {INF, INF};
};

void push(Node* r) {}

void upd(Node* r) {
    if (!r) return;
    int c0sz = (r->c[0] ? r->c[0]->sz : 0);
    r->sz = 1 + c0sz;
    if (r->c[1]) {
        r->sz += r->c[1]->sz;
    }
    for (int x : iota(0, 2)) {
        r->locs[x] = INF;
        if (r->c[0]) {
            r->locs[x] = r->c[0]->locs[x];
        }
        if (r->c[1]) {
            r->locs[x] = min(r->locs[x], r->c[1]->locs[x] + c0sz + 1);
        }
    }
    assert(r->x == 0 || r->x == 1);
    r->locs[r->x] = c0sz;
}

pair<Node*, Node*> split(Node* r, int k) {
    if (!r) return {nullptr, nullptr};
    Node *a, *b;
    push(r);
    int c0sz = (r->c[0] ? r->c[0]->sz : 0);
    if (c0sz < k) {
        a = r;
        tie(a->c[1], b) = split(r->c[1], k - c0sz - 1);
    } else {
        b = r;
        tie(a, b->c[0]) = split(r->c[0], k);
    }
    upd(r);
    return {a, b};
}

Node* merge(Node* a, Node* b) {
    if (!a) return b;
    if (!b) return a;
    push(a), push(b);
    Node* r;
    if (a->pri < b->pri) {
        r = a;
        r->c[1] = merge(a->c[1], b);
    } else {
        r = b;
        r->c[0] = merge(a, b->c[0]);
    }
    upd(r);
    return r;
}

Node nodes[600010];

int main() {
    std::ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << std::fixed << std::setprecision(20);

    int N, K;
    string A, B;
    cin >> N >> K >> A >> B;
    {
        int balance = 0;
        for (char c : A) {
            if (c == 'B') {
                balance++;
            } else if (c == 'C') {
                balance--;
            } else {
                assert(false);
            }
        }

        if (balance > 0) {
            for (char& c : A) {
                c ^= 'B' ^ 'C';
            }
            for (char& c : B) {
                c ^= 'B' ^ 'C';
            }
        }
    }

    int ptr = 0;
    auto make_node = [&](char x) -> Node* {
        assert(ptr < 2 * N);
        Node* r = &nodes[ptr++];
        r->pri = mt();
        r->sz = 1;
        r->x = (x != 'B');
        upd(r);
        return r;
    };
    Node* ta = nullptr;
    Node* tb = nullptr;
    for (int i : iota(0, N)) {
        assert(i < sz(A));
        assert(i < sz(B));
        ta = merge(ta, make_node(A[i]));
        tb = merge(tb, make_node(B[i]));
    }
    assert(ptr == 2 * N);

    auto ops = Vec<pair<int, int>>();
    auto do_rotate = [&](Node* t, int k) -> Node* {
        Node *a, *b;
        tie(a, b) = split(t, k);
        return merge(b, a);
    };
    auto do_swap = [&](int i, int j) {
        i = (i % N + N) % N;
        j = (j % N + N) % N;
        ops.emplace_back(i, j);
        ta = do_rotate(ta, i);
        tb = do_rotate(tb, j);
        Node *a, *b, *c, *d;
        tie(a, b) = split(ta, K);
        tie(c, d) = split(tb, K);
        ta = merge(c, b);
        tb = merge(a, d);
        ta = do_rotate(ta, N - i);
        tb = do_rotate(tb, N - j);
    };

    while (true) {
        int i = ta->locs[0];
        int j = tb->locs[1];
        assert((i == INF) == (j == INF));
        if (i == INF) break;
        do_swap(i - K, j);
        do_swap(i - K + 1, j);
        assert(ta->sz == tb->sz);
        assert(ta->sz == N);
    }

    cout << ops.size() << '\n';
    for (auto [i, j] : ops) {
        cout << i + 1 << ' ' << j + 1 << '\n';
    }

    return 0;
}