#include <bits/stdc++.h>

using namespace std;

using ll = long long;

using Int = int;

struct ModInt {
    static constexpr Int mod = 1e9 + 7;
    Int v;

    ModInt(long long _v = 0) : v(set(_v)) {}
    ModInt(const ModInt &r) : v(set(r.v)) {}

    inline static Int set(const auto x) { return x < 0 ? (x % mod) + mod : x % mod; }
    inline void set() { v = set(v); }

    bool operator<(ModInt r) const { return v < r.v; }
    bool operator>(ModInt r) const { return r.v < v; }
    bool operator==(ModInt r) const { return v == r.v; }
    bool operator!= (ModInt r) const { return v != r.v; }

    ModInt operator-() const { return ModInt(v ? mod - v : v); }
    ModInt &operator=(const ModInt &r) { if (this != &r) v = set(r.v); return *this; }
    ModInt &operator+=(ModInt r) { (v += r.v) %= mod; return *this; }
    ModInt &operator-=(ModInt r) { (v -= r.v - mod) %= mod; return *this; }
    // ModInt &operator*=(ModInt r) { v = (__uint128_t(v) * r.v) % mod; return *this; }
    ModInt &operator*=(ModInt r) { v = 1ULL * v * r.v % mod; return *this; }
    ModInt &operator/=(ModInt r) { *this *= r.inv(); return *this; }
    ModInt operator+(ModInt r) const { return ModInt(*this) += r; }
    ModInt operator-(ModInt r) const { return ModInt(*this) -= r; }
    ModInt operator*(ModInt r) const { return ModInt(*this) *= r; }
    ModInt operator/(ModInt r) const { return ModInt(*this) /= r; }

    ModInt inv() const {
        long long a = v, b = mod, u = 1, w = 0;
        while (b) {
            long long t = a / b;
            std::swap(a -= t * b, b);
            std::swap(u -= t * w, w);
        }
        return ModInt(u);
    }

    ModInt pow(Int e) {
        ModInt a = *this, x(1);
        for ( ; 0 < e; e >>= 1) { if (e & 1) x *= a; a *= a; }
        return x;
    }
    inline ModInt pow(ModInt &e) { return pow(e.v); }
};
std::ostream &operator<<(std::ostream &os, const ModInt &r) { return os << r.v; }
std::istream &operator>>(std::istream &is, ModInt &r) { is >> r.v; r.set();return is; }


int main() {
    cin.tie(0); ios::sync_with_stdio(false);

    int n;
    string s1, s2;
    cin >> n >> s1 >> s2;

    vector<vector<vector<ModInt>>> dp(n, vector<vector<ModInt>>(3, vector<ModInt>(3)));

    int idx = 0;
    if (s1[0] == s2[0]) {
        dp[0][0][0] = dp[0][1][1] = dp[0][2][2] = 1;
        ++idx;
    }
    else {
        dp[1][0][1] = dp[1][0][2] = dp[1][1][0] = 1;
        dp[1][1][2] = dp[1][2][0] = dp[1][2][1] = 1;
        idx += 2;
    }

    while (idx < n) {
        if (s1[idx] == s2[idx]) {
            // 0で塗る
            dp[idx][0][0] += dp[idx - 1][1][1] + dp[idx - 1][2][2];
            dp[idx][0][0] += dp[idx - 1][1][2] + dp[idx - 1][2][1];
            // 1で塗る
            dp[idx][1][1] += dp[idx - 1][0][0] + dp[idx - 1][2][2];
            dp[idx][1][1] += dp[idx - 1][0][2] + dp[idx - 1][2][0];
            // 2で塗る
            dp[idx][2][2] += dp[idx - 1][0][0] + dp[idx - 1][1][1];
            dp[idx][2][2] += dp[idx - 1][1][0] + dp[idx - 1][0][1];
            ++idx;
        }
        else {
            // [idx][idx + 1]
            // 01で塗る
            dp[idx + 1][0][1] += dp[idx - 1][2][2] + dp[idx - 1][1][0];
            dp[idx + 1][0][1] += dp[idx - 1][1][2] + dp[idx - 1][2][0];
            // 02で塗る
            dp[idx + 1][0][2] += dp[idx - 1][1][1] + dp[idx - 1][2][0];
            dp[idx + 1][0][2] += dp[idx - 1][2][1] + dp[idx - 1][1][0];
            // 10で塗る
            dp[idx + 1][1][0] += dp[idx - 1][2][2] + dp[idx - 1][0][1];
            dp[idx + 1][1][0] += dp[idx - 1][0][2] + dp[idx - 1][2][1];
            // 12で塗る
            dp[idx + 1][1][2] += dp[idx - 1][0][0] + dp[idx - 1][0][1];
            dp[idx + 1][1][2] += dp[idx - 1][2][0] + dp[idx - 1][2][1];
            // 20で塗る
            dp[idx + 1][2][0] += dp[idx - 1][1][1] + dp[idx - 1][0][1];
            dp[idx + 1][2][0] += dp[idx - 1][0][2] + dp[idx - 1][1][2];
            // 21で塗る
            dp[idx + 1][2][1] += dp[idx - 1][0][0] + dp[idx - 1][0][2];
            dp[idx + 1][2][1] += dp[idx - 1][1][0] + dp[idx - 1][1][2];
            idx += 2;
        }
    }

    ModInt res = dp[n - 1][0][0] + dp[n - 1][1][1] + dp[n - 1][2][2];
    res += dp[n - 1][0][1] + dp[n - 1][0][2];
    res += dp[n - 1][1][0] + dp[n - 1][1][2];
    res += dp[n - 1][2][0] + dp[n - 1][2][1];

    cout << res << endl;

    return 0;
}


Measured memory_bytes: 256