#pragma gcc optimize("-Ofast,unroll-loops")
#pragma gcc target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
vector<int> t(6);
vector<int> optimal(6);
int v[6][4] = {{0, 3, 5, 2}, 
                       {0, 2, 5, 3},
                       {0, 1, 5, 4},
                       {0, 4, 5, 1},
                       {1, 2, 4, 3},
                       {1, 3, 4, 2}};
string b = "EWNS";
struct Dice {
    int s[6];
    int &top() {return s[0];}
    int &south() {return s[1];}
    int &east() {return s[2];}
    int &west() {return s[3];}
    int &north() {return s[4];}
    int &bottom() {return s[5];}
    void roll(char c) {
        for(int k = 0; k < 6; k++) {
            if(b[k] != c) continue;
            int t = s[v[k][0]];
            s[v[k][0]] = s[v[k][1]];
            s[v[k][1]] = s[v[k][2]];
            s[v[k][2]] = s[v[k][3]];
            s[v[k][3]] = t;
            return;
        }
    }
    void print() {
        for(int i = 0; i < 6; i++) cerr << s[i] << " ";
        cerr << endl;
    }
    ll hash() {
        ll res = 0;
        for(int i = 0; i < 6; i++) res = res * 256 + s[i];
        return res;
    }

    bool operator==(const Dice &d) const{
        for(int i = 0; i < 6; i++) if(s[i] != d.s[i]) return 0;
        return 1;
    }
    bool operator!=(const Dice &d) const{
        return !(*this == d);
    }
};
vector<Dice> makeDices(Dice d) {
    vector<Dice> res;
    for(int i = 0; i < 6; i++) {
        Dice t(d);
        if(i == 1) t.roll('N');
        if(i == 2) t.roll('S');
        if(i == 3) t.roll('S'), t.roll('S');
        if(i == 4) t.roll('L');
        if(i == 5) t.roll('R');
        for(int k = 0; k < 4; k++) {
            res.push_back(t);
            t.roll('E');
        }
    }
    return res;
}

bool end() {
    for(int i = 0; i <= 5; i++) {
        if(t[i] != 0) return false;
    }
    return true;
}

bool valid(Dice d) {
    int sum = 0;
    for(int i = 0; i < 6; i++) {
        if(d.s[i] < 0) return false;
        sum += d.s[i];
    }
    if(2 * (d.s[0] + d.s[5]) > sum) return false;
    if(2 * (d.s[2] + d.s[3]) > 1 + sum) return false;
    if(2 * (d.s[1] + d.s[4]) > 1 + sum) return false;
    return true;
}

Dice newDice;
vector<vector<int> > operations;
string direction = "ENSW";
int main() {
    /*
    Dice test;
    for(int i = 0; i < 6; i++) test.s[i] = i + 1;
    test.print();
    test.roll('S');
    test.print();
    test.roll('S');
    test.print();
    test.roll('W');
    test.print();
    */
    Dice zeroDice;
    for(int i = 0; i < 6; i++) zeroDice.s[i] = 0;
    while(true) {
        operations.clear();
        for(int i = 0; i <= 5; i++) cin >> t[i];
        if(end()) break;
        int p, q;
        cin >> p >> q;
        string ans;
        for(int i = 0; i < 6; i++) {
            for(int j = 1; j <= t[i]; j++) ans.push_back('Z');
        }
        sort(t.begin(), t.end());
        do {
            operations.push_back(t);
        } while(next_permutation(t.begin(), t.end()));
        //cerr << operations.size() << endl;
        mt19937 mt;
        shuffle(begin(operations), end(operations), mt);
        for(int INDEX = 0; INDEX < operations.size(); INDEX++) {
            vector<int> t = operations[INDEX];
            bool equals = true;
            //if(t[0] < t[5]) continue;
            Dice initialdice;
            for(int i = 0; i < 6; i++) {
                initialdice.s[i] = t[i];
            }
            vector<Dice> dices = makeDices(initialdice);
            dices.resize(1);
            for(int i = 0; i < dices.size(); i++) {
                Dice nowDice = dices[i];
                //cerr << "--------" << i << "-------" << endl;
                //owDice.print();
                string S = "";
                bool clear = true;
                while(zeroDice != nowDice) {
                    //cerr << "ANSWER: " << ans << endl;
                    //cerr << "now: " << S << endl;
                    //cerr << equals << endl;
                    if(equals) {
                        if(!S.empty()) {
                            int index = S.size() - 1;
                            if(S[i] < ans[i]) {
                                equals = false;
                            } else if(S[i] > ans[i]) {
                                //cerr << "CUT" << endl;
                                clear = false;
                                break;
                            }
                        }
                    }
                    //nowDice.print();
                    bool nowclear = false;
                    for(int i = 0; i < direction.size(); i++) {
                        newDice = nowDice;
                        newDice.roll(direction[i]);
                        newDice.s[5]--;
                        if(valid(newDice)) {
                            nowclear = true;
                            S.push_back(direction[i]);
                            swap(nowDice, newDice);
                            break;
                        }
                        //cerr << "IMPOSSIBLE: " << endl;
                        //newDice.print();
                    }
                    if(!nowclear) {
                        clear = false;
                        break;
                    }
                }
                if(clear) {
                    if(ans > S) {
                        ans = min(S, ans);
                        //optimal = t;
                    }
                }
            }
        }
        if(ans[0] == 'Z') cout << "impossible" << endl;
        else {
            cout << ans.substr(p-1, q - p + 1) << endl;
            //for(int i = 0; i < 6; i++) cerr << optimal[i] << " ";
            //cerr << endl;
        }
    }
    return 0;
}


Measured memory_bytes: 3304