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.io.IOException;
import java.io.InputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class Main {
    public static void main(String[] args) {

        File file = new File("in.txt");
        InputStream inputStream = null;
//        try {inputStream= new FileInputStream(file);} catch (FileNotFoundException ex){return;};
        inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(1, in, out);
        out.close();
    }
}





class TaskB {


    public void solve(int testNumber, InputReader in, PrintWriter out) {
        Integer minutes = in.nextInt();
        Integer results = 0;
        List<Integer> interesting = new ArrayList<>();
        interesting.add(0);
        for(int i=0;i<minutes;i++){
            interesting.add(in.nextInt());
        }
        interesting.add(90);

        int sum = 0;

        for(int i=1;i<interesting.size();i++){
            int last = interesting.get(i-1);
            int current = interesting.get(i);

            if(current - last > 15){
                results = sum+15 > results ? sum+15 : results;
                break;
            }
            else{
                sum+=current-last;
                if(sum==90){
                    results = 90;
                }
            }
        }

        out.println(results);


    }



}







class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public String nextLine(){
        try {
            return reader.readLine();
        } catch (IOException e){
            throw new RuntimeException(e);
        }
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() { return Long.parseLong(next()); }

}



class Pair<F, S> {
    public final F first;
    public final S second;




    public Pair(F first, S second) {
        this.first = first;
        this.second = second;
    }

    @Override
    public boolean equals(Object o) {
        if (!(o instanceof Pair)) {
            return false;
        }
        Pair<?, ?> p = (Pair<?, ?>) o;
        return Objects.equals(p.first, first) && Objects.equals(p.second, second);
    }

    @Override
    public int hashCode() {
        return (first == null ? 0 : first.hashCode()) ^ (second == null ? 0 : second.hashCode());
    }

    @Override
    public String toString() {
        return "(" + first + ", " + second + ')';
    }
}