import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.HashMap;

/**
 * @author cteam18
 */
public class arbitrage {

    static int N;
    static Pomer graf[][] = null;
    static HashMap ci = new HashMap<String, Integer>();
    static HashMap ic = new HashMap<Integer, String>();

    public static Pomer multi( Pomer a, Pomer b ) {
          //System.out.println( "a: " + a + "b: " + b );
        Pomer res = new Pomer("1:1"); // hack
        res.c = a.c.multiply( b.c );
        res.m = a.m.multiply( b.m );
        
        BigInteger gcd = res.c.gcd(res.m);
        if ( !gcd.equals( new BigInteger("0") ) ) {
            res.c.divide(gcd);
            res.m.divide(gcd);
        }
        return res;
    }
        

    private static class Pomer implements Comparable<Pomer> {
        BigInteger c;
        BigInteger m;
        Pomer( String s ) {
            String[] cm = s.split(":");
            m = new BigInteger(cm[0]);
            c = new BigInteger(cm[1]);
        }

        public int compareTo(Pomer n) {
            BigInteger ntc = new BigInteger( this.c.toString() ).multiply( n.m );
            BigInteger nnc = new BigInteger( n.c.toString() ).multiply( this.m );
            return ntc.compareTo(nnc);
        }

        public String toString() {
            return c.toString() + "/" + m.toString();
        }
        
        
    }
    
    static void solve() {
        for ( int k = 0; k < N; ++k ) {
            for ( int i = 0; i < N; ++i ) 
                for ( int j = 0; j < N; ++j ) {
                    if ( graf[i][j] != null && graf[i][k] != null && graf[k][j] != null ) {
                        Pomer p = multi(graf[i][k], graf[k][j]);
                        if ( graf[i][j].compareTo( p ) < 0 ) {
                            graf[i][j] = p;
                        }
                    }
                }
            //printGraf();
        }
        boolean ar = false;
        for ( int i = 0; i < N; ++i ) {
            if ( graf[i][i].c.compareTo( graf[i][i].m) > 0 ) {
                ar = true;
                break;
            }
        }
        if (ar) {
            System.out.println("Arbitrage");
        } else {
            System.out.println("Ok");
        }
    }

    static void printGraf() {
        for ( int i = 0; i < N; ++i ) {
            for ( int j = 0; j < N; ++j ) {
                System.out.println( graf[i][j] );
            }
        }
    }

    public static void main(String[] args) {
        try {
            final BufferedReader br = new BufferedReader( new InputStreamReader(System.in) );
            String line = br.readLine();
            int c1;
            int c2;
            String[] cs;
            String[] ccp;
            while ( !"0".equals(line) ) {
                ci = new HashMap<String, Integer>();
                ic = new HashMap<Integer, String>();
                c1 = Integer.parseInt( line );
                N = c1;
                graf = new Pomer[c1][c1];
                for ( int i = 0; i < N; ++i ) {
                    for ( int j = 0; j < N; ++j ) {
                        //graf[i][j] = new Pomer("0:0");
                    }
                    
                }
                cs = br.readLine().split(" ");
                for ( int i = 0; i < c1; ++i ) {
                    ci.put( cs[i], i );
                    ic.put( i, cs[i] );
                    graf[i][i] = new Pomer("1:1");
                }
                c2 = Integer.parseInt( br.readLine() );
                for ( int i = 0; i < c2; ++i ) {
                    ccp = br.readLine().split(" ");
                    graf[ (Integer)ci.get(ccp[0]) ][ (Integer)ci.get( ccp[1] ) ] = new Pomer( ccp[2] );
                }

                //printGraf();
                solve();
                //System.out.println("--- --- --- ---");

                line = br.readLine();
            }
        } catch ( Throwable t ) {
            t.printStackTrace();
        }
    }
}