Problem:
Score: 200 points

Problem Statement

You are an immigration officer in the Kingdom of AtCoder. The document carried by an immigrant has some number of integers written on it, and you need to check whether they meet certain criteria.

According to the regulation, the immigrant should be allowed entry to the kingdom if and only if the following condition is satisfied:

All even numbers written on the document are divisible by 3 or 5.

If the immigrant should be allowed entry according to the regulation, output APPROVED; otherwise, print DENIED.

Notes

The condition in the statement can be rephrased as "If x is an even number written on the document, x is divisible by 3 or 5".
Here "if" and "or" are logical terms.

Constraints

All values in input are integers.

1 \leq N \leq 100

1 \leq A_i \leq 1000

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \dots A_N

Output

If the immigrant should be allowed entry according to the regulation, print APPROVED; otherwise, print DENIED.

Sample Input 1

5
6 7 9 10 31

Sample Output 1

APPROVED

The even numbers written on the document are 6 and 10.

All of them are divisible by 3 or 5, so the immigrant should be allowed entry.

Sample Input 2

3
28 27 24

Sample Output 2

DENIED

28 violates the condition, so the immigrant should not be allowed entry.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Linq;
using System.Text.RegularExpressions;
using System.Collections.Generic;
using static program.Input;
using static program.MyMath;
using static System.Console;
using static program.Const;

namespace program
{
  class Program
  {
    static void Main()
    {
      var n = ScanInt();
      var a = ScanIntArray().Select(_=>_%2==1 || _%6==0 || _%10==0).ToArray().All(_=>_);
      
      WriteLine(a ? "APPROVED" : "DENIED");
    }
  }

  static class Const
  {
    public static string alp = "abcdefghijklmnopqrstuvwxyz";
    public static string Alp = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    public static long MOD = 1000000007;
    public static int INF = int.MaxValue;
    public static long INFL = long.MaxValue;
  }
  static class Input
  {
    static public int ScanInt() { return int.Parse(Console.ReadLine()); }
    static public uint ScanUint() { return uint.Parse(Console.ReadLine()); }
    static public double ScanDouble() { return double.Parse(Console.ReadLine()); }
    static public long ScanLong() { return long.Parse(Console.ReadLine()); }
    static public ulong ScanUlong() { return ulong.Parse(Console.ReadLine()); }
    static public int[] ScanIntArray() { return Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray(); }
    static public uint[] ScanUintArray() { return Console.ReadLine().Split().Select(x => uint.Parse(x)).ToArray(); }
    static public double[] ScanDoubleArray() { return Console.ReadLine().Split().Select(x => double.Parse(x)).ToArray(); }
    static public long[] ScanLongArray() { return Console.ReadLine().Split().Select(x => long.Parse(x)).ToArray(); }
    static public ulong[] ScanUlongArray() { return Console.ReadLine().Split().Select(x => ulong.Parse(x)).ToArray(); }

    static public string ScanStr() { return Console.ReadLine(); }
    static public string[] ScanStrArray() { return ScanStr().Split(); }
    static public string RegaxReplace(this string arg1, string pattern, string replacement) { return Regex.Replace(arg1, pattern, replacement); }
    static public string Join<T>(this IEnumerable<T> source, string separator) { return string.Join(separator, source); }
  }

  static class MyMath
  {
    static public int Floor2(this int a)
    {
      int N = 1;
      while (N < a) N *= 2;
      return N / 2;
    }
    static public long Floor2(this long a)
    {
      long N = 1;
      while (N < a) N *= 2;
      return N / 2;
    }
    static public int Ceiling2(this int a)
    {
      int N = 1;
      while (N < a) N *= 2;
      return N;
    }
    static public long Ceiling2(this long a)
    {
      long N = 1;
      while (N < a) N *= 2;
      return N;
    }
    static public long[] CumSum(this long[] a)
    {
      var res = new long[a.Length];
      long s = 0;
      for (int i = 0; i < a.Length; i++) res[i] = (s += a[i]);
      return res;
    }
    static public IEnumerable<int> PrimeFactors(this int n)
    {
      int tmp = n;
      for (int i = 2; i * i <= n; i++)
      {
        while (tmp % i == 0)
        {
          tmp /= i;
          yield return i;
        }
      }
      if (tmp != 1) yield return tmp;
    }
    static public IEnumerable<long> PrimeFactors(this long n)
    {
      var tmp = n;
      for (long i = 2; i * i <= n; i++)
      {
        while (tmp % i == 0)
        {
          tmp /= i;
          yield return i;
        }
      }
      if (tmp != 1) yield return tmp;
    }
    static public int Digit(this int n, int d) { if (d < 0) return 0; return (n % (int)Math.Pow(10, d + 1)) / (int)Math.Pow(10, d); }
    static public int Length(this int n) { if (n < 0) return 0; return (int)Math.Log10(n) + 1; }
    static public int Top(this int n) { return n.Digit(n.Length() - 1); }
    public static bool isPrime(this int p)
    {
      if (p <= 1) return false;
      for (int i = 2; i * i <= p; i++)
        if (p % i == 0) return false;
      return true;
    }
    public static bool isPrime(this long p)
    {
      if (p <= 1) return false;
      for (long i = 2; i * i <= p; i++)
        if (p % i == 0) return false;
      return true;
    }
    public static int GCD(int a, int b)
    {
      Func<int, int, int> gcd = null;
      gcd = (x, y) => y == 0 ? x : gcd(y, x % y);
      return a > b ? gcd(a, b) : gcd(b, a);
    }
    public static long GCD(long a, long b)
    {
      Func<long, long, long> gcd = null;
      gcd = (x, y) => y == 0 ? x : gcd(y, x % y);
      return a > b ? gcd(a, b) : gcd(b, a);
    }
    public static ulong extGCD(ulong a, ulong b, ref ulong x, ref ulong y)
    {
      if (b == 0)
      {
        x = 1;
        y = 0;
        return a;
      }
      var d = extGCD(b, a % b, ref y, ref x);
      y -= a / b * x;
      return d;
    }
    public static int LCM(int a, int b) { return a * b / GCD(a, b); }
    public static long LCM(long a, long b) { return a * b / GCD(a, b); }
    public static long Inv(this long a, long m = 1000000007)
    {
      long b = m, u = 1, v = 0;
      while (b != 0)
      {
        long t = a / b;
        a -= t * b;
        swap(ref a, ref b);
        u -= t * v;
        swap(ref u, ref v);
      }
      u %= m;
      if (u < 0) u += m;
      return u;
    }
    private static void swap(ref long a, ref long b)
    {
      var t = a;
      a = b;
      b = t;
    }
  }


}