#include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;

const int mod = 1000000007;
class mint {
    long long x;
public:
    mint(long long x=0) : x((x%mod+mod)%mod) {}
    mint operator-() const { 
    return mint(-x);
    }
    mint& operator+=(const mint& a) {
        if ((x += a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator-=(const mint& a) {
        if ((x += mod-a.x) >= mod) x -= mod;
        return *this;
    }
    mint& operator*=(const  mint& a) {
        (x *= a.x) %= mod;
        return *this;
    }
    mint operator+(const mint& a) const {
        mint res(*this);
        return res+=a;
    }
    mint operator-(const mint& a) const {
        mint res(*this);
        return res-=a;
    }
    mint operator*(const mint& a) const {
        mint res(*this);
        return res*=a;
    }
    mint pow(ll t) const {
        if (!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
    // for prime mod
    mint inv() const {
        return pow(mod-2);
    }
    mint& operator/=(const mint& a) {
        return (*this) *= a.inv();
    }
    mint operator/(const mint& a) const {
        mint res(*this);
        return res/=a;
    }
    friend ostream& operator<<(ostream& os, const mint& m){
        os << m.x;
        return os;
    }
};
char maze[2][52];
int main(){
    int n;cin >> n;
    rep(i,2)rep(j,n) cin >> maze[i][j];

    vector<bool> xy;
    int i = 1;
    if(maze[0][0]==maze[1][0]){
        xy.push_back(false);
    }else{
        xy.push_back(true);
        ++i;
    }
    while(i<=n-1){
        xy.push_back((maze[0][i]!=maze[1][i]));
        if(maze[0][i]!=maze[1][i]) i++;
        i++;
    }

    mint ans = 1;
    rep(i,xy.size()) {
        if(i == 0){
            if(xy[i]) ans *= 6;
            else ans*=3;
            continue;
        }
        if(xy[i]){
            if(xy[i-1])ans*=3;
            else ans *= 2;
        }else{
            if(xy[i-1]) ans*=1;
            else ans*=2;
        }
    }

    cout << ans << endl;

}



















































// const int mod = 1000000007;
// class mint {
//     long long x;
// public:
//     mint(long long x=0) : x((x%mod+mod)%mod) {}
//     mint operator-() const { 
//     return mint(-x);
//     }
//     mint& operator+=(const mint& a) {
//         if ((x += a.x) >= mod) x -= mod;
//         return *this;
//     }
//     mint& operator-=(const mint& a) {
//         if ((x += mod-a.x) >= mod) x -= mod;
//         return *this;
//     }
//     mint& operator*=(const  mint& a) {
//         (x *= a.x) %= mod;
//         return *this;
//     }
//     mint operator+(const mint& a) const {
//         mint res(*this);
//         return res+=a;
//     }
//     mint operator-(const mint& a) const {
//         mint res(*this);
//         return res-=a;
//     }
//     mint operator*(const mint& a) const {
//         mint res(*this);
//         return res*=a;
//     }
//     mint pow(ll t) const {
//         if (!t) return 1;
//         mint a = pow(t>>1);
//         a *= a;
//         if (t&1) a *= *this;
//         return a;
//     }
//     // for prime mod
//     mint inv() const {
//         return pow(mod-2);
//     }
//     mint& operator/=(const mint& a) {
//         return (*this) *= a.inv();
//     }
//     mint operator/(const mint& a) const {
//         mint res(*this);
//         return res/=a;
//     }
//     friend ostream& operator<<(ostream& os, const mint& m){
//         os << m.x;
//         return os;
//     }
// };

// using graph = vector<vector<int>>;

// int number(const char ch){
//     int n = ch-'a';
//     if(0<= n && n <=25) return n;
//     else return (ch - 'A') + 26;
// }

// char maze[2][52];
// int main(){
//     int n;cin >> n;
//     rep(i,2)rep(j,n) cin >> maze[i][j]; 

//     int i = 1;
//     graph G(52);
//     int up_pre = number(maze[0][0]);
//     int lo_pre = number(maze[1][0]);
//     if(up_pre != lo_pre){
//         G[up_pre].push_back(lo_pre);
//         G[lo_pre].push_back(up_pre);
//         i++;
//     }
//     while(i<n){
//         int up = number(maze[0][i]);
//         int lo = number(maze[1][i]);
//         if(up == lo){
//             if(up_pre == lo_pre) {
//                 G[up_pre].push_back(up);
//                 G[up].push_back(up_pre);
//             }else{
//                 G[up_pre].push_back(up);
//                 G[lo_pre].push_back(up);
//                 G[up].push_back(lo_pre);
//                 G[up].push_back(up_pre);
//             }
//         }else{
//             G[up].push_back(lo);
//             G[lo].push_back(up);
//             if(up_pre == lo_pre){
//                 G[up_pre].push_back(up);
//                 G[up_pre].push_back(lo);
//                 G[up].push_back(up_pre);
//                 G[lo].push_back(up_pre);
//             }else{
//                 G[up].push_back(up_pre);
//                 G[up_pre].push_back(up);
//                 G[lo_pre].push_back(lo);
//                 G[lo].push_back(lo_pre);
//             }
//             i++;
//         }
//         up_pre = up;
//         lo_pre = lo;
//         i++;
//     }

//     // rep(i,52){
//     //     if(G[i].size())for(auto v:G[i]) printf("i %d v %d\n",i,v);
//     // }

//     vector<int> num(52,-1);
//     queue<int> q;
//     int saisyo = number(maze[0][0]);
//     q.push(saisyo);
//     mint ans = 1;
//     int cnt = 3;
//     //cout << q.front() << endl;
//     while(!q.empty()){
//         int v = q.front();q.pop();
//         //cout << v << endl;
//         if(num[v] != -1) continue;
//         for(auto nv:G[v]){
//             if(num[nv] != -1){
//                 --cnt;
//                 continue;
//             }
//             q.push(nv);
//         }
//         num[v] = cnt;
//         cnt = 3;
//         ans *= num[v];
//         //cout << " " << num[v] << endl;
//     }
//     //rep(i,n) cout << num[i] << endl;

//     //rep(i,n) ans *= num[i];
//     cout << ans << endl;
// }



Measured memory_bytes: 3604