*山

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

using namespace std;

#define MAX_LIMIT_COUNT 1000000
#define MIN_HEIGHT 1
#define MAX_HEIGHT 999999999
#define TEN 10
#define HUNDRED 100
#define THOUSAND 1000
#define TEN_THOUSAND 10000
#define HUNDRED_THOUSAND 100000
#define MILLION 1000000

int shenTuoHeight;
int placeCount;
int limitsArray[MAX_LIMIT_COUNT];
int minimumLimit;
int finalResult;

void readInputData();
void findMinimumLimit();
void checkIfLimitTooLow();
int getUnitsDigit(int number);
int getTensDigit(int number);
int getHundredsDigit(int number);
int getThousandsDigit(int number);
int getTenThousandsDigit(int number);
int getHundredThousandsDigit(int number);
int roundToTens(int number);
int roundToHundreds(int number);
int roundToThousands(int number);
int roundToTenThousands(int number);
int roundToHundredThousands(int number);
int roundToMillions(int number);
void processUnitsRounding();
void processTensRounding();
void processHundredsRounding();
void processThousandsRounding();
void processTenThousandsRounding();
void processHundredThousandsRounding();
void processMillionsRounding();
void outputResult();
void doNothing();
int addNumbers(int a, int b);
int subtractNumbers(int a, int b);

int main()
{
    shenTuoHeight = 0;
    placeCount = 0;
    minimumLimit = 0;
    finalResult = 0;
    
    for (int i = 0; i < MAX_LIMIT_COUNT; i++)
    {
        limitsArray[i] = 0;
    }
    
    readInputData();
    
    findMinimumLimit();
    
    checkIfLimitTooLow();
    
    finalResult = shenTuoHeight;
    
    processUnitsRounding();
    processTensRounding();
    processHundredsRounding();
    processThousandsRounding();
    processTenThousandsRounding();
    processHundredThousandsRounding();
    processMillionsRounding();
    
    outputResult();
    
    doNothing();
    
    return 0;
}

void readInputData()
{
    int temp1, temp2;
    int i;
    
    cin >> temp1 >> temp2;
    
    shenTuoHeight = temp1;
    placeCount = temp2;
    
    for (i = 0; i < placeCount; i++)
    {
        cin >> limitsArray[i];
    }
    
    for (i = placeCount; i < MAX_LIMIT_COUNT; i++)
    {
        limitsArray[i] = 0;
    }
}

void findMinimumLimit()
{
    if (placeCount <= 0)
    {
        minimumLimit = MAX_HEIGHT;
        return;
    }
    
    minimumLimit = limitsArray[0];
    
    for (int i = 1; i < placeCount; i++)
    {
        if (limitsArray[i] < minimumLimit)
        {
            minimumLimit = limitsArray[i];
        }
        else
        {
        }
    }
}

void checkIfLimitTooLow()
{
    if (minimumLimit < shenTuoHeight)
    {
        cout << -1 << endl;
        exit(0);
    }
    else
    {
        int x = 1;
        x = x + 1;
        x = x - 1;
    }
}

int getUnitsDigit(int number)
{
    int digit;
    digit = number % TEN;
    return digit;
}

int getTensDigit(int number)
{
    int temp = number / TEN;
    int digit = temp % TEN;
    return digit;
}

int getHundredsDigit(int number)
{
    int temp = number / HUNDRED;
    int digit = temp % TEN;
    return digit;
}

int getThousandsDigit(int number)
{
    int temp = number / THOUSAND;
    int digit = temp % TEN;
    return digit;
}

int getTenThousandsDigit(int number)
{
    int temp = number / TEN_THOUSAND;
    int digit = temp % TEN;
    return digit;
}

int getHundredThousandsDigit(int number)
{
    int temp = number / HUNDRED_THOUSAND;
    int digit = temp % TEN;
    return digit;
}

int roundToTens(int number)
{
    int units = getUnitsDigit(number);
    int result;
    
    if (units >= 5)
    {
        result = number + (TEN - units);
    }
    else
    {
        result = number - units;
    }
    
    return result;
}

int roundToHundreds(int number)
{
    int tens = getTensDigit(number);
    int remainder = number % HUNDRED;
    int result;
    
    if (tens >= 5)
    {
        result = number + (HUNDRED - remainder);
    }
    else
    {
        result = number - remainder;
    }
    
    return result;
}

int roundToThousands(int number)
{
    int hundreds = getHundredsDigit(number);
    int remainder = number % THOUSAND;
    int result;
    
    if (hundreds >= 5)
    {
        result = number + (THOUSAND - remainder);
    }
    else
    {
        result = number - remainder;
    }
    
    return result;
}

int roundToTenThousands(int number)
{
    int thousands = getThousandsDigit(number);
    int remainder = number % TEN_THOUSAND;
    int result;
    
    if (thousands >= 5)
    {
        result = number + (TEN_THOUSAND - remainder);
    }
    else
    {
        result = number - remainder;
    }
    
    return result;
}

int roundToHundredThousands(int number)
{
    int tenThousands = getTenThousandsDigit(number);
    int remainder = number % HUNDRED_THOUSAND;
    int result;
    
    if (tenThousands >= 5)
    {
        result = number + (HUNDRED_THOUSAND - remainder);
    }
    else
    {
        result = number - remainder;
    }
    
    return result;
}

int roundToMillions(int number)
{
    int hundredThousands = getHundredThousandsDigit(number);
    int remainder = number % MILLION;
    int result;
    
    if (hundredThousands >= 5)
    {
        result = number + (MILLION - remainder);
    }
    else
    {
        result = number - remainder;
    }
    
    return result;
}

void processUnitsRounding()
{
    int units = getUnitsDigit(finalResult);
    
    if (units >= 5)
    {
        int afterRounding = roundToTens(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
    }
}

void processTensRounding()
{
    int tens = getTensDigit(finalResult);
    
    if (tens >= 5)
    {
        int afterRounding = roundToHundreds(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
        int a = 10;
        int b = 20;
        int c = a + b;
    }
}

void processHundredsRounding()
{
    int hundreds = getHundredsDigit(finalResult);
    
    if (hundreds >= 5)
    {
        int afterRounding = roundToThousands(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
        for (int i = 0; i < 5; i++)
        {
            int x = i * 2;
        }
    }
}

void processThousandsRounding()
{
    int thousands = getThousandsDigit(finalResult);
    
    if (thousands >= 5)
    {
        int afterRounding = roundToTenThousands(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
    }
}

void processTenThousandsRounding()
{
    int tenThousands = getTenThousandsDigit(finalResult);
    
    if (tenThousands >= 5)
    {
        int afterRounding = roundToHundredThousands(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
        int temp = 1;
        temp = temp * 1;
    }
}

void processHundredThousandsRounding()
{
    int hundredThousands = getHundredThousandsDigit(finalResult);
    
    if (hundredThousands >= 5)
    {
        int afterRounding = roundToMillions(finalResult);
        
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
        else
        {
        }
    }
    else
    {
    }
}

void processMillionsRounding()
{
    int millions = finalResult / MILLION;
    if (millions >= 5)
    {
        int afterRounding = (millions + 1) * MILLION;
        if (afterRounding <= minimumLimit)
        {
            finalResult = afterRounding;
        }
    }
}

void outputResult()
{
    cout << finalResult << endl;
}

void doNothing()
{
    int a = 0;
    a = a + 0;
    for (int i = 0; i < 1; i++)
    {
    }
}

int addNumbers(int a, int b)
{
    return a + b;
}

int subtractNumbers(int a, int b)
{
    return a - b;
}