#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
//#pragma GCC optimize("Ofast") //#pragma GCC optimize "unroll-loops" //#pragma GCC target "mmx,sse,sse2,sse3,sse4,avx,avx2,fma,abm,popcnt,tune=native" //#pragma GCC optimize "prefetch-loop-arrays"
using namespace std; using namespace __gnu_pbds;
#define foru(i,a,b) for(int i=(a);i<(b);i++)
#define ford(i,a,b) for(int i=(a)-1;i>=(b);i--)
#define fori(a,b) foru(i,a,b)
#define forj(a,b) foru(j,a,b)
#define fork(a,b) foru(k,a,b)
#define seto(x,i) memset(x,i,sizeof x)
#define pf first
#define ps second
#define pb push_back
#define eb emplace_back
#define em emplace
#define mp make_pair
#define mt make_tuple
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define clz __builtin_clz
#define clzll __builtin_clzll
#define ctz __builtin_ctz
#define ctzll __builtin_ctzll
#define P2(x) (1LL<<(x))
#define sz(x) (int)x.size()
#define all(x) begin(x),end(x)
#define lwb lower_bound
#define upb upper_bound
#if __SIZEOF_INT128__
    typedef __int128_t i128; typedef __uint128_t ui128;
#endif
typedef int64_t ll;  typedef uint64_t ull; typedef long double lld; typedef pair<int,int> pii; typedef pair<ll,ll> pll; typedef pair<lld,lld> pdd;
template<class T1,class T2> using ordered_map=tree<T1,T2,less<T1>,rb_tree_tag,tree_order_statistics_node_update>; template<class T1> using ordered_set=ordered_map<T1,null_type>;
template<class T> using minpq=std::priority_queue<T,vector<T>,greater<T>>; template<class T> using maxpq=std::priority_queue<T,vector<T>,less<T>>;
template<class T> using minpairingheap=__gnu_pbds::priority_queue<T,greater<T>,pairing_heap_tag>; template<class T>using maxpairingheap=__gnu_pbds::priority_queue<T,less<T>,pairing_heap_tag>;
const int inf=0x3f3f3f3f,MOD=1e9+7; const ll INF=0x3f3f3f3f3f3f3f3f; const lld PI=acos((lld)-1);
const ll SEED=443214^chrono::duration_cast<chrono::nanoseconds>(chrono::high_resolution_clock::now().time_since_epoch()).count();
mt19937 randgen(SEED); ll rand(ll a, ll b){return uniform_int_distribution<ll>(a,b)(randgen);}
ll gcd(ll a, ll b){return b?gcd(b,a%b):a;}
ll fpow(ll a,ll b){ll ret=1;for(;b;b>>=1){if(b&1) ret=ret*a%MOD;a=a*a%MOD;}return ret;} ll fpow(ll a,ll b,ll M){ll ret=1;for(;b;b>>=1){if(b&1) ret=ret*a%M;a=a*a%M;}return ret;}
template<class T1,class T2>constexpr const auto _min(const T1&x,const T2&y){return x<y?x:y;} template<class T,class...Ts>constexpr auto _min(const T&x,const Ts&...xs){return _min(x,_min(xs...));}
template<class T1,class T2>constexpr const auto _max(const T1&x,const T2&y){return x>y?x:y;} template<class T,class...Ts>constexpr auto _max(const T&x,const Ts&...xs){return _max(x,_max(xs...));}
#define min(...) _min(__VA_ARGS__)
#define max(...) _max(__VA_ARGS__)
template<class T1,class T2>constexpr bool ckmin(T1&x,const T2&y){return x>y?x=y,1:0;} template<class T,class...Ts>constexpr bool ckmin(T&x,const Ts&...xs){return ckmin(x,min(xs...));}
template<class T1,class T2>constexpr bool ckmax(T1&x,const T2&y){return x<y?x=y,1:0;} template<class T,class...Ts>constexpr bool ckmax(T&x,const Ts&...xs){return ckmax(x,max(xs...));}
template<class T1,class T2,class T3,class T4> constexpr const auto operator+(const pair<T1,T2>& a,const pair<T3,T4>& b){return mp(a.pf+b.pf,a.ps+b.ps);}
template<class T1,class T2,class T3,class T4> constexpr const auto operator-(const pair<T1,T2>& a,const pair<T3,T4>& b){return mp(a.pf-b.pf,a.ps-b.ps);}
template<class T1,class T2,class T3> constexpr const auto operator *(const pair<T1,T2>& a,const T3& b){return mp(a.pf*b,a.ps*b);}
template<class T1,class T2,class T3> constexpr const auto operator *(const T1& a,const pair<T2,T3>& b){return b*a;}
template<class T1,class T2,class T3> constexpr const auto operator /(const pair<T1,T2>& a,const T3& b){return mp(a.pf/b,a.ps/b);}
template<class T1,class T2,class T3,class T4> constexpr const auto& operator+=(pair<T1,T2> &a,const pair<T3,T4> &b){return a=a+b;}
template<class T1,class T2,class T3,class T4> constexpr const auto& operator-=(pair<T1,T2> &a,const pair<T3,T4> &b){return a=a-b;}
template<class T1,class T2,class T3> constexpr const auto& operator*=(pair<T1,T2> &a,const T3 &b){return a=a*b;}
template<class T1,class T2,class T3> constexpr const auto& operator/=(pair<T1,T2> &a,const T3 &b){return a=a/b;}
template<class T,class U> void erase(T& t,const U& u){auto it=t.find(u);if(it!=end(t)) t.erase(it);}
template<class T> T pop(queue<T> &a){auto b=a.front(); a.pop(); return b;} template<class T> auto pop(T &a){auto b=a.top(); a.pop(); return b;}
template<class T> T operator -(vector<T> &a,size_t x){return a[a.size()-x];} template<class T> T operator -(deque<T> &a,size_t x){return a[a.size()-x];}
struct chash{
    static ll splitmix64(ll x){x+=0x9e3779b97f4a7c15; x=(x^(x>>30))*0xbf58476d1ce4e5b9; x=(x^(x>>27))*0x94d049bb133111eb; return x^(x>>31);}
    template<class T> size_t operator()(const T &x) const{return splitmix64(hash<T>()(x)+SEED);}
    template<class T1,class T2> size_t operator()(const pair<T1,T2>&x)const{return 31*operator()(x.first)+operator()(x.second);}};
void fin(string s){freopen(s.c_str(),"r",stdin);} void fout(string s){freopen(s.c_str(),"w",stdout);} void fio(string s){fin(s+".in"); fout(s+".out");}
string to_string(char c){return string(1,c);} string to_string(char* s){return (string)s;} string to_string(string s){return s;}
template<class T> string to_string(complex<T> c){stringstream ss; ss<<c; return ss.str();}
template<class T1,class T2> string to_string(pair<T1,T2> p){return "("+to_string(p.pf)+","+to_string(p.ps)+")";}
template<class T1,class T2,class T3> string to_string(tuple<T1,T2,T3> p){auto [a,b,c]=p; return "("+to_string(a)+","+to_string(b)+","+to_string(c)+")";}
template<class T1,class T2,class T3,class T4> string to_string(tuple<T1,T2,T3,T4> p){auto [a,b,c,d]=p; return "("+to_string(a)+","+to_string(b)+","+to_string(c)+","+to_string(d)+")";}
template<class T> string to_string(T v){string ret="{"; for(const auto& x:v) ret+=to_string(x)+","; return ret+"}";}
void DBG(){cerr<<"]"<<endl;} template<class T,class... Ts> void DBG(T x,Ts... xs){cerr<<to_string(x); if(sizeof...(xs)) cerr<<", "; DBG(xs...);}
#ifdef LOCAL
    #define dbg(...) cerr<<"Line("<< __LINE__<<") -> ["<<#__VA_ARGS__<<"]: [", DBG(__VA_ARGS__)
#else
    #define dbg(...) 0
#endif
#define nl "\n"

const int N=1e6+10,M=MOD;
ll n,x,y,z,p;
string s;
vector<pll> ans,ans1;
set<tuple<ll,ll,ll>> a,b,b0;
struct BITree{
    int bit[N];
    void upd(int x,int v){
        for(ckmin(++x,N);x<N;x+=x&-x) bit[x]+=v;
    }
    int query(int x){
        int ret=0;
        for(ckmin(++x,N);x;x-=x&-x) ret+=bit[x];
        return ret;
    }
    int query(int l,int r){
        return query(r)-query(l-1);
    }
} bit;
void er(ll a,ll b){
    assert(b>1);
    while(b){
        if(b==3){
            ans1.eb(a,3);
            b-=3;
        }
        else{
            ans1.eb(a,2);
            b-=2;
        }
    }
}
void ins(ll l,ll r,ll m){
    if(l>r){
        return;
    }
    b.em(m,l,r);
    b0.em(l,r,m);
    if(p) p+=max(1,(m+1)/2);
}
void del(ll m,ll l,ll r){
    b.erase(mt(m,l,r));
    b0.erase(mt(l,r,m));
    if(p) p-=max(1,(m+1)/2);
}
void solve(){
    #ifdef LOCAL
        fin("a.txt");
    #endif // LOCAL
    cin>>n;
    cin>>s; s="."+s+".";
    x=1;
    fori(1,n+1){
        if(s[i]!=s[i+1]){
            a.em(x,i,i-x+1);
            dbg(x,i,i-x+1);
            x=i+1;
        }
    }
    x=y=0;
    for(auto &[l,r,m]:a){
        if(m==1){
            x++; ckmax(z,x);
            if(y==0) y=l;
        }
        else{
            if(x){
                p+=x;
                b.em(x*2-(y==1),y,y+x-1);
                b0.em(y,y+x-1,x*2-(y==1));
            }
            x=0; y=0; p++;
            b.em(0,l,r);
            b0.em(l,r,0);
        }
    }
    if(x){
        p+=x;
        b.em(x*2-1,y,n);
        b0.em(y,n,x*2-1);
    }
    b0.em(inf,inf,-1);
    b0.em(inf+1,inf+1,-1);
    b0.em(-inf,-inf,-1);
    b0.em(-inf-1,-inf-1,-1);
    for(auto [a,b,c]:b0){
        dbg(a,b,c);
    }
    while(sz(b)){
        for(auto [a,b,c]:b0){
            dbg(a,b,c);
        }
        auto [m,l,r]=*b.rbegin();
        if(p){
            auto [l0,r0,m0]=*next(next(b0.rbegin()));
            auto [l1,r1,m1]=*next(next(b0.begin()));
            if(m1==0||m0==0){
                p=0;
                continue;
            }
            ll mm1=(m1+1)/2;
            ll mm0=(m0+1)/2;
            if(mm1+mm0>=p-1-mm0-mm1-1){
                if(m0>m1){
                    l=l0; r=r0; m=m0;
                }
                else{
                    l=l1; r=r1; m=m1;
                }
            }
        }
        if(m==0){
            ans.eb(l,r);
            b.erase(mt(m,l,r));
            b0.erase(mt(l,r,m));
            continue;
        }
        dbg(m,l,r);
        auto [l0,r0,m0]=*next(next(b0.find(mt(l,r,m))));
        auto [l1,r1,m1]=*prev(prev(b0.find(mt(l,r,m))));
        if(m0<=m1){
            auto [l0,r0,m0]=mt(l1,r1,m1);
            if(m0==-1){
                cout<<-1;
                return;
            }
            ans.eb(r0+1,l-1);
            del(m0,l0,r0);
            del(0,r0+1,l-1);
            del(m,l,r);
            ins(l+1,r,m-2);
            if(m0<=0){
                ins(l0,l,0);
            }
            else{
                ins(l0,r0-1,m0-2);
                ins(r0,l,0);
            }
            continue;
        }
        ans.eb(r+1,l0-1);
        del(m0,l0,r0);
        del(0,r+1,l0-1);
        del(m,l,r);
        ins(l,r-1,m-2);
        if(m0<=0){
            ins(r,r0,0);
        }
        else{
            ins(l0+1,r0,m0-2);
            ins(r,l0,0);
        }
    }
    dbg(ans);
    for(auto &[l,r]:ans){
        ll l0=l,r0=r;
        l0-=bit.query(l); r0-=bit.query(r);
        bit.upd(l,r0-l0+1);
        er(l0,r0-l0+1);
    }
    cout<<sz(ans1)<<nl;
    for(auto &[l,r]:ans1){
        cout<<l<<" "<<r<<nl;
    }
}
int main(){
    cin.tie(0)->sync_with_stdio(0);
    int T=1; //cin>>T;
    foru(t,1,T+1){
        solve();
    }
    return 0;
}
/**

*/