#include <bits/stdc++.h>
#include <random>
#define ll long long int
#define pb push_back
#define st first
#define nd second
#define pii pair<int,int>
#define mp make_pair
#define pll pair<long long,long long>
#define ld long double
#define ull unsigned long long

using namespace std;

const int nax = 2e5 + 5;
int v[4];
vector<int> pos[4];
int n;

map<tuple<int, int, bool> , bool> done;

bool Compare(pair<pll, tuple<int, int, bool> > s1, pair<pll, tuple<int, int, bool> > s2){
    return (s1.st.st * s2.st.nd > s1.st.nd * s2.st.st);
}

int wa = 0;

pll add(pll one, pll two){
    wa += 1;
    ll mian = one.nd * two.nd;
    ll licz = one.st * two.nd + two.st * one.nd;
    ll g = __gcd(licz, mian);
    return mp(licz / g, mian / g);
}

pll mul(pll one, pll two){
    ll licz = one.st * two.st;
    ll mian = one.nd * two.nd;
    ll g = __gcd(licz, mian);
    return mp(licz / g, mian / g);
}

int whichPas(int id){
    if(id < pos[1].size()) return 1;
    if(id < pos[1].size() + pos[2].size()) return 2;
    return 3;
}

int ktoryNaPasie(int id, int ktory){
    if(ktory == 1) return id;
    if(ktory == 2) return id - pos[1].size();
    return id - pos[1].size() - pos[2].size();
}

bool cmp(pll& one, pll& two){
    return one.st * two.nd < two.st * one.nd;
}

int ile[4][nax];
int za[4][nax];


pll intersect(pll& s1, pll& e1, pll& s2, pll& e2){
    pll s = s1;
    if(cmp(s1, s2)) s = s2;
    pll e = e1;
    if(cmp(e2, e1)) e = e2;
    if(cmp(e, s)) return mp(0, 1);
    pll res = add(e, mp(-s.st, s.nd));
    return res;
}


int mappedID(int pas, int which){
    int of = 0;
    if(pas >= 2) of += pos[1].size();
    if(pas >= 3) of += pos[2].size();
    return of + which;
}

pll gdzieOstatni(int pas, pll czas){
    int sz = pos[pas].size() - 1;
    ll start = pos[pas][sz];
    pll pojechal = mul(mp(v[pas], 1), czas);
    pojechal = add(pojechal, mp(start, 1));
    return pojechal;
}

void solve(){
    cin >> n;
    for(int i=0;i<4;i++) cin >> v[i];
    for(int i=0;i<3;i++){
        string s; cin >> s;
        for(int j=0;j<n;j++){
            if(s[j] == '#' && (i != 2 || j != 0)){
                pos[i + 1].pb(j);
                int sz = pos[i + 1].size();
                ile[i + 1][sz - 1] = 1;
                za[i + 1][sz - 1] = 1;
                if(sz >= 2 && pos[i + 1][sz - 2] == pos[i + 1][sz - 1] - 1){
                    ile[i + 1][sz - 1] += ile[i + 1][sz - 2];
                }
            }
        }
    }
    for(int i=1;i<=3;i++){
        int sz = pos[i].size();
        for(int j=sz-2;j>=0;j--){
            if(pos[i][j] + 1 == pos[i][j + 1]) za[i][j] += za[i][j + 1];
        }
    }
    // TODO: WYIFUJ JESLI ISTNIEJE PUSTY PAS!

    bool jestPusty = false;
    for(int i=1;i<=3;i++){
        if(pos[i].size() == 0) jestPusty = true;
    }

    if(jestPusty){
        pll ans = mp(0, 1);
        for(int i=1;i<=3;i++){
            if(pos[i].size()){
                pll last = gdzieOstatni(i, mp(0, 1));
                pll tmp = mp(1, 1);
                last = add(last, tmp);
                ll predkosc = v[0] - v[i];
                pll posible = mp(last.st, last.nd * predkosc);
                if(cmp(ans, posible)) ans = posible;
            }
        }
        cout << setprecision(18) << (double)ans.st / ans.nd << endl;
        return;
    }

    
    //priority_queue<pair<pll, tuple<int, int, bool> > , vector<pair<pll, tuple<int, int, bool> > >, function<bool(pair<pll, tuple<int, int, bool> > , pair<pll, tuple<int, int, bool> > )>> Q(Compare);
    auto comp = []( pair<pll, tuple<int, int, bool> > a, pair<pll, tuple<int, int, bool> > b ) { return a.st.st * b.st.nd > a.st.nd * b.st.st; };
    priority_queue< pair<pll, tuple<int, int, bool> > , vector<pair<pll, tuple<int, int, bool> >>, decltype( comp ) >
    Q( comp );
    // return (s1.st.st * s2.st.nd > s1.st.nd * s2.st.st);
    // numerujemy od zero
    pll opt = mp(1e9, 1);
    int ofset = 0;
    int id = -1;
    for(int i=1;i<=3;i++){
        for(int j=0;j<pos[i].size();j++){
            int p = pos[i][j] - 1;
            pll possible = mp(p, v[0] - v[i]);
            if(cmp(possible, opt)){
                opt = possible;
                id = j + ofset;
            }
        }
        ofset += pos[i].size();
    }
    pll dist = opt;
    pll ans = mp(1e9, 1); // TODO: zmienic !!
    Q.push(mp(dist, make_tuple(1, id, false)));
    int mx = 0;
    int iter = 0;
    int iter2 = 0;
    while(Q.size()){
        iter += 1;
        mx = max(mx, (int)Q.size());
        auto cur = Q.top();
        Q.pop();
        if(done[cur.nd]) continue;
        done[cur.nd] = true;
        iter2 += 1;
        pll czas = cur.st;
        int pas = get<0>(cur.nd);
        int carID = get<1>(cur.nd);
        bool przed = get<2>(cur.nd);
        przed = !przed;
        //cout << "COJEST" << pas << " " << carID << " " << przed << " " << czas.st << " " << czas.nd << endl;
        //if(dbg) cout << "CO" << endl;
        //if(dbg) cout << "XD" << endl;
       // bool dbg = false;
        
        //cout << czas.st << " " << czas.nd << endl;
        int which = whichPas(carID);
        ll startPos = pos[which][ktoryNaPasie(carID, which)];
        pll gone = mul(mp(v[which], 1), czas);
        gone = add(gone, mp(startPos, 1));
        if(przed) gone = add(gone, mp(-1, 1));
        else gone = add(gone, mp(1, 1));
        // gdzies se jestesm
        bool mogeKonczyc = false;

        pll koniec = gdzieOstatni(pas, czas);
        mogeKonczyc = cmp(koniec, gone);

        if(mogeKonczyc){
            pll opcja = mp(0, 1); // TODO zmienic
            for(int i=1;i<=3;i++){
                pll ostatni = mul(czas, mp(v[i], 1));
                ll jegoStart = pos[i][pos[i].size() - 1];
                ostatni = add(ostatni, mp(jegoStart, 1));
                ostatni = add(ostatni, mp(1, 1)); // musmy go calego wyprzedzic XD
                //cout << "WTF" << czas.st << " " << pas << " " << przed << " " << gone.st << " " << gone.nd << " " << ostatni.st << " " << ostatni.nd << endl;
                //cout << "PRAWIE" << ostatni.st << " " << ostatni.nd << endl;
                if(!cmp(ostatni, gone)){
                    pll dif = add(ostatni, mp(-gone.st, gone.nd));
                    ll predkoscDif = v[0] - v[i];
                    pll koszt = mp(dif.st, dif.nd * predkoscDif);
                    pll mozliwe = add(koszt, czas);
                    if(cmp(opcja, mozliwe)) opcja = mozliwe;
                }
            }
            //cout << "ALT" << opcja.st << " " << opcja.nd << endl;
            if(cmp(opcja, ans)){
                 //cout << "ODP" << czas.st << " " << czas.nd << " " << pas << " " << carID << " " << przed << " " << gone.st << " " << gone.nd << endl;
                 //cout << koniec.st << " " << koniec.nd << endl;
                 //cout << gone.st << " " << gone.nd << endl;
                 ans = opcja;
            }
            continue;
        }
        
        
        if(1){
            
            // mozemy tylko zmienic pas
            for(int i=1;i<=3;i++){
                if(abs(i - pas) == 1){
                    //if(dbg) cout << "WA" << i << endl;
                    
                    // rozwazamy zmiane pasa tutaj
                    // ile musimy zaczekac, moze od razu?
                    int which = whichPas(carID);
                    ll startPos = pos[which][ktoryNaPasie(carID, which)];
                    pll gone = mul(mp(v[which], 1), czas);
                    gone = add(gone, mp(startPos, 1));
                    if(przed) gone = add(gone, mp(-1, 1));
                    else gone = add(gone, mp(1, 1));
                    
                    // gone <- tutaj jest nasz LEWY koniec
                    // idziemy do i ?
                    // [gone, gone + 1]
                    if(pos[i].size() == 0){ // to sie nie powinno dziac jak sie DOIFUJE na poczatku CO TRZEBA
                        // mozemy isc na palke :)
                        auto go = mp(czas, make_tuple(i, carID, !przed));
                        //if(czas.st == 61) cout << "HAHAHAHAHA " << endl;
                        
                        //if(tutaj) cout << "AAAAA" << endl;
                        Q.push(go);
                        continue;
                    }
                        
                    int lo = 0;
                    int hi = pos[i].size() - 1;
                   
                    while(lo + 1 < hi){
                        int mid = (lo + hi) / 2;
                        pll gd = mul(czas, mp(v[i], 1));
                        gd = add(gd, mp(pos[i][mid], 1));
                    

                        //gd = add(gd, mp(pos[i][mid], 1));
                        // [gd, gd + 1]
                        //pll koniecOn = add(gd, mp(1, 1));
                        pll koniecOn = mp(gd.st + gd.nd, gd.nd);
                        // [gone, koniecJa]
                        pll wtf = mp(gone.st + gone.nd, gone.nd);
                        pll przeciecie = intersect(gone, wtf, gd, koniecOn);
                        pll emp = mp(0, 1);
                        if(cmp(emp, przeciecie)){
                            hi = mid;
                        }
                        else{
                            if(cmp(gd, gone)){
                                lo = mid;
                            }
                            else hi = mid;
                        }
                    }
                    int idInter = -1;
                    
                    for(int j=lo;j<=hi;j++){
                        pll gd = mul(czas, mp(v[i], 1));
                        gd = add(gd, mp(pos[i][j], 1));

                        pll koniecOn = add(gd, mp(1, 1));
                        pll wtf = add(gone, mp(1, 1));
                        pll przeciecie = intersect(gone, wtf, gd, koniecOn);
                        //if(dbg){
                        //    cout << "H" << " " << j << endl;
                        //    cout << koniecOn.st << " " << koniecOn.nd << endl;
                        //    cout << gone.st << " " << gone.nd << endl;
                        //}
                        pll emp = mp(0, 1);
                        if(cmp(emp, przeciecie)){
                            idInter = j;
                        }
                    }
                    //if(DEBUG){
                    //    cout << "KUTWA" << i << " " << idInter << endl;
                   // }
                    //if(DEBUG) cout << "INTER" << idInter << endl;
                    if(idInter == -1){
                        // mozemy isc na palke :)
                        auto go = mp(czas, make_tuple(i, carID, !przed));
                        
                        //if(czas.st == 61) cout << "HAHAHAHAHA " << endl;
                        //if(tutaj) cout << "BBBB" << endl;
                        //if(tutaj) cout << "WTFBBB" << czas.st << " " << czas.nd << " " << pas << " " << carID << " " << przed << endl;
                        Q.push(go);
                        // jak jestesmy na szybszym to musimy probowac wyprzedzic !
                        if(i > pas){
                            for(int j=hi;j>=lo;j--){
                                pll gd = mul(czas, mp(v[i], 1));
                                gd = add(gd, mp(pos[i][j], 1));
                                if(!cmp(gd, gone)){
                                    idInter = j;
                                }
                            }
                            if(idInter == -1) continue;
                            
                            pll gd = mul(czas, mp(v[i], 1));
                            gd = add(gd, mp(pos[i][idInter], 1));
                            pll dif = add(gd, mp(-gone.st, gone.nd));
                            dif = add(dif, mp(1, 1));
                            int bonus = za[i][idInter] - 1;
                            dif = add(dif, mp(bonus, 1));
                            int speed = v[pas] - v[i];
                            pll cost = mp(dif.st, dif.nd * speed);
                            pll opt = add(cost, czas);
                            //if(DEBUG){
                            //    cout << "MAM" << opt.st << " " << opt.nd << endl;
                            //}
                            auto go = mp(opt, make_tuple(i, mappedID(i, idInter + bonus), 1));
                            bool tutaj = (i == 2 && carID == 4 && !przed == true);
                            //if(opt.st == 61) cout << "HAHAHAHAHA " << endl;
                            //if(tutaj) cout << "A" << endl;
                            Q.push(go);
                        }
                        continue;
                    }
                    //if(dbg) cout << "TUTUTUTU " << idInter << endl;
                    if(pas > i){
                        //if(DEBUG) cout << "AMEIS" << idInter << endl;
                        // jestesmy wolniejsi
                        // musimy czekac, a ile? :)
                        int blok = ile[i][idInter] - 1;
                        pll gd = mul(czas, mp(v[i], 1));
                        gd = add(gd, mp(pos[i][idInter], 1));

                        pll mojKoniec = add(gone, mp(1, 1));
                        pll len = add(mojKoniec, mp(-gd.st, gd.nd));
                        len = add(len, mul(mp(1, 1), mp(blok, 1)));
                        ll predkosc = v[i] - v[pas];
                        pll czekam = mp(len.st, len.nd * predkosc);
                        //if(DEBUG) cout << "CZEK" << czekam.st << " " << czekam.nd << endl;
                        pll starcik = add(czas, czekam);
                        
                        auto go = mp(starcik, make_tuple(i, carID, 0));
                        //if(starcik.st == 61) cout << "HAHAHAHAHA " << endl;
                        //if(dbg) cout << "AAAAAAAAAAAAAAA" << i << " " << carID << " " << starcik.st << " " << starcik.nd << endl;
                        Q.push(go);
                        continue;
                    }
                    else if(pas < i){
                        
                        //if(dbg) cout << "YES" << endl;
                        // jestesmy szybsi
                        // musimy czekac, a ile? :)
                        
                        int blok = za[i][idInter] - 1;
                        
                        pll gd = mul(czas, mp(v[i], 1));
                        gd = add(gd, mp(pos[i][idInter], 1));

                        pll jegoKoniec = add(gd, mp(1, 1));
                        
                        pll len = add(jegoKoniec, mp(-gone.st, gone.nd));
                        len = add(len, mul(mp(1, 1), mp(blok, 1)));
                        ll predkosc = v[pas] - v[i];

                        //if(DEBUG) cout << "FINAL " << czas.st << " " << czas.nd << " " << len.st << " " << len.nd << " " << predkosc << endl;

                        pll czekam = mp(len.st, len.nd * predkosc);
                        pll starcik = add(czas, czekam);
                        //if(DEBUG){
                        //    cout << "YEY" << starcik.st << " " << starcik.nd << " " << endl;
                        //    cout << blok << endl;
                        //}
                        //if(i == 3 && carID == 0 && !przed ==false){
                        //    cout << "JA ZLY" << endl;
                        //    cout << pas << " " << carID << " " << przed << endl;
//
                        //    cout << "KONIEC" << endl;
                        //}
                        //if(DEBUG) cout << "OOO" << starcik.st << " " << starcik.nd << endl;
                        auto go = mp(starcik, make_tuple(i, mappedID(i, idInter + blok), 1));
                        //if(starcik.st == 61) cout << "HAHAHAHAHA " << endl;
                        
                        //if(dbg) cout << "WA" << go.st.st << " " << go.st.nd << endl;
                        //if(i == 2 && mappedID(i, idInter + blok) == 4) cout << "TUTUTUTU " << endl;
                        Q.push(go);
                        continue;
                    }
                }
            }
        }
        // chcemy jechac do przodu do pierwszego miejsca gdzie sie cos dzieje (i. e.) zrownujemy sie z kims
        if(1){
            //if(DEBUG) cout << "SIEM" << endl;
            bool problem = (czas.st == 0 && czas.nd == 1);
            //if(dbg) cout << "SIEMA" << endl;
            // jazda do przodu na pale
            // binserczujemy pierwszego co jest za nami OSTRO i do niego probujemy dospeedowac
            int which = whichPas(carID);
            //if(dbg) cout << "CO" << przed << endl;
            ll startPos = pos[which][ktoryNaPasie(carID, which)];
            pll gone = mul(mp(v[which], 1), czas);
            gone = add(gone, mp(startPos, 1));
            if(!przed) gone = add(gone, mp(1, 1));
            else gone = add(gone, mp(-1, 1));

            //if(dbg) cout << "POS" << gone.st << " " << gone.nd << endl;
            //if(dbg) cout << "HAHA" << gone.st << " " << gone.nd << endl;
            // my [gone, gone + 1]
            int lo = 0;
            int hi = pos[pas].size() - 1; // MA BYC NIEPUSTY I JEST KTOS ZA NAMI JESZCZE
            //if(DEBUG){
            //    //cout << "CHO" << endl;
            //    cout << lo << " " << hi << endl;
            //    cout << czas.st << " " << czas.nd << endl;
            //}
            // najmniejsza pozycja taka ze ziomek jest za nami
            while(lo + 1 < hi){
                int mid = (lo + hi) / 2;
                ll start = pos[pas][mid];
                pll goneJego = mul(mp(v[pas], 1), czas);
                pll mojKoniec = mp(gone.st + gone.nd, gone.nd);
                goneJego = add(goneJego, mp(start, 1));
                
                // to jest jego poczatek
                if(!cmp(goneJego, mojKoniec)){
                    hi = mid;
                }
                else lo = mid;
            }
            int odp = hi;
            //if(dbg) cout << "WTF" << lo << " " << hi << endl;
            //if(dbg) cout << "WTF2" << gone.st << " " << gone.nd << endl;
            for(int mid=lo;mid<=hi;mid++){
                ll start = pos[pas][mid];
                pll goneJego = mul(mp(v[pas], 1), czas);
                goneJego = add(goneJego, mp(start, 1));
                // to jest jego poczatek
                //if(dbg) cout << "DBG" << goneJego.st << " " << goneJego.nd << endl;
                pll mojKoniec = add(gone, mp(1, 1));
                //if(dbg) cout << "A" << goneJego.st << " " << goneJego.nd << endl;
                //if(dbg) cout << "B" << mojKoniec.st << " " << mojKoniec.nd << endl;
                //if(dbg) cout << "HAHA" << mojKoniec.st << " " << mojKoniec.nd << endl;
                if(!cmp(goneJego, mojKoniec)){
                    odp = min(odp, mid);
                }
            }
            
            assert(odp >= 0);
            pll mojPoczatek = gone;
            ll start = pos[pas][odp];
            
            pll jegoPoczatek = mul(mp(v[pas], 1), czas);
            jegoPoczatek = add(jegoPoczatek, mp(start, 1));

            pll dif = add(jegoPoczatek, mp(-mojPoczatek.st, mojPoczatek.nd));
            dif = add(dif, mp(-1, 1));
            pll czekam = mp(dif.st, dif.nd * (v[0] - v[pas]));
            pll optCzas = add(czas, czekam);
            //if(DEBUG) cout << "KUR" << dif.st << " " << dif.nd << endl;
           //if(dbg) cout << "XD" << optCzas.st << " " << optCzas.nd << endl;
           //if(dbg) cout << "XDD" << mappedID(pas, odp) << pas << endl;
            auto go = mp(optCzas, make_tuple(pas, mappedID(pas, odp), 0));
            //if(dbg) cout << "WA" << go.st.st << " " << go.st.nd << " " << pas << " " << mappedID(pas, odp) << endl;
            //if(dbg) cout << "KTO" << pas << " " << carID << " " << przed << endl;
            
            Q.push(go);
            
            // moze chcemy zjechac na inny pas, po tym jak wyprzedzimy pierwszego ZIOMKA (moze grupe?? ale chyba nie trzeba ifowac tego)

            // najpierw musimy kogos scignac z tego pasa obok
            // szukamy PIERWSZEGO ziomka co sie przecina / jest przed nami i wtedy liczymy czy mozemy go scignac
            // jak tak to wrzucamy i to jest koniec zadania
            // CHYBA XD
            
            for(int i=1;i<=3;i++){
                if(abs(pas - i) != 1) continue;
                // zakladamy ze pasy sa NIEPUSTE !!
                
                int lo = 0;
                int hi = pos[i].size() - 1;
                ll startOstatni = pos[i][hi];
                pll ostatniPojechal = mul(mp(v[i], 1), czas);
                pll gdd = add(mp(startOstatni, 1), ostatniPojechal);
                pll jegoKoniec = add(gdd, mp(1, 1));
                if(!cmp(gone, jegoKoniec)){
                    // jestesmy za nim, nothing to d
                    continue;
                }
                
                while(lo + 1 < hi){
                    int mid = (lo + hi) / 2;
                    ll jegoStart = pos[i][mid];
                    pll onPojechal = mul(mp(v[i], 1), czas);
                    pll jegoPoczatek = add(mp(jegoStart, 1), onPojechal);
                    pll jegoKoniec = mp(jegoPoczatek.st + jegoPoczatek.nd, jegoPoczatek.nd);
                    
                    if(!cmp(gone, jegoKoniec)){
                        // on jest przed nami
                        lo = mid;
                    }
                    else hi = mid;
                }
                
                int szukaneId = hi;
                for(int mid=lo;mid<=hi;mid++){
                    ll jegoStart = pos[i][mid];
                    pll onPojechal = mul(mp(v[i], 1), czas);
                    pll jegoPoczatek = add(mp(jegoStart, 1), onPojechal);
                    pll jegoKoniec = add(jegoPoczatek, mp(1, 1));
                   
                    if(!cmp(gone, jegoKoniec)){
                        // on jest przed nami
                        ;
                    }
                    else szukaneId = min(szukaneId, mid);
                }
                assert(szukaneId >= 0);
                //if(dbg) cout << "TUTAJ:!" << szukaneId << endl;
                // szukaneId, to do niego chcemy podjechac i go wyprzedzic, ja pierdole
                int bonus = za[i][szukaneId] - 1;
                ll jegoStart = pos[i][szukaneId];
                pll onPojechal = mul(mp(v[i], 1), czas);
                pll jegoPoczatek = add(mp(jegoStart, 1), onPojechal);
                jegoPoczatek = add(jegoPoczatek, mp(bonus, 1));
                pll dif = add(jegoPoczatek, mp(-gone.st, gone.nd));
                dif = add(dif, mp(1, 1));
                
                ll szybszy = v[0] - v[i];
                //if(dbg) cout << "HEHEHE" << i << " " << szybszy << endl;
                pll ileMiZajmie = mp(dif.st, dif.nd * szybszy);
                //if(dbg) cout << "KAPPA" << czekam.st << " " << czekam.nd << endl;
                if(cmp(czekam, ileMiZajmie)){
                    ;
                }
                else{
                   
                    // moge
                    //if(DEBUG) cout << "OOOOOOO" << endl;
                    auto xd = add(czas, ileMiZajmie);
                    //cout << "JA" << pas << " " << carID << " " << przed << endl;
                    //cout << "SIEMA" << i << " " << mappedID(i, szukaneId + bonus) << endl;
                    //cout << czekam.st << " " << czekam.nd << endl;
                    auto go = mp(add(czas, ileMiZajmie), make_tuple(i, mappedID(i, szukaneId + bonus), 1));
                    /*if(i == 2 && mappedID(i, szukaneId + bonus) == 4){
                        cout << "ZLE" << endl;
                        cout << czas.st << " " << czas.nd << endl;
                        cout << pas << endl;
                        cout << carID << endl;
                        cout << czekam.st << " " << czekam.nd << endl;
                        cout << "PROBLEM" << odp << endl;
                    }*/
                    Q.push(go);
                }
            }
        }
    }
    
    cout << setprecision(18) << (double)ans.st / ans.nd << endl;
    
}

int main(){
    ios_base::sync_with_stdio(0); cin.tie(0);

    int tt = 1;
    // cin >> tt;
    while(tt--) solve();

    return 0;
}