#include <bits/stdc++.h>
using namespace std;

ifstream in ( "eval.in"  );
ofstream out( "eval.out" );

const int NMAX = 27;
const int DMAX = 280;
const int LMAX = 1005;
const int SMAX = 100005;
const int BASE = 10000;
const int NBASE = 4;
const int CONST1 = 46342;
const int CONST2 = 2147481199;
const int CONST3 = 2147483647;

char axs[LMAX], str[SMAX];
int axn[DMAX], ans[DMAX], aux[DMAX];
int num[NMAX][DMAX], sign[NMAX], val[NMAX];

vector<int> axp;
bitset<CONST1> oki;

int mod( int a[DMAX], int b ) {
    int i; long long t = 0;
    
    for( i = a[0]; i >= 1; i -- )
        t = ( t * BASE + a[i] ) % b;
    
    return (int) t;
}

void add( int a[DMAX], int b[DMAX] ) {
    int i; long long t = 0;
    
    for( i = 1; i <= a[0] || i <= b[0]; i ++, t /= BASE )
        a[i] = ( t += a[i] + b[i] ) % BASE;
    a[0] = i - 1;
    
    while( a[0] > 0 && a[a[0]] == 0 )
        a[0] --;
    
    return;
}

void mul( int a[DMAX], int b ) {
    int i; long long t = 0;
    
    for( i = 1; i <= a[0] || t; i ++, t /= BASE )
        a[i] = ( t += 1LL * a[i] * b ) % BASE;
    a[0] = i - 1;
    
    while( a[0] > 0 && a[a[0]] == 0 )
        a[0] --;
    
    return;
}

void sub( int a[DMAX], int b[DMAX] ) {
    int i; long long t = 0;
    
    for( i = 1; i <= a[0]; i ++ ) {
        a[i] -= b[i] + t;
        a[i] += ( t = a[i] < 0 ) * BASE;
    }
    
    while( a[0] > 0 && a[a[0]] == 0 )
        a[0] --;
    
    return;
}

int cmp( int a[DMAX], int b[DMAX] ) {
    if( a[0] != b[0] )
        return ( a[0] < b[0] ) ? -1 : 1;
    
    for( int i = a[0]; i >= 1; i -- ) {
        if( a[i] != b[i] )
            return ( a[i] < b[i] ) ? -1 : 1;
    }
    
    return 0;
}

int expr( int &p, int r );
int term( int &p, int r );
int fact( int &p, int r );
int numb( int &p, int r );

int expr( int &p, int r ) {
    int nr = term( p, r );
    
    while( str[p] == '+' || str[p] == '-' ) {
        if( str[p] == '+' )
            nr = ( 0LL + nr + term( ++ p, r ) + r ) % r;
        else
            nr = ( 0LL + nr - term( ++ p, r ) + r ) % r;
    }
    
    return nr;
}

int term( int &p, int r ) {
    int nr = fact( p, r );
    
    while( str[p] == '*' )
        nr = ( 1LL * nr * fact( ++ p, r ) ) % r;
    
    return nr;
}

int fact( int &p, int r ) {
    int nr = 0;
    
    if( str[p] != '+' && str[p] != '-' ) {
        if( str[p] == '(' ) {
            nr = expr( ++ p, r );
            p ++;
        }
        else
            nr = numb( p, r );
    }
    else {
        if( str[p] == '+' )
            nr = expr( ++ p, r );
        else
            nr = ( 0LL + r - expr( ++ p, r ) + r ) % r;
    }
    
    return nr;
}

int numb( int &p, int r ) {
    int nr = 0;
    
    if( str[p] == '[' ) {
        nr = ( 1LL * val[str[p + 1] - 'a' + 1] * val[str[p + 1] - 'a' + 1] ) % r;
        p += 3;
    }
    else {
        if( sign[str[p] - 'a' + 1] == 1 )
            nr = val[str[p] - 'a' + 1];
        else
            nr = r - val[str[p] - 'a' + 1];
        p ++;
    }
    
    return nr;
}

int runexp( int n, int r ) {
    for( int i = 1; i <= n; i ++ )
        val[i] = mod( num[i], r );
    
    int p = 1;
    return expr( p, r );
}

int lgput( int x, int y, int r ) {
    if( y == 0 )
        return 1;
    
    int z = lgput( x, y / 2, r );
    z = ( 1LL * z * z ) % r;
    
    if( y % 2 == 1 )
        z = ( 1LL * z * x ) % r;
    
    return z;
}

void solve( int n ) {
    memset( axn, 0, sizeof( axn ) );
    memset( ans, 0, sizeof( ans ) );
    
    axn[0] = axn[1] = ans[0] = ans[1] = 1;
    for( int i = CONST2, nr = 0; i <= CONST3; i += 2 ) {
        bool ok = true;
        
        for( int x : axp ) {
            if( i % x == 0 ) {
                ok = false;
                break;
            }
        }
        
        if( ok == true ) {
            int prm = i, rst = runexp( n, i );
            
            nr ++;
            if( nr == 1 ) {
                mul( axn, prm );
                mul( ans, rst );
            }
            else {
                int aux1 = ( 0LL + rst - mod( ans, prm ) + prm ) % prm;
                int aux2 = lgput( mod( axn, prm ), prm - 2, prm );
                
                memcpy( aux, axn, ( axn[0] + 1 ) << 2 ); mul( axn, prm );
                mul( aux, ( 1LL * aux1 * aux2 ) % prm ); add( ans, aux );
            }
        }
        
        if( i == CONST3 )
            break;
    }
    
    return;
}

int main( void ) {
    
    int n;
    in >> n;
    
    for( int i = 1; i <= n; i ++ ) {
        in >> ( axs + 1 );
        int l = (int) strlen( axs + 1 );
        
        if( axs[1] == '-' )
            sign[i] = -1;
        else
            sign[i] = +1;
        
        for( int j = l; j >= 1 + ( sign[i] == -1 ); j -= NBASE ) {
            num[i][0] ++;
            
            for( int k = max( j - NBASE + 1, 1 + ( sign[i] == -1 ) ); k <= j; k ++ )
                num[i][num[i][0]] = num[i][num[i][0]] * 10 + ( axs[k] - '0' );
        }
    }
    
    in >> ( str + 1 );
    for( int i = 3; i < CONST1; i += 2 ) {
        if( oki[i] == false ) {
            axp.push_back( i );
            
            for( int j = i + i + i; j < CONST1; j += i + i )
                oki[j] = true;
        }
    }
    
    solve( n );
    
    memset( aux, 0, sizeof( aux ) );
    aux[0] = DMAX - 29; aux[DMAX - 29] = 1;
    
    if( cmp( ans, aux ) > 0 ) {
        out << '-';
        
        for( int i = 1; i <= n; i ++ )
            sign[i] *= -1;
        solve( n );
    }
        
    out << ans[ans[0]];
    for( int i = ans[0] - 1; i >= 1; i -- ) {
        for( int aux = BASE / 10; aux > ans[i] && aux > 1; aux /= 10 )
            out << 0;
        out << ans[i];
    }
    
    return 0;
}