#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <random>

using namespace std;

#define x first
#define y second
#define prev _prev
typedef long long ll;
typedef unsigned long long ull;

mt19937 rnd(rand());
const int MOD = 1e9 + 7;
const ll BIG_MOD = 1e18 + 7;
const int MAXN = 107;

int fact(ll a, ll b){
	ll f = (a * b) % MOD;
	if (f < 0){
		return f + MOD;
	}

	if (f >= MOD){
		return f - MOD;
	}

	return f;
}

void add(int &a, int b){
	ll s = (ll)a + (ll)b;
	if (s >= MOD){
		a = s - MOD;
	}
	else{
		a = s;
	}
}

int dp[MAXN][3][3];
int dp1[MAXN][3][3];
int dp2[MAXN][3][3];

signed main(){
	cout.precision(20);
	//freopen("input.txt", "r", stdin);
	ios_base::sync_with_stdio(false);
	int n;
	cin >> n;
	string s1;
	string s2;
	cin >> s1;
	cin >> s2;

	dp[1][0][1] = 1;
	dp[1][0][2] = 1;
	dp[1][1][0] = 1;
	dp[1][1][2] = 1;
	dp[1][2][0] = 1;
	dp[1][2][1] = 1;

	for (int i = 2; i < MAXN; ++i){
		add(dp[i][0][1], dp[i - 1][1][0]);
		add(dp[i][0][1], dp[i - 1][1][2]);
		add(dp[i][0][1], dp[i - 1][2][0]);

		add(dp[i][0][2], dp[i - 1][1][0]);
		add(dp[i][0][2], dp[i - 1][2][0]);
		add(dp[i][0][2], dp[i - 1][2][1]);

		add(dp[i][1][0], dp[i - 1][0][1]);
		add(dp[i][1][0], dp[i - 1][2][1]);
		add(dp[i][1][0], dp[i - 1][0][2]);

		add(dp[i][2][0], dp[i - 1][0][1]);
		add(dp[i][2][0], dp[i - 1][1][2]);
		add(dp[i][2][0], dp[i - 1][0][2]);

		add(dp[i][1][2], dp[i - 1][0][1]);
		add(dp[i][1][2], dp[i - 1][2][1]);
		add(dp[i][1][2], dp[i - 1][2][0]);

		add(dp[i][2][1], dp[i - 1][1][0]);
		add(dp[i][2][1], dp[i - 1][1][2]);
		add(dp[i][2][1], dp[i - 1][0][2]);
	}

	int last = 0;
	vector <int> format;
	for (int i = 0; i < n; ++i){
		if (s1[i] != s2[i]){
			++last;
		}
		else{
			if (last) {
				format.push_back(last / 2);
			}

			last = 0;
			format.push_back(0);
		}
	}
	
	if (last){
		format.push_back(last / 2);
	}

	if (!format[0]){
		dp1[0][0][0] = 1;
		dp1[0][1][1] = 1;
		dp1[0][2][2] = 1;
	}
	else{
		dp1[0][0][1] = dp[format[0]][0][1];
		dp1[0][1][0] = dp[format[0]][1][0];
		dp1[0][0][2] = dp[format[0]][0][2];
		dp1[0][2][0] = dp[format[0]][2][0];
		dp1[0][1][2] = dp[format[0]][1][2];
		dp1[0][2][1] = dp[format[0]][2][1];
	}

	for (int i = 1; i < format.size(); ++i){
		if (!format[i]){
			add(dp1[i][0][0], dp1[i - 1][1][2]);
			add(dp1[i][0][0], dp1[i - 1][2][1]);
			add(dp1[i][0][0], dp1[i - 1][1][1]);
			add(dp1[i][0][0], dp1[i - 1][2][2]);

			add(dp1[i][1][1], dp1[i - 1][0][2]);
			add(dp1[i][1][1], dp1[i - 1][2][0]);
			add(dp1[i][1][1], dp1[i - 1][0][0]);
			add(dp1[i][1][1], dp1[i - 1][2][2]);

			add(dp1[i][2][2], dp1[i - 1][1][0]);
			add(dp1[i][2][2], dp1[i - 1][0][1]);
			add(dp1[i][2][2], dp1[i - 1][1][1]);
			add(dp1[i][2][2], dp1[i - 1][0][0]);
		}
		else{

			for (int j = 0; j < MAXN; ++j){
				dp2[j][0][1] = 0;
				dp2[j][0][2] = 0;
				dp2[j][1][0] = 0;
				dp2[j][1][2] = 0;
				dp2[j][2][0] = 0;
				dp2[j][2][1] = 0;
			}

			add(dp2[1][0][1], dp1[i - 1][2][2]);
			add(dp2[1][0][2], dp1[i - 1][1][1]);
			add(dp2[1][1][0], dp1[i - 1][2][2]);
			add(dp2[1][2][0], dp1[i - 1][1][1]);
			add(dp2[1][1][2], dp1[i - 1][0][0]);
			add(dp2[1][2][1], dp1[i - 1][0][0]);

			for (int j = 2; j < MAXN; ++j){
				add(dp2[j][0][1], dp2[j - 1][1][0]);
				add(dp2[j][0][1], dp2[j - 1][1][2]);
				add(dp2[j][0][1], dp2[j - 1][2][0]);

				add(dp2[j][0][2], dp2[j - 1][1][0]);
				add(dp2[j][0][2], dp2[j - 1][2][0]);
				add(dp2[j][0][2], dp2[j - 1][2][1]);

				add(dp2[j][1][0], dp2[j - 1][0][1]);
				add(dp2[j][1][0], dp2[j - 1][2][1]);
				add(dp2[j][1][0], dp2[j - 1][0][2]);

				add(dp2[j][2][0], dp2[j - 1][0][1]);
				add(dp2[j][2][0], dp2[j - 1][1][2]);
				add(dp2[j][2][0], dp2[j - 1][0][2]);

				add(dp2[j][1][2], dp2[j - 1][0][1]);
				add(dp2[j][1][2], dp2[j - 1][2][1]);
				add(dp2[j][1][2], dp2[j - 1][2][0]);

				add(dp2[j][2][1], dp2[j - 1][1][0]);
				add(dp2[j][2][1], dp2[j - 1][1][2]);
				add(dp2[j][2][1], dp2[j - 1][0][2]);
			}

			dp1[i][0][1] = dp2[format[i]][0][1];
			dp1[i][1][0] = dp2[format[i]][0][1];
			dp1[i][0][2] = dp2[format[i]][0][1];
			dp1[i][2][0] = dp2[format[i]][0][1];
			dp1[i][1][2] = dp2[format[i]][0][1];
			dp1[i][2][1] = dp2[format[i]][0][1];
		}

	}

	int ans = 0;
	int l = format.size() - 1;
	add(ans, dp1[l][0][0]);
	add(ans, dp1[l][1][1]);
	add(ans, dp1[l][2][2]);
	add(ans, dp1[l][0][1]);
	add(ans, dp1[l][1][0]);
	add(ans, dp1[l][0][2]);
	add(ans, dp1[l][2][0]);
	add(ans, dp1[l][1][2]);
	add(ans, dp1[l][2][1]);

	cout << ans;
	return 0;
}

Measured memory_bytes: 256