2
1 18
 9
6 20 27 28 40 53 59 70 85
 8
10 20 30 40 50 60 70 80
 6
13 17 32 47 60 66
 1
1
 8
5 17 20 35 42 53 67 76
 1
90
 6
14 29 43 59 70 74
 76
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
 8
15 20 30 40 50 60 73 83
 14
14 22 27 31 35 44 46 61 62 69 74 79 88 89
 30
6 11 12 15 22 24 30 31 32 33 34 35 40 42 44 45 47 50 53 54 57 58 63 67 75 77 79 81 83 88
 84
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
 6
15 30 45 60 74 89
 9
15 28 39 48 55 60 63 64 74
 1
15
 9
10 20 30 40 50 60 70 80 84
 25
1 2 3 4 5 6 7 8 9 10 11 23 36 50 65 81 82 83 84 85 86 87 88 89 90
 5
15 30 45 60 74
 2
16 50
 12
14 22 27 31 35 44 62 69 74 79 88 89
 10
15 28 39 48 55 60 63 64 74 82
 60
1 2 4 5 6 7 11 14 16 18 20 21 22 23 24 25 26 33 34 35 36 37 38 39 41 42 43 44 46 47 48 49 52 55 56 57 58 59 60 61 63 64 65 67 68 70 71 72 73 74 75 77 78 80 82 83 84 85 86 88
 6
15 30 45 60 75 84
 90
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
 3
1 20 90
 8
1 16 30 31 32 33 34 50
 72
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
 12
1 3 6 10 15 21 28 36 45 55 66 78
 1
16
 5
15 30 45 60 75

16
 90
 90
 81
 16
 90
 15
 58
 90
 90
 90
 90
 90
 90
 89
 30
 90
 80
 89
 15
 59
 90
 90
 90
 90
 16
 49
 54
 90
 15
 90

import java.io.*;
import java.util.*;
import java.nio.charset.Charset;
public class Main{ 
  public static void main(String[] args){ 
    Charset charset=Charset.forName("ascii");
    FastIO sc=new FastIO(System.in,System.out,charset);
    int t=sc.readInt();
    boolean flag=true;
    int time=sc.readInt();
    int count=15;
    if(time>15){
      count=15;
      flag=false;
     }else 
       count=time;
    t--;
    int c=1;
    
    while(c<= t) {
     int n=sc.readInt();
     if(flag){
     	if(n-time>=15){
     		flag=false;
     		count+=15;
     	}else{
     	   count=n;
           time=n; 
     }
     }
     c++;
      }
     System.out.println(count);
     
}

}
class FastIO {
  public final StringBuilder cache = new StringBuilder(1 << 20);
  private final InputStream is;
  private final OutputStream os;
  private final Charset charset;
  private StringBuilder defaultStringBuf = new StringBuilder(1 << 8);
  private byte[] buf = new byte[1 << 13];
  private int bufLen;
  private int bufOffset;
  private int next;
 
  public FastIO(InputStream is, OutputStream os, Charset charset) {
    this.is = is;
    this.os = os;
    this.charset = charset;
  }
 
  public FastIO(InputStream is, OutputStream os) {
    this(is, os, Charset.forName("ascii"));
  }
 
  private int read() {
    while (bufLen == bufOffset) {
      bufOffset = 0;
      try {
        bufLen = is.read(buf);
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
      if (bufLen == -1) {
        return -1;
      }
    }
    return buf[bufOffset++];
  }
 
  public void skipBlank() {
    while (next >= 0 && next <= 32) {
      next = read();
    }
  }
 
  public int readInt() {
    int sign = 1;
 
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+' ? 1 : -1;
      next = read();
    }
 
    int val = 0;
    if (sign == 1) {
      while (next >= '0' && next <= '9') {
        val = val * 10 + next - '0';
        next = read();
      }
    } else {
      while (next >= '0' && next <= '9') {
        val = val * 10 - next + '0';
        next = read();
      }
    }
 
    return val;
  }
 
  public long readLong() {
    int sign = 1;
 
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+' ? 1 : -1;
      next = read();
    }
 
    long val = 0;
    if (sign == 1) {
      while (next >= '0' && next <= '9') {
        val = val * 10 + next - '0';
        next = read();
      }
    } else {
      while (next >= '0' && next <= '9') {
        val = val * 10 - next + '0';
        next = read();
      }
    }
 
    return val;
  }
 
  public double readDouble() {
    boolean sign = true;
    skipBlank();
    if (next == '+' || next == '-') {
      sign = next == '+';
      next = read();
    }
 
    long val = 0;
    while (next >= '0' && next <= '9') {
      val = val * 10 + next - '0';
      next = read();
    }
    if (next != '.') {
      return sign ? val : -val;
    }
    next = read();
    long radix = 1;
    long point = 0;
    while (next >= '0' && next <= '9') {
      point = point * 10 + next - '0';
      radix = radix * 10;
      next = read();
    }
    double result = val + (double) point / radix;
    return sign ? result : -result;
  }
  public String readString(StringBuilder builder) {
    skipBlank();
 
    while (next > 32) {
      builder.append((char) next);
      next = read();
    }
 
    return builder.toString();
  }
 
  public String readString() {
    defaultStringBuf.setLength(0);
    return readString(defaultStringBuf);
  }
  public int readLine(char[] data, int offset) {
    int originalOffset = offset;
    while (next != -1 && next != '\n') {
      data[offset++] = (char) next;
      next = read();
    }
    return offset - originalOffset;
  }
 
  public int readString(char[] data, int offset) {
    skipBlank();
 
    int originalOffset = offset;
    while (next > 32) {
      data[offset++] = (char) next;
      next = read();
    }
 
    return offset - originalOffset;
  }
 
  public int readString(byte[] data, int offset) {
    skipBlank();
 
    int originalOffset = offset;
    while (next > 32) {
      data[offset++] = (byte) next;
      next = read();
    }
 
    return offset - originalOffset;
  }
 
  public char readChar() {
    skipBlank();
    char c = (char) next;
    next = read();
    return c;
  }
 
  public void flush() {
    try {
      os.write(cache.toString().getBytes(charset));
      os.flush();
      cache.setLength(0);
    } catch (IOException e) {
      throw new RuntimeException(e);
    }
  }
 
  public boolean hasMore() {
    skipBlank();
    return next != -1;
  }
}