//#pragma comment(linker, "/stack:200000000")
//#pragma GCC optimize("Ofast")
//#pragma GCC optimize("no-stack-protector")
//#pragma GCC target("popcnt")
//#pragma GCC target("sse4")
//
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define rng(a) a.begin(),a.end()
#define fast ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define sz(a) (int)(a.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef long double ld;

#define int long long
bool kekw = 0;
bool ask(int left, int right) {
	cout << left << ' ' << right << endl;
	string s;
	cin >> s;
	if (s == "Bad")
		kekw = 1;
	if (left == right && s == "Yes")
		kekw = 1;
	return (s == "Yes");
}

signed main(){
	mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
	int n, k;
	cin >> n >> k;
	int l = 1, r = n + 1;
	int id = 0;
	while(id < 4500) {
		int m = (l + r) / 2;
		if(ask(l, m)){
			r = m + 1;
		} else {
			l = m;
		}
		if (kekw)
			return 0;
		l -= k;
		l = max(l, 1ll);
		id++;
		r += k;
		r = min(r, n);
		if (r - l <= 4 * k + 1) {
			int f = rnd()%(r - l) + l;
			if (ask(f, f)){
				return 0;
			}
			if (kekw)
				return 0;
			l -= k;
			r += k;
		l = max(l, 1ll);
		r = min(r, n);
		id++;
		}
	}

}


#include <bits/stdc++.h>
using ll = long long;
#define int ll
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define mp make_pair
#define mt make_tuple
using namespace std;

void umin(int &a, int b) {
	a = min(a, b);
}
void umax(int &a, int b) {
	a = max(a, b);
}

int n, k;

bool query(int l, int r) {
	cout << l << " " << r << endl;
	string s;
	cin >> s;
	return s == "Yes";
}

signed main() {
#ifdef LC
    assert(freopen("input.txt", "r", stdin));
#endif // LC
    ios::sync_with_stdio(0);
    cin.tie(0);
	cin >> n >> k;
	mt19937 rnd;
	int l = 1, r = n;
	while (1) {
		while (r - l + 1 > 5 * k) {
			int m = (l + r) / 2;
			if (query(l, m)) {
				l = max(l, k + 1) - k;
				r = min(m, n - k) + k;
			} else {
				l = max(m, k + 1) - k;
				r = min(r, n - k) + k;
			}
		}
		l = r = l + rnd() % (r - l + 1);
		if (query(l, r)) {
			return 0;
		} else {
			l = max(l, k + 1) - k;
			r = min(r, n - k) + k;
		}
	}
    return 0;
}


#include <bits/stdc++.h>
using ll = long long;
#define int ll
#define x first
#define y second
#define all(x) x.begin(), x.end()
#define mp make_pair
#define mt make_tuple
using namespace std;

void umin(int &a, int b) {
	a = min(a, b);
}
void umax(int &a, int b) {
	a = max(a, b);
}

int n, k;

bool query(int l, int r) {
	cout << l << " " << r << endl;
	string s;
	cin >> s;
	return s == "Yes";
}

signed main() {
#ifdef LC
    assert(freopen("input.txt", "r", stdin));
#endif // LC
    ios::sync_with_stdio(0);
    cin.tie(0);
	cin >> n >> k;
	mt19937 rnd;
	while (1) {
		int l = 1, r = n;
		while (r - l + 1 >= 5 * k) {
			int m = (l + r) / 2;
			if (query(l, m)) {
				l = max(l, k + 1) - k;
				r = min(m, n - k) + k;
			} else {
				l = max(m, k + 1) - k;
				r = min(r, n - k) + k;
			}
		}
		l = r = l + rnd() % (r - l + 1);
		if (query(l, r)) {
			return 0;
		}
	}
    return 0;
}


#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define me0(a) memset(a,0,sizeof(a))
#define me1(a) memset(a,-1,sizeof(a))
#define op freopen("in.txt", "r", stdin)
#define pii pair<int,int>
#define mp(x,y) make_pair(x,y)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
void read(int& val) { int x = 0; int bz = 1; char c; for (c = getchar(); (c<'0' || c>'9') && c != '-'; c = getchar()); if (c == '-') { bz = -1; c = getchar(); }for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48; val = x * bz; }
const int mod=1e9+7;
const int maxn = 2e6+7;

int n;
char s[maxn],t[maxn],tmp[maxn];
int dp1[maxn],dp2[maxn];
int tot=0;

int xx(){
    me0(dp1);me0(dp2);
    fo(i,1,n){
        dp1[i]=dp1[i-1];
        if(tmp[i]=='1') dp1[i]++;
        else dp1[i]--;
        dp1[i]=max(0,dp1[i]);
    }

    stack<char>st;
    int nw=0;
    fod(i,n,1){
        if(st.empty()){
            st.push(tmp[i]);
            if(tmp[i]=='0') nw++;
        }
        else if(tmp[i]=='1'){
            if(st.top()=='0') {
                nw--;st.pop();
            }
            else{
                st.push('1');
            }
        }
        else{
            st.push('0');nw++;
        }
        dp2[i]=st.size()-nw;
    }

    int mx=0;
    fo(i,1,tot){
        mx=max(mx,dp1[i]+dp2[i+1]);
    }
    return mx;
}

int main(){
//    op;
    read(n);
    scanf("%s",s+1);
    scanf("%s",t+1);
    int num[2];me0(num);
    fo(i,1,n){
        if(s[i]!=t[i]) tmp[++tot]=s[i];
        num[s[i]-'0']++;num[t[i]-'0']--;
    }
    if(num[0]||num[1]){
        puts("-1");
        return 0;
    }

    n=tot;
    int mx=xx();

    fo(i,1,n) if(tmp[i]=='1') tmp[i]='0';else tmp[i]='1';
    mx = min(mx, xx());
    printf("%d\n",mx);

    return 0;
}


#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define me0(a) memset(a,0,sizeof(a))
#define me1(a) memset(a,-1,sizeof(a))
#define op freopen("in.txt", "r", stdin)
#define pii pair<int,int>
#define mp(x,y) make_pair(x,y)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
void read(int& val) { int x = 0; int bz = 1; char c; for (c = getchar(); (c<'0' || c>'9') && c != '-'; c = getchar()); if (c == '-') { bz = -1; c = getchar(); }for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48; val = x * bz; }
const int mod=1e9+7;
const int maxn = 2e6+7;

int n;
char s[maxn],t[maxn],tmp[maxn];
int dp1[maxn],dp2[maxn];

int main(){
//    op;
    read(n);
    scanf("%s",s+1);
    scanf("%s",t+1);
    int tot=0;
    int num[2];me0(num);
    fo(i,1,n){
        if(s[i]!=t[i]) tmp[++tot]=s[i];
        num[s[i]-'0']++;num[t[i]-'0']--;
    }
    if(num[0]||num[1]){
        puts("-1");
        return 0;
    }

    n=tot;
    fo(i,1,n){
        dp1[i]=dp1[i-1];
        if(tmp[i]=='1') dp1[i]++;
        else dp1[i]--;
        dp1[i]=max(0,dp1[i]);
    }

    stack<char>st;
    int nw=0;
    fod(i,n,1){

        if(st.empty()){
            st.push(tmp[i]);
            if(tmp[i]=='0') nw++;
        }
        else if(tmp[i]=='1'){
            if(st.top()=='0') {
                nw--;st.pop();
            }
            else{
                st.push('1');
            }
        }
        else{
            st.push('0');nw++;
        }
        dp2[i]=st.size()-nw;
    }

    int mx=0;
    fo(i,1,tot){
        mx=max(mx,dp1[i]+dp2[i+1]);
    }
    printf("%d\n",mx);

    return 0;
}


#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define me0(a) memset(a,0,sizeof(a))
#define me1(a) memset(a,-1,sizeof(a))
#define op freopen("in.txt", "r", stdin)
#define pii pair<int,int>
#define mp(x,y) make_pair(x,y)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
void read(int& val) { int x = 0; int bz = 1; char c; for (c = getchar(); (c<'0' || c>'9') && c != '-'; c = getchar()); if (c == '-') { bz = -1; c = getchar(); }for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48; val = x * bz; }
const int mod=1e9+7;
const int maxn = 1e6+7;

int n;
char s[maxn],t[maxn],tmp[maxn];

int main(){
    read(n);
    scanf("%s",s+1);
    scanf("%s",t+1);
    int tot=0;
    int num[2];me0(num);
    fo(i,1,n){
        if(s[i]!=t[i]) tmp[++tot]=s[i];
        num[s[i]-'0']++;num[t[i]-'0']--;
    }
    if(num[0]||num[1]){
        puts("-1");
        return 0;
    }

    fo(i,tot+1,tot+tot) tmp[i]=tmp[i-tot];
    int mx=0,cnt=1;
    fo(i,2,tot+tot){
        if(tmp[i]==tmp[i-1]) cnt++;
        else cnt=1;
        mx=max(mx,cnt);
    }
    printf("%d\n",mx);
    return 0;
}


#include <bits/stdc++.h>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define me0(a) memset(a,0,sizeof(a))
#define me1(a) memset(a,-1,sizeof(a))
#define op freopen("in.txt", "r", stdin)
#define pii pair<int,int>
#define mp(x,y) make_pair(x,y)
using namespace std;
const int INF = 0x3f3f3f3f;
typedef long long LL;
void read(int& val) { int x = 0; int bz = 1; char c; for (c = getchar(); (c<'0' || c>'9') && c != '-'; c = getchar()); if (c == '-') { bz = -1; c = getchar(); }for (; c >= '0' && c <= '9'; c = getchar()) x = x * 10 + c - 48; val = x * bz; }
const int mod=1e9+7;
const int maxn = 2e6+7;

int n;
char s[maxn],t[maxn],tmp[maxn];

int main(){
//    op;
    read(n);
    scanf("%s",s+1);
    scanf("%s",t+1);
    int tot=0;
    int num[2];me0(num);
    fo(i,1,n){
        if(s[i]!=t[i]) tmp[++tot]=s[i];
        num[s[i]-'0']++;num[t[i]-'0']--;
    }
    if(num[0]||num[1]){
        puts("-1");
        return 0;
    }

    fo(i,tot+1,tot+tot) tmp[i]=tmp[i-tot];
    int mx=0,cnt=1;
    int num0=0;
    fo(i,1,tot){
        if(tmp[i]==tmp[i-1]) cnt++;
        else cnt=1;
        if(tmp[i]=='0') num0++;
        else num0--;
        if(tmp[i]=='0'){
            mx=max(mx,num0);
        }
        else{
            mx= max(mx, -num0);
        }
    }
    printf("%d\n",mx);
    return 0;
}


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        vst[s1[i] - '0'].erase(i);
        int32_t cur = (s1[i] - '0') ^1;
        int32_t now_i = i;
        while (true) {
            auto it = vst[cur].upper_bound(now_i)
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;
            used[now_i] = 1;
            vst[cur].erase(now_i);
            cur ^= 1;
        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) {
            continue;
        }
        used[i] = 1;
        vst[s1[i] - '0'].erase(i);
        int j = i, cur = (s1[i] - '0') ^1;
        while (true) {
            auto it = vst[cur].upper_bound(j);
            if (it == vst[cur].end()) {
                break;
            }
            j = *it;
            used[j] = 1;
            vst[cur].erase(it);
            cur ^= 1;
        }
        ++ans;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        vst[s1[i] - '0'].erase(i);
        int32_t cur = (s1[i] - '0') ^1;
        int32_t now_i = i;
        while (true) {
            auto it = std::upper_bound(vst[cur].begin(), vst[cur].end(), now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;
            used[now_i] = 1;
            vst[cur].erase(now_i);
            cur ^= 1;
        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return 0;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        int32_t cur = s1[i] - '0';
        int32_t now_i = i;
        while (true) {
            if (vst[cur].empty()) break;
            vst[cur].erase(now_i);
            used[now_i] = 1;
            cur ^= 1;
            auto it = std::upper_bound(vst[cur].begin(), vst[cur].end(), now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;

        }
        ans++;
    }
    std::cout << ans;
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже

сто триллионов миллиардов лет проживаю на триллионах и

триллионах таких же планет, как эта Земля, мне этот мир абсолютно

понятен, и я здесь ищу только одного - покоя, умиротворения и

вот этой гармонии, от слияния с бесконечно вечным, от созерцания

великого фрактального подобия и от вот этого замечательного всеединства

существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно

малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со

своим вот этим, иди суетись дальше, это твоё распределение, это

твой путь и твой горизонт познания и ощущения твоей природы, он

несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже

давно глубокий старец, бессмертный, ну или там уже почти бессмертный,

который на этой планете от её самого зарождения, ещё когда только Солнце

только-только сформировалось как звезда, и вот это газопылевое облако,

вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало

формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже

как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк

этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои

яхты, на твои квартиры, там, на твоё благо. Я был на этой

планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче

всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,

чем здесь. Я множество этих состояний чувствую. Где-то я был больше

подобен растению, где-то я больше был подобен птице, там, червю, где-то

был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани

подобия совершенно многообразные, бесконечное множество. Но тебе этого

не понять, поэтому ты езжай себе , мы в этом мире как бы живем

разными ощущениями и разными стремлениями, соответственно, разное наше и

место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    size_t n;
    std::cin >> n;
    std::string s1, s2;
    std::cin >> s1;
    std::cin >> s2;
    std::set<int32_t> one;
    std::set<int32_t> zero;
    size_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        if (s1[i] == s2[i]) continue;
        if (s1[i] == '1') {
            one.insert(i);
        } else {
            zero.insert(i);
        }
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return 0;
    }
    size_t ans = 0;
    while (!one.empty() || !zero.empty()) {
        ans++;
        bool one_h;
        if (one.empty()) {
            one_h = false;
        } else if (zero.empty()) {
            one_h = true;
        } else one_h = *zero.begin() >= *one.begin();
        int32_t prev = -1;
        while (!one.empty() || !zero.empty()) {
            if (one_h) {
                if (one.empty()) {
                    break;
                }
                auto it = std::upper_bound(one.begin(), one.end(), prev);
                if (it != one.end()) {
                    prev = *it;
                    one.erase(it);
                    one_h = false;
                } else {
                    break;
                }
            } else {
                if (zero.empty()) {
                    break;
                }
                auto it = std::upper_bound(zero.begin(), zero.end(), prev);
                if (it != zero.end()) {
                    prev = *it;
                    zero.erase(it);
                    one_h = true;
                } else {
                    break;
                }
            }
        }
    }
    std::cout << ans;
    return 0;
}


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        vst[s1[i] - '0'].erase(i);
        int32_t cur = (s1[i] - '0') ^1;
        int32_t now_i = i;
        while (true) {
            auto it = vst[cur].upper_bound(now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;
            used[now_i] = 1;
            vst[cur].erase(now_i);
            cur ^= 1;
        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        int32_t cur = s1[i] - '0';
        int32_t now_i = i;
        while (true) {
            used[now_i] = 1;
            vst[cur].erase(now_i);
            cur ^= 1;
            auto it = std::upper_bound(vst[cur].begin(), vst[cur].end(), now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;

        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
    size_t n, right = 0;
    std::cin >> n;
    std::string s1, s2;
    std::cin >> s1;
    std::cin >> s2;
    if (std::count(s1.begin(), s1.end(), '1') != std::count(s2.begin(), s2.end(), '1')) {
        std::cout << -1;
    } else {
        std::set<int32_t> one;
        std::set<int32_t> zero;
        for (size_t i = 0; i < n; i++) {
            if (s1[i] == s2[i]) continue;
            if (s1[i] == '1') {
                one.insert(i);
            } else {
                zero.insert(i);
            }
        }
        size_t ans = 0;
        while (!one.empty() || !zero.empty()) {
            ans++;
            bool one_h = true;
            if (one.empty() || (!zero.empty() && *zero.begin() < *one.begin())) {
                one_h = false;
            }
            int32_t prev = -1;
            while (!one.empty() || !zero.empty()) {
                if (one_h) {
                    if (one.empty()) {
                        break;
                    }
                    auto it = one.upper_bound(prev);
                    if (it != one.end()) {
                        prev = *it;
                        one.erase(it);
                        one_h = false;
                    } else {
                        break;
                    }
                } else {
                    if (zero.empty()) {
                        break;
                    }
                    auto it = zero.upper_bound(prev);
                    if (it != zero.end()) {
                        prev = *it;
                        zero.erase(it);
                        one_h = true;
                    } else {
                        break;
                    }
                }
            }
        }
        std::cout << ans;
    }
    return 0;
}


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        int32_t cur = s1[i] - '0';
        int32_t now_i = i;
        while (true) {
            if (vst[cur].empty()) break;
            vst[cur].erase(now_i);
            used[now_i] = 1;
            cur ^= 1;
            auto it = std::upper_bound(vst[cur].begin(), vst[cur].end(), now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;

        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <deque>
#include <sstream>

void fast_io() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
}

void solve() {
    int32_t n;
    std::string s1, s2;
    std::cin >> n >> s1 >> s2;
    std::vector<std::set<int32_t>> vst(2);
    std::vector<int32_t> used(n);
    int32_t one_0 = 0, one_1 = 0;
    for (int32_t i = 0; i < n; i++) {
        one_0 += (s1[i] == '1');
        one_1 += (s2[i] == '1');
        used[i] = (s1[i] == s2[i]);
        if (s1[i] == s2[i]) {
            continue;
        }
        vst[s1[i] - '0'].insert(i);
    }
    if (one_0 != one_1) {
        std::cout << -1;
        return;
    }
    int32_t ans = 0;
    for (int32_t i = 0; i < n; i++) {
        if (used[i]) continue;
        used[i] = 1;
        int32_t cur = s1[i] - '0';
        int32_t now_i = i;
        while (true) {
            used[now_i] = 1;
            if (vst[cur].empty()) break;
            vst[cur].erase(now_i);
            cur ^= 1;
            auto it = std::upper_bound(vst[cur].begin(), vst[cur].end(), now_i);
            if (it == vst[cur].end()) {
                break;
            }
            now_i = *it;

        }
        ans++;
    }
    std::cout << ans;
}

int main() {
    solve();
    return 0;
}

/*
ЗАКЛИНАНИЕ, ЧТОБЫ ЭТОТ ТУПОЙ N LOG N НАКОНЕЦ-ТО ЗАШЁЛ
Я в своем познании настолько преисполнился, что я как будто бы уже
сто триллионов миллиардов лет проживаю на триллионах и
триллионах таких же планет, как эта Земля, мне этот мир абсолютно
понятен, и я здесь ищу только одного - покоя, умиротворения и
вот этой гармонии, от слияния с бесконечно вечным, от созерцания
великого фрактального подобия и от вот этого замечательного всеединства
существа, бесконечно вечного, куда ни посмотри, хоть вглубь - бесконечно
малое, хоть ввысь - бесконечное большое, понимаешь? А ты мне опять со
своим вот этим, иди суетись дальше, это твоё распределение, это
твой путь и твой горизонт познания и ощущения твоей природы, он
несоизмеримо мелок по сравнению с моим, понимаешь? Я как будто бы уже
давно глубокий старец, бессмертный, ну или там уже почти бессмертный,
который на этой планете от её самого зарождения, ещё когда только Солнце
только-только сформировалось как звезда, и вот это газопылевое облако,
вот, после взрыва, Солнца, когда оно вспыхнуло, как звезда, начало
формировать вот эти коацерваты, планеты, понимаешь, я на этой Земле уже
как будто почти пять миллиардов лет живу и знаю её вдоль и поперёк
этот весь мир, а ты мне какие-то... мне не важно на твои тачки, на твои
яхты, на твои квартиры, там, на твоё благо. Я был на этой
планете бесконечным множеством, и круче Цезаря, и круче Сталина, и круче
всех великих, понимаешь, был, а где-то был ничтожеством, ещё хуже,
чем здесь. Я множество этих состояний чувствую. Где-то я был больше
подобен растению, где-то я больше был подобен птице, там, червю, где-то
был просто сгусток камня, это всё есть душа, понимаешь? Она имеет грани
подобия совершенно многообразные, бесконечное множество. Но тебе этого
не понять, поэтому ты езжай себе , мы в этом мире как бы живем
разными ощущениями и разными стремлениями, соответственно, разное наше и
место, разное и наше распределение. Тебе я желаю все самые крутые тачки...

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
000000000000000000000000000________________________________000000000000000000000000000
00000000000000000000000________________________________________00000000000000000000000
00000000000000000000______________________________________________00000000000000000000
000000000000000000__________________________________________________000000000000000000
000000000000000_____00___________________________________________00____000000000000000
00000000000000______0000_______________________________________0000_____00000000000000
000000000000_________000000_________________________________000000________000000000000
0000000000___________00000000_____________________________0000000___________0000000000
000000000_____________000000000_________________________000000000____________000000000
00000000______________0000__000000___________________000000__000______________00000000
0000000________________000____000000_______________00000_____000_______________0000000
000000_________________000_______00000__________000000______000_________________000000
00000___________________000________000000_____000000_______0000__________________00000
0000____________________0000_________000000_00000__________000____________________0000
000______________________000___________00000000___________0000_____________________000
000______________________0000__________00000000___________000______________________000
000_______________________000_______000000__000000_______000________________________00
00_________________________000____00000________00000_____000________________________00
00_________________________0000000000____________0000000000__________________________0
00__________________________0000000________________00000000_________________________00
0__________________________00000______________________00000__________________________0
0________________________0000000______________________00000000_______________________0
0_____________________00000000000_____________________0000000000_____________________0
0__________________0000000____000____________________000_____00000___________________0
0________________000000_______0000___________________000_______00000_________________0
0______________000000__________000__________________000__________000000______________0
00__________000000______________000_________________000_____________00000___________00
00________00000_________________000________________000________________00000__________0
00______00000____________________000______________0000__________________000000______00
00____0000000000000000000000000000000000000000000000000000000000000000000000000_____00
000__000000000000000000000000000000000000000000000000000000000000000000000000000___000
000_______________________________000____________000_______________________________000
0000_______________________________000__________000_______________________________0000
00000______________________________0000_________000______________________________00000
000000______________________________000________000______________________________000000
0000000______________________________000______0000_____________________________0000000
00000000_____________________________000______000_____________________________00000000
000000000_____________________________000_____000____________________________000000000
0000000000____________________________000____000____________________________0000000000
000000000000___________________________000__0000__________________________000000000000
00000000000000_________________________00000000__________________________0000000000000
000000000000000_________________________000000_________________________000000000000000
000000000000000000______________________000000______________________000000000000000000
00000000000000000000_____________________0000_____________________00000000000000000000
00000000000000000000000__________________0000__________________00000000000000000000000
00000000000000000000000000________________00________________00000000000000000000000000
00000000000000000000000000000000______________________00000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 */


//author ----> noobiesAG

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int                long long
#define double             long double
#define pb                 push_back
#define mp                 make_pair
#define ld                 long double
#define vi                 vector<int>
#define vvi                vector<vector<int>>
#define vpii               vector<pair<int,int>>
#define pii                pair<int,int>
#define mii                map<int,int>
#define umap               unordered_map
#define all(c)             c.begin(),c.end()
#define si(c)              (int)c.size()
#define lb                 lower_bound
#define ub                 upper_bound
#define gi                 greater<int>
#define rev                reverse
#define ff                 first
#define ss                 second
#define yes                cout << "YES" << endl
#define no                 cout << "NO" << endl
#define ayes               cout << "Yes" << endl
#define ano                cout << "No" << endl
#define nl                 cout << endl
#define hello              cerr << "hello" << endl
#define sp(x)              fixed << setprecision(x)
#define re                 return
#define p_q                priority_queue
#define FAST               ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_multiset;
//find_by_order(k)  --> value at kth index (iterator)
//order_of_key(k)   --> index of value k

void dbg_out(){cerr << endl;}
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)

const double pi = 3.14159265359;
const int mod = 1000000007;
const int modc = 998244353;
const int inf = LLONG_MAX;
const int neg_inf = LLONG_MIN;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); //use rng() instead of rand() //shuffle(all(a),rng)

int inline power(int a, int b, int p){
    a %= p;
    int ans = 1;
    while(b>0){
        if(b & 1)
            ans = (ans*a)%p;
        a = (a*a)%p;
        b >>= 1;
    }
    return ans;
}

int mod_inv(int n, int p){
    return power(n,p-2, p);
}

bool inline isPrime(int n) {
    if (n <= 1)  return false;
    if (n <= 3)  return true;
    if (n%2 == 0 || n%3 == 0) return false;
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
    return true;
}
template<typename... T>
void W(T&&... args)
{
	((cout << sp(17) <<  args << " "), ...);
	nl;
}
template<typename... T>
void R(T&&... args)
{
	((cin >> args), ...);
}
int ston(string s)
{
	int a = 0;
	reverse(s.begin(),s.end());
	int pow = 1;
	for(int i=0;i<s.size();i++)
	{
		a += pow*(s[i]-'0');
		pow*=10;
	}
	return a;
}
template <class T>
string to_binary(T n)
{
	string binaryNum;
	int i = 0;
	while (n > 0) {
		binaryNum.pb((n % 2)+'0');
		n = n / 2;
		i++;
	}
	if(si(binaryNum) == 0)
		binaryNum.pb('0');
	reverse(binaryNum.begin(),binaryNum.end());
	return binaryNum;
}
int bton(string &s, int base)
{
	int ans = 0;
	int pow  = 1;
	rev(all(s));
	for(auto x : s)
	{
		if(x >= 'a' && x <= 'z')
			ans += (x - 'a' + 10)*pow;
		else
			ans += (x-'0')*pow;
		pow *= base;
	}
	return ans;
}
template<class T>
void wv(T &v)
{
	for(auto x : v)
		cout << x << " " ;
	nl;
}
template<class T>
void rv(T &v)
{
	for(int i=0;i<si(v);i++)
		cin >> v[i];
}

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
const int M = 5e5;
/*
int fact[M];
int ncr(int n, int r)
{
	int ans = fact[n];
	int denom = (fact[r]*fact[n-r])%mod;
	ans = (ans * mod_inv(denom,mod))%mod;
	return ans;
}
*/
//vector<int>v[M];

void solve()
{
	int i,j,sum = 0,prod = 1,maxl = neg_inf, minl = inf;
	int n;
	cin >> n;
	string s,t;
	cin >> s >> t;
	if(s == t)
	{
		W(0);
		re;
	}
	int one_s = 0 , one_t = 0;
	for(i=0;i<n;i++)
	{
		if(s[i] == '1')
			one_s++;
		if(t[i] == '1')
			one_t++;
	}
	if(one_s != one_t)
	{
		W(-1);
		re;
	}
	string diff;
	for(i=0;i<n;i++)
		if(s[i] != t[i])
			diff.pb(s[i]);
	set<int>one,zero;
	for(i=0;i<si(diff);i++)
		if(diff[i] == '1')
			one.insert(i);
		else
			zero.insert(i);
	int ans = 0;
	while(1)
	{
		if(si(zero) == 0 || si(one) == 0)
		{
			ans += si(zero) + si(one);
			break;
		}
		int end = -1;
		int last = -1;
		int first_zero = *zero.begin();
		int first_one = *one.begin();
		if(first_zero < first_one)
		{
			end = 0;
			last = first_zero;
			zero.erase(zero.begin());
		}
		else
		{
			end = 1;
			last = first_one;
			one.erase(one.begin());
		}
		while(1)
		{
			if(end == 0)
			{
				auto it = one.lb(last);
				if(it == one.end())
					break;
				last = *it;
				end = 1;
				one.erase(it);
			}
			else
			{
				auto it = zero.lb(last);
				if(it == zero.end())
					break;
				last = *it;
				end = 0;
				zero.erase(it);
			}
		}
		ans++;
	}
	cout << ans << endl;
}
int32_t main()
{
	FAST;
	int t = 1;
	/*
	fact[0] = 1;
	for(int i = 1;i<M;i++)
		fact[i] = (i * fact[i-1])%mod;
		*/
	int test = 1;
	while(t--)
	{
		//cout << "Case #" << test << ": ";
		solve();
		test++;
	}
}


//author ----> noobiesAG

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int                long long
#define double             long double
#define pb                 push_back
#define mp                 make_pair
#define ld                 long double
#define vi                 vector<int>
#define vvi                vector<vector<int>>
#define vpii               vector<pair<int,int>>
#define pii                pair<int,int>
#define mii                map<int,int>
#define umap               unordered_map
#define all(c)             c.begin(),c.end()
#define si(c)              (int)c.size()
#define lb                 lower_bound
#define ub                 upper_bound
#define gi                 greater<int>
#define rev                reverse
#define ff                 first
#define ss                 second
#define yes                cout << "YES" << endl
#define no                 cout << "NO" << endl
#define ayes               cout << "Yes" << endl
#define ano                cout << "No" << endl
#define nl                 cout << endl
#define hello              cerr << "hello" << endl
#define sp(x)              fixed << setprecision(x)
#define re                 return
#define p_q                priority_queue
#define FAST               ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_multiset;
//find_by_order(k)  --> value at kth index (iterator)
//order_of_key(k)   --> index of value k

void dbg_out(){cerr << endl;}
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)

const double pi = 3.14159265359;
const int mod = 1000000007;
const int modc = 998244353;
const int inf = LLONG_MAX;
const int neg_inf = LLONG_MIN;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); //use rng() instead of rand() //shuffle(all(a),rng)

int inline power(int a, int b, int p){
    a %= p;
    int ans = 1;
    while(b>0){
        if(b & 1)
            ans = (ans*a)%p;
        a = (a*a)%p;
        b >>= 1;
    }
    return ans;
}

int mod_inv(int n, int p){
    return power(n,p-2, p);
}

bool inline isPrime(int n) {
    if (n <= 1)  return false;
    if (n <= 3)  return true;
    if (n%2 == 0 || n%3 == 0) return false;
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
    return true;
}
template<typename... T>
void W(T&&... args)
{
	((cout << sp(17) <<  args << " "), ...);
	nl;
}
template<typename... T>
void R(T&&... args)
{
	((cin >> args), ...);
}
int ston(string s)
{
	int a = 0;
	reverse(s.begin(),s.end());
	int pow = 1;
	for(int i=0;i<s.size();i++)
	{
		a += pow*(s[i]-'0');
		pow*=10;
	}
	return a;
}
template <class T>
string to_binary(T n)
{
	string binaryNum;
	int i = 0;
	while (n > 0) {
		binaryNum.pb((n % 2)+'0');
		n = n / 2;
		i++;
	}
	if(si(binaryNum) == 0)
		binaryNum.pb('0');
	reverse(binaryNum.begin(),binaryNum.end());
	return binaryNum;
}
int bton(string &s, int base)
{
	int ans = 0;
	int pow  = 1;
	rev(all(s));
	for(auto x : s)
	{
		if(x >= 'a' && x <= 'z')
			ans += (x - 'a' + 10)*pow;
		else
			ans += (x-'0')*pow;
		pow *= base;
	}
	return ans;
}
template<class T>
void wv(T &v)
{
	for(auto x : v)
		cout << x << " " ;
	nl;
}
template<class T>
void rv(T &v)
{
	for(int i=0;i<si(v);i++)
		cin >> v[i];
}

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
const int M = 5e5;
/*
int fact[M];
int ncr(int n, int r)
{
	int ans = fact[n];
	int denom = (fact[r]*fact[n-r])%mod;
	ans = (ans * mod_inv(denom,mod))%mod;
	return ans;
}
*/
//vector<int>v[M];

void solve()
{
	int i,j,sum = 0,prod = 1,maxl = neg_inf, minl = inf;
	int n;
	cin >> n;
	string s,t;
	cin >> s >> t;
	if(s == t)
	{
		W(0);
		re;
	}
	int one_s = 0 , one_t = 0;
	for(i=0;i<n;i++)
	{
		if(s[i] == '1')
			one_s++;
		if(t[i] == '1')
			one_t++;
	}
	if(one_s != one_t)
	{
		W(-1);
		re;
	}
	string diff;
	for(i=0;i<n;i++)
		if(s[i] != t[i])
			diff.pb(s[i]);
	set<int>one,zero;
	for(i=0;i<si(diff);i++)
		if(diff[i] == '1')
			one.insert(i);
		else
			zero.insert(i);
	int ans = 0;
	while(1)
	{
		if(si(zero) == 0 || si(one) == 0)
		{
			ans += si(zero) + si(one);
			break;
		}
		int end = -1;
		int last = -1;
		int first_zero = *zero.begin();
		int first_one = *one.begin();
		if(first_zero < first_one)
		{
			end = 0;
			last = first_zero;
			zero.erase(zero.begin());
		}
		else
		{
			end = 1;
			last = first_one;
			one.erase(one.begin());
		}
		while(1)
		{
			if(end == 0)
			{
				auto it = one.lb(last);
				if(it == one.end())
					break;
				last = *it;
				end = 1;
				one.erase(it);
			}
			else
			{
				auto it = zero.lb(last);
				if(it == zero.end())
					break;
				last = *it;
				end = 0;
				zero.erase(it);
			}
			cerr << "hello" << '\n';
		}
		ans++;
	}
	cout << ans << endl;
}
int32_t main()
{
	FAST;
	int t = 1;
	/*
	fact[0] = 1;
	for(int i = 1;i<M;i++)
		fact[i] = (i * fact[i-1])%mod;
		*/
	int test = 1;
	while(t--)
	{
		//cout << "Case #" << test << ": ";
		solve();
		test++;
	}
}


/*╔═══╗──╔╗╔╗───────────────────╔╗────────╔═══╦═══╗
  ║║─║╠╗╠╗╔╣╚═╦══╦═╗╔╦╗╔═╗╔══╦══╣╚═╦╦══╦══╣║─║║║─╚╝
  ║╔═╗║╚╝║╚╣║║║╚╝║║─╔╦╗║║║║╚╝║╚╝║╚╝║║║═╬══║╔═╗║╚╩═║
  ╚╝─╚╩══╩═╩╝╚╩══╩╝─╚╩╝╚╝╚╩══╩══╩══╩╩══╩══╩╝─╚╩═══╝*/

#include<bits/stdc++.h>
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pdbs;
template <typename T> using ordered_set =  tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

1. order_of_key(k) : number of elements strictly lesser than k
2. find_by_order(k) : k-th element in the set
*/
//#define int long long

using namespace std;

#define f(i,k,n) for(i=k;i<n;i++)
#define fd(i,k,n) for(i=k;i>n;i--)
#define pb push_back
#define mp make_pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mii map<int,int>
#define mll map<ll,ll>
#define umap unordered_map
#define all(c) c.begin(),c.end()
#define sz(c) (int)c.size()
#define si(c) (int)c.size()
#define lb lower_bound
#define ub upper_bound
#define gi greater<int>
#define rev reverse
#define ff first
#define ss second
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define imp cout << "IMPOSSIBLE" << endl
#define nl cout << endl
#define hello cout << "hello" << endl
#define sp(x) fixed << setprecision(x)
#define re return
#define p_q priority_queue
#define FAST ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);

//debugging
void dbg_out(){cerr << endl;}
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)

const double pi = 3.14159265359;
const ll mod = 1000000007;
const ll modc = 998244353;

ll inline power(ll a, ll b, ll p){
    a %= p;
    ll ans = 1;
    while(b>0){
        if(b & 1)
            ans = (ans*a)%p;
        a = (a*a)%p;
        b >>= 1;
    }
    return ans;
}

ll mod_inv(ll n, ll p){
    return power(n,p-2, p);
}

bool inline isPrime(ll n) {
    if (n <= 1)  return false;
    if (n <= 3)  return true;
    if (n%2 == 0 || n%3 == 0) return false;
    for (ll i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
    return true;
}
template<typename... T>
void W(T&&... args)
{
	((cout << sp(9) <<  args << " "), ...);
	nl;
}
template<typename... T>
void R(T&&... args)
{
	((cin >> args), ...);
}
ll ston(string s)
{
	ll a = 0;
	reverse(s.begin(),s.end());
	ll pow = 1;
	for(int i=0;i<s.size();i++)
	{
		a += pow*(s[i]-'0');
		pow*=10;
	}
	return a;
}
template <class T>
string to_binary(T n)
{
	string binaryNum;
	int i = 0;
	while (n > 0) {
		binaryNum.pb((n % 2)+'0');
		n = n / 2;
		i++;
	}
	reverse(binaryNum.begin(),binaryNum.end());
	return binaryNum;
}
template<class T>
void wv(T &v)
{
	for(auto x : v)
		cout << x << " " ;
	nl;
}
template<class T>
void rv(T &v)
{
	for(int i=0;i<sz(v);i++)
		cin >> v[i];
}

//to safe_guard unordered_map<> in STL
//now declare something as unordered_map<int,int,custom_hash>mp :)
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

/*
 * USING WITH STRUCT
   Define a structure .
   Initialize variables in structure.
   Define another structure of type compare.(don't use bool operator < for stl containers (since it is there in std namespace);
   Overload the variables of structure in compare structure.(bool operator()(arguments){} )
   Use container with compare structure. (priority queue me ulta)
*/
/*
      FUNCTIONS YOU ARE USING
    * ll inline power(ll a, ll b, ll p)
    * ll mod_inv(ll n, ll p)
    * bool inline isPrime(ll n)
    * ll ston(string s)
    * string to_binary(T n)
*/
/*
 *int overflow (ll vs int)
 *array out of bounds(runtime errors)
 *special cases (n=1)?
 *don't store large numbers in double(use long double instead)
 *BINARY SEARCH ??
 *BRUTE FORCE with some optimization ??
 *in compare return true if you want to place first argument before second argument(p_q me ulta)(bool operator<)(bool operator())
 *Use custom_hash with unordered_map to avoid collisions
 *Think of your approach for one more minute if it will work or not , otherwise you will end up implementing shit as always :(
 *use factor cmd to get prime factorization of something instead of writing another code for it :)
 *DO SOMETHING INSTEAD OF NOTHING
*/
const int M = 2e5;//for graph

void solve()
{
	int i,j;ll sum = 0,prod = 1;ll maxl = LLONG_MIN, minl = LLONG_MAX;int maxi = INT_MIN,mini = INT_MAX;
	int n;
	cin >> n;
	string s,t;
	cin >> s >> t;
	if(s == t)
	{
		W(0);
		re;
	}
	int s1 = 0,t1 = 0;
	for(i=0;i<n;i++)
	{
		if(s[i] == '1')
			s1++;
		if(t[i] == '1')
			t1++;
	}
	if(s1 != t1)
	{
		W(-1);
		re;
	}
	vi diff;
	for(i=0;i<n;i++)
		if(s[i] != t[i])
			diff.pb(i);
	//choosing 01010101
	int size = 0;
	for(auto x : diff)
	{
		if(size%2 + '0' == s[x])
			size++;
	}
	int size1 = 0;
	for(auto x : diff)
	{
		if(!(size1%2) + '0' == s[x])
			size1++;
	}
	if(size%2)
		size--;
	if(size1%2)
		size1--;
	size = max(size,size1);
	cout << (si(diff)-size)/2 + (size > 0) << endl;
}
int32_t main()
{
	FAST;
	int t = 1;
	while(t--)
	{
		solve();
	}
}


//author ----> noobiesAG

#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;

#define int                long long
#define double             long double
#define pb                 push_back
#define mp                 make_pair
#define ld                 long double
#define vi                 vector<int>
#define vvi                vector<vector<int>>
#define vpii               vector<pair<int,int>>
#define pii                pair<int,int>
#define mii                map<int,int>
#define umap               unordered_map
#define all(c)             c.begin(),c.end()
#define si(c)              (int)c.size()
#define lb                 lower_bound
#define ub                 upper_bound
#define gi                 greater<int>
#define rev                reverse
#define ff                 first
#define ss                 second
#define yes                cout << "YES" << endl
#define no                 cout << "NO" << endl
#define ayes               cout << "Yes" << endl
#define ano                cout << "No" << endl
#define nl                 cout << endl
#define hello              cerr << "hello" << endl
#define sp(x)              fixed << setprecision(x)
#define re                 return
#define p_q                priority_queue
#define FAST               ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL)

typedef tree<int, null_type, less<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_set;
typedef tree<int, null_type, less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>ordered_multiset;
//find_by_order(k)  --> value at kth index (iterator)
//order_of_key(k)   --> index of value k

void dbg_out(){cerr << endl;}
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)

const double pi = 3.14159265359;
const int mod = 1000000007;
const int modc = 998244353;
const int inf = LLONG_MAX;
const int neg_inf = LLONG_MIN;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count()); //use rng() instead of rand() //shuffle(all(a),rng)

int inline power(int a, int b, int p){
    a %= p;
    int ans = 1;
    while(b>0){
        if(b & 1)
            ans = (ans*a)%p;
        a = (a*a)%p;
        b >>= 1;
    }
    return ans;
}

int mod_inv(int n, int p){
    return power(n,p-2, p);
}

bool inline isPrime(int n) {
    if (n <= 1)  return false;
    if (n <= 3)  return true;
    if (n%2 == 0 || n%3 == 0) return false;
    for (int i=5; i*i<=n; i=i+6)
        if (n%i == 0 || n%(i+2) == 0)
           return false;
    return true;
}
template<typename... T>
void W(T&&... args)
{
	((cout << sp(17) <<  args << " "), ...);
	nl;
}
template<typename... T>
void R(T&&... args)
{
	((cin >> args), ...);
}
int ston(string s)
{
	int a = 0;
	reverse(s.begin(),s.end());
	int pow = 1;
	for(int i=0;i<s.size();i++)
	{
		a += pow*(s[i]-'0');
		pow*=10;
	}
	return a;
}
template <class T>
string to_binary(T n)
{
	string binaryNum;
	int i = 0;
	while (n > 0) {
		binaryNum.pb((n % 2)+'0');
		n = n / 2;
		i++;
	}
	if(si(binaryNum) == 0)
		binaryNum.pb('0');
	reverse(binaryNum.begin(),binaryNum.end());
	return binaryNum;
}
int bton(string &s, int base)
{
	int ans = 0;
	int pow  = 1;
	rev(all(s));
	for(auto x : s)
	{
		if(x >= 'a' && x <= 'z')
			ans += (x - 'a' + 10)*pow;
		else
			ans += (x-'0')*pow;
		pow *= base;
	}
	return ans;
}
template<class T>
void wv(T &v)
{
	for(auto x : v)
		cout << x << " " ;
	nl;
}
template<class T>
void rv(T &v)
{
	for(int i=0;i<si(v);i++)
		cin >> v[i];
}

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
const int M = 5e5;
/*
int fact[M];
int ncr(int n, int r)
{
	int ans = fact[n];
	int denom = (fact[r]*fact[n-r])%mod;
	ans = (ans * mod_inv(denom,mod))%mod;
	return ans;
}
*/
//vector<int>v[M];

void solve()
{
	int i,j,sum = 0,prod = 1,maxl = neg_inf, minl = inf;
	int n;
	cin >> n;
	string s,t;
	cin >> s >> t;
	if(s == t)
	{
		W(0);
		re;
	}
	int one_s = 0 , one_t = 0;
	for(i=0;i<n;i++)
	{
		if(s[i] == '1')
			one_s++;
		if(t[i] == '1')
			one_t++;
	}
	if(one_s != one_t)
	{
		W(-1);
		re;
	}
	string diff;
	for(i=0;i<n;i++)
		if(s[i] != t[i])
			diff.pb(s[i]);
	set<int>one,zero;
	for(i=0;i<si(diff);i++)
		if(diff[i] == '1')
			one.insert(i);
		else
			zero.insert(i);
	int ans = 0;
	while(1)
	{
		if(si(zero) == 0 || si(one) == 0)
		{
			ans += si(zero) + si(one);
			break;
		}
		int end = -1;
		int last = -1;
		int first_zero = *zero.begin();
		int first_one = *one.begin();
		if(first_zero < first_one)
		{
			end = 0;
			last = first_zero;
			zero.erase(zero.begin());
		}
		else
		{
			end = 1;
			last = first_one;
			one.erase(one.begin());
		}
		while(1)
		{
			if(end == 0)
			{
				auto it = one.lb(last);
				if(it == one.end())
					break;
				last = *it;
				end = 1;
				one.erase(it);
			}
			else
			{
				auto it = zero.lb(last);
				if(it == zero.end())
					break;
				last = *it;
				end = 0;
				zero.erase(it);
			}
		}
		ans++;
	}
	dbg("hello");
	cout << ans << endl;
}
int32_t main()
{
	FAST;
	int t = 1;
	/*
	fact[0] = 1;
	for(int i = 1;i<M;i++)
		fact[i] = (i * fact[i-1])%mod;
		*/
	int test = 1;
	while(t--)
	{
		//cout << "Case #" << test << ": ";
		solve();
		test++;
	}
}