#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto& i:a)
#define ff first 
#define ss second 
#define all(a) begin(a),end(a)
#define allr(a) rbegin(a),rend(a)
#define pb push_back
using ll =long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
template<class T> inline bool chmin(T& a,T b){return a>b?a=b,1:0;}
template<class T> inline bool chmax(T& a,T b){return a<b?a=b,1:0;}

const int INFI=numeric_limits<int>::max()/2;
const ll INFL=numeric_limits<ll>::max()/2;

template< typename T, typename F >
struct SegmentTree {
    int n, sz;
    vector< T > seg;
    const F f;
    const T ti;
    SegmentTree() = default;
    explicit SegmentTree(int n, const F f, const T &ti) : n(n), f(f), ti(ti) {
        sz = 1;
        while(sz < n) sz <<= 1;
        seg.assign(2 * sz, ti);
    }
    explicit SegmentTree(const vector< T > &v, const F f, const T &ti) :
        SegmentTree((int) v.size(), f, ti) {
        build(v);
    }
    void build(const vector< T > &v) {
        assert(n == (int) v.size());
        for(int k = 0; k < n; k++) seg[k + sz] = v[k];
        for(int k = sz - 1; k > 0; k--) {
            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
        }
    }
    void set(int k, const T &x) {
        k += sz;
        seg[k] = x;
        while(k >>= 1) {
            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
        }   
    }
    T get(int k) const {
        return seg[k + sz];
    }
    T operator[](const int &k) const {
        return get(k);
    }
    void apply(int k, const T &x) {
        k += sz;
        seg[k] = f(seg[k], x);
        while(k >>= 1) {
            seg[k] = f(seg[2 * k + 0], seg[2 * k + 1]);
        }
    }
    T prod(int l, int r) const {
        T L = ti, R = ti;
        for(l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
            if(l & 1) L = f(L, seg[l++]);
            if(r & 1) R = f(seg[--r], R);
        }
        return f(L, R);
    }
    T all_prod() const {
        return seg[1];
    }
    template< typename C >
    int find_first(int l, const C &check) const {
        if(l >= n) return n;
        l += sz;
        T sum = ti;
        do {
            while((l & 1) == 0) l >>= 1;
            if(check(f(sum, seg[l]))){ 
                while(l < sz) {
                    l <<= 1;
                    auto nxt = f(sum, seg[l]);
                    if(not check(nxt)) {
                        sum = nxt;
                        l++;
                    }
                }
                return l + 1 - sz;
            }
            sum = f(sum, seg[l++]);
        } while((l & -l) != l);
        return n;
    }

    template< typename C >
    int find_last(int r, const C &check) const {
        if(r <= 0) return -1;
        r += sz;
        T sum = ti;
        do {
            r--;
            while(r > 1 and (r & 1)) r >>= 1;
            if(check(f(seg[r], sum))) {
                while(r < sz) {
                    r = (r << 1) + 1;
                    auto nxt = f(seg[r], sum);
                    if(not check(nxt)) {
                        sum = nxt;
                        r--;
                    }
                }
                return r - sz;
            }
            sum = f(seg[r], sum);
        } while((r & -r) != r);
        return -1;
    } 
};


template< typename T, typename F >
SegmentTree< T, F > get_segment_tree(int N, const F &f, const T &ti) {
    return SegmentTree<T,F>{N, f, ti};
}

template< typename T, typename F >
SegmentTree< T, F > get_segment_tree(const vector< T > &v, const F &f, const T &ti) {
    return SegmentTree<T,F>{v, f, ti};
}
ll n,R,M;string s;
void solve(){

    vector<int> pref(2*n+1);
    vector<int> pre2(2*n+1);
    vector<int> pre3(2*n+1);
    rep(i,0,2*n){
        if(s[i%n]=='('){
            pref[i+1]++;
            pre2[i+1]++;
        }else{
            pref[i+1]--;
            pre3[i+1]++;
        }
        pref[i+1]+=pref[i];
        pre2[i+1]+=pre2[i];
        pre3[i+1]+=pre3[i];
    }
    auto seg=get_segment_tree(pref,[](int a,int b){return min(a,b);},INFI);
    int S=pref[n]/2;
    auto f=[&](int a,int k)->int {
        if(k>=n)return true;
        int x=(S+k)/2;int y=(k-S)/2;
        if(y<0)return false;
        int l,r;
        //cout<<endl;
        //cout<<k<<' '<<x<<' '<<y<<endl;
        //cout<<pre2[n]<<' '<<pre3[n]<<endl;
        {
            int ok=a+n;int ng=a-1;
            if(pre3[ok]-pre3[a]<y)return true;
            while(abs(ok-ng)>1){
                int mid=(ok+ng)/2;
                if(pre3[mid]-pre3[a]>=y)ok=mid;
                else ng=mid;
            }
            l=ok;
        }
        {
            int ok=a;int ng=a+n;
            if(pre2[a+n]-pre2[ok]<x)return true;
            while(abs(ok-ng)>1){
                int mid=(ok+ng)/2;
                if(pre2[a+n]-pre2[mid]>=x)ok=mid;
                else ng=mid;
            }
            r=ok;
        }
        //cout<<k<<' '<<x<<' '<<y<<' '<<l<<' '<<r<<' '<<seg.prod(l+1,r+1)<<endl;
        if(r-l<0)return true;
        return seg.prod(l+1,r+1)-pref[l]+(l-a)>=0;
    };
    ll ans{INFL};
    rep(i,0,n){
        //変更の回数
        int ok=n/2;
        int ng=-1;
        while(abs(ok-ng)>1){
            int mid=(ok+ng)/2;
            if(f(i,(abs(S)&1)+2*mid))ok=mid;
            else ng=mid;
        }
        //cout<<i<<' '<<((abs(S)&1)+2*ok)<<endl;
        ll cost=i*R;
        cost+=((S&1)+2*ok)*M;
        chmin(ans,cost);
    }
    //cout<<endl;
    cout<<ans<<endl;

}

int main(){
    cin>>n;
    cin>>s;
    cin>>R>>M;
    if(n&1){
        cout<<"-1"<<endl;
        return 0;
    }
    solve();
    return 0;
}
/*
6
()()()
1 1
*/