Petya loves computer games. Finally a game that he's been waiting for so long came out!The main character of this game has n different skills, each of which is characterized by an integer ai from 0 to 100. The higher the number ai is, the higher is the i-th skill of the character. The total rating of the character is calculated as the sum of the values of  for all i from 1 to n. The expression ⌊ x⌋ denotes the result of rounding the number x down to the nearest integer.At the beginning of the game Petya got k improvement units as a bonus that he can use to increase the skills of his character and his total rating. One improvement unit can increase any skill of Petya's character by exactly one. For example, if a4 = 46, after using one imporvement unit to this skill, it becomes equal to 47. A hero's skill cannot rise higher more than 100. Thus, it is permissible that some of the units will remain unused.Your task is to determine the optimal way of using the improvement units so as to maximize the overall rating of the character. It is not necessary to use all the improvement units.

The first line of the input contains two positive integers n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 107) — the number of skills of the character and the number of units of improvements at Petya's disposal. The second line of the input contains a sequence of n integers ai (0 ≤ ai ≤ 100), where ai characterizes the level of the i-th skill of the character.

The first line of the output should contain a single non-negative integer — the maximum total rating of the character that Petya can get using k or less improvement units.

NoteIn the first test case the optimal strategy is as follows. Petya has to improve the first skill to 10 by spending 3 improvement units, and the second skill to 10, by spending one improvement unit. Thus, Petya spends all his improvement units and the total rating of the character becomes equal to  lfloor frac{100}{10} rfloor +  lfloor frac{100}{10} rfloor = 10 + 10 =  20.In the second test the optimal strategy for Petya is to improve the first skill to 20 (by spending 3 improvement units) and to improve the third skill to 20 (in this case by spending 1 improvement units). Thus, Petya is left with 4 improvement units and he will be able to increase the second skill to 19 (which does not change the overall rating, so Petya does not necessarily have to do it). Therefore, the highest possible total rating in this example is .In the third test case the optimal strategy for Petya is to increase the first skill to 100 by spending 1 improvement unit. Thereafter, both skills of the character will be equal to 100, so Petya will not be able to spend the remaining improvement unit. So the answer is equal to .

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}

/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	var Prelude_1 = __webpack_require__(1);
	var List = __webpack_require__(2);
	var _a = List.map(parseInt, readline().split(' ')), n = _a[0], k = _a[1];
	var a = List.map(parseInt, readline().split(' '));
	var count = List.replicate(101, 0);
	for (var i = 0; i < a.length; i++) {
	    count[a[i]]++;
	}
	function enhance(ten, digit, delta) {
	    var skills = count[ten + digit];
	    if (skills == 0 || k < delta)
	        return;
	    var points = Math.floor(k / delta);
	    var chosen = Prelude_1.min(skills, points);
	    count[ten + digit] -= chosen;
	    count[ten + 10] += chosen;
	    k -= chosen * delta;
	}
	for (var digit = 9; digit > 0; digit--) {
	    var delta = 10 - digit;
	    for (var x = 0; x <= 90 && k >= delta; x += 10) {
	        enhance(x, digit, delta);
	    }
	}
	for (var x = 0; x <= 90; x += 10) {
	    enhance(x, 0, 10);
	}
	var result = 0;
	for (var x = 0; x <= 100; x++) {
	    result += count[x] * Math.floor(x / 10);
	}
	print(result);

/***/ },
/* 1 */
/***/ function(module, exports) {

	function min(a, b) {
	    return a < b ? a : b;
	}
	exports.min = min;
	function max(a, b) {
	    return a < b ? b : a;
	}
	exports.max = max;
	function curry(f) {
	    return function (x) { return function (y) { return f(x, y); }; };
	}
	exports.curry = curry;
	function uncurry(f) {
	    return function (x, y) { return f(x)(y); };
	}
	exports.uncurry = uncurry;
	function id(x) {
	    return x;
	}
	exports.id = id;
	function constant(x) {
	    return function (_) { return x; };
	}
	exports.constant = constant;
	function flip(f) {
	    return function (y) { return function (x) { return f(x)(y); }; };
	}
	exports.flip = flip;
	function flip2(f) {
	    return function (y, x) { return f(x, y); };
	}
	exports.flip2 = flip2;
	function compose(g, f) {
	    return function (x) { return g(f(x)); };
	}
	exports.compose = compose;

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	var Prelude_1 = __webpack_require__(1);
	function add(xs, ys) {
	    return xs.concat(ys);
	}
	exports.add = add;
	function head(xs) {
	    return xs[0];
	}
	exports.head = head;
	function last(xs) {
	    return xs[xs.length - 1];
	}
	exports.last = last;
	function tail(xs) {
	    return xs.slice(1);
	}
	exports.tail = tail;
	function init(xs) {
	    return xs.slice(0, xs.length - 1);
	}
	exports.init = init;
	function map(f, xs) {
	    var result = new Array(xs.length);
	    for (var i = 0; i < xs.length; i++) {
	        result[i] = f(xs[i]);
	    }
	    return result;
	}
	exports.map = map;
	function reverse(xs) {
	    return xs.slice().reverse();
	}
	exports.reverse = reverse;
	function intersperse(x, xs) {
	    if (xs.length == 0) {
	        return [];
	    }
	    var result = new Array(xs.length + xs.length - 1);
	    for (var i = 0; i + 1 < xs.length; i++) {
	        result[i + i] = xs[i];
	        result[i + i + 1] = x;
	    }
	    result[result.length - 1] = xs[xs.length - 1];
	    return result;
	}
	exports.intersperse = intersperse;
	function intercalate(xs, xss) {
	    return concat(intersperse(xs, xss));
	}
	exports.intercalate = intercalate;
	function foldl(f, initial, xs) {
	    var result = initial;
	    for (var i = 0; i < xs.length; i++) {
	        result = f(result, xs[i]);
	    }
	    return result;
	}
	exports.foldl = foldl;
	function foldr(f, initial, xs) {
	    var result = initial;
	    for (var i = xs.length - 1; i >= 0; i--) {
	        result = f(xs[i], result);
	    }
	    return result;
	}
	exports.foldr = foldr;
	function concat(xss) {
	    var total = sum(map(function (xs) { return xs.length; }, xss));
	    var result = new Array(total);
	    var m = 0;
	    for (var i = 0; i < xss.length; i++) {
	        var xs = xss[i];
	        for (var j = 0; j < xs.length; j++) {
	            result[m++] = xs[j];
	        }
	    }
	    return result;
	}
	exports.concat = concat;
	function sum(xs) {
	    var result = 0;
	    for (var i = 0; i < xs.length; i++) {
	        result += xs[i];
	    }
	    return result;
	}
	exports.sum = sum;
	function product(xs) {
	    var result = 1;
	    for (var i = 0; i < xs.length; i++) {
	        result *= xs[i];
	    }
	    return result;
	}
	exports.product = product;
	function maximum(xs) {
	    var result = xs[0];
	    for (var i = 1; i < xs.length; i++) {
	        if (result < xs[i])
	            result = xs[i];
	    }
	    return result;
	}
	exports.maximum = maximum;
	function minimum(xs) {
	    var result = xs[0];
	    for (var i = 1; i < xs.length; i++) {
	        if (result > xs[i])
	            result = xs[i];
	    }
	    return result;
	}
	exports.minimum = minimum;
	function replicate(n, x) {
	    var result = new Array(n);
	    for (var i = 0; i < result.length; i++) {
	        result[i] = x;
	    }
	    return result;
	}
	exports.replicate = replicate;
	function take(n, xs) {
	    return xs.slice(0, n);
	}
	exports.take = take;
	function drop(n, xs) {
	    return xs.slice(n);
	}
	exports.drop = drop;
	function splitAt(n, xs) {
	    return [take(n, xs), drop(n, xs)];
	}
	exports.splitAt = splitAt;
	function takeWhile(f, xs) {
	    for (var i = 0; i < xs.length; i++) {
	        if (!f(xs[i])) {
	            return xs.slice(0, i);
	        }
	    }
	    return xs.slice();
	}
	exports.takeWhile = takeWhile;
	function dropWhile(f, xs) {
	    for (var i = 0; i < xs.length; i++) {
	        if (!f(xs[i])) {
	            return xs.slice(i);
	        }
	    }
	    return [];
	}
	exports.dropWhile = dropWhile;
	function group(xs) {
	    if (xs.length == 0) {
	        return [];
	    }
	    var result = [];
	    var last = [xs[0]];
	    for (var i = 1; i < xs.length; i++) {
	        if (last[0] === xs[i]) {
	            last.push(xs[i]);
	        }
	        else {
	            result.push(last);
	            last = [xs[i]];
	        }
	    }
	    result.push(last);
	    return result;
	}
	exports.group = group;
	function filter(f, xs) {
	    var result = [];
	    for (var i = 0; i < xs.length; i++) {
	        if (f(xs[i]))
	            result.push(xs[i]);
	    }
	    return result;
	}
	exports.filter = filter;
	function zip(xs, ys) {
	    var n = Prelude_1.min(xs.length, ys.length);
	    var result = new Array(n);
	    for (var i = 0; i < n; i++) {
	        result[i] = [xs[i], ys[i]];
	    }
	    return result;
	}
	exports.zip = zip;
	function unzip(xs) {
	    var r1 = new Array(xs.length);
	    var r2 = new Array(xs.length);
	    for (var i = 0; i < xs.length; i++) {
	        r1[i] = xs[i][0];
	        r2[i] = xs[i][1];
	    }
	    return [r1, r2];
	}
	exports.unzip = unzip;

/***/ }
/******/ ]);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] > middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] < middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }

//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    data_help[i]=data[i]%10;
}
quickSort(0,n-1);

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data[i]=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

input = readline().split(" ").map(Number);
n = input[0];
k = input[1];
a = readline().split(" ").map(Number);

b = [];

for (var i = 0; i < n; i++) {
	b.push( {mod: a[i]%10, i: i} );
}
b.sort(function(x,y) { return x.mod - y.mod}).reverse();

for (var i = 0; i < n; i++) {
	if ( k >= (10 - b[i].mod) ) {
		var add = Math.min((10 - b[i].mod)%10, k);
		//write("add = " + add + "\n");
		a[b[i].i] += add;
		k -= add;
	}
}

a.sort();
for (var i = 0; i < n; i++) {
	if (a[i] < 100 && k > 0) {
		var add = Math.min(100 - a[i],k);
		a[i] += add;
		k -= add;
	}
}

answer = 0;
for (var i = 0; i < n; i++) {
	answer += Math.floor(a[i]/10);
}

write(answer);

//write("b[i].mod = " + b[i].mod + "\n");

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.round(parseInt(input[i])/10));
n=data.length;
data_help.length=n
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
while(k && data.length>0){
    for(i=0;i<n;i++){
        if(data[i]>=100){
            sum+=Math.round(data[i]/10);
            data.splice(i,1);
            n--;
            i--;
            continue;
        }
        var help=Math.round((1-data_help[i])*10);
        if(k>=help){
            data[i]=data[i]+help;
            k=k-help;
        }
        else {
            k=0;
            break;
        }
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.round(parseInt(input[i])/10));
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    data_help[i]=data[i]%10;
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=Math.round(data[i]/10);
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.round(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] > middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] < middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }

//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    data_help[i]=data[i]%10;
}
quickSort(0,n-1);

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    try{
        data_help[i]=data[i]%10;
    }catch (e){
        data_help[i]=0;
    }
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    if(data[i]!==0)
        sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    try{
        data_help[i]=data[i]%10;
    }catch (e){
        data_help[i]=0;
    }
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    try{
        sum+=Math.floor(data[i]/10);
    }catch (e){}
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
for(i=0;i<n;i++)
    if(input[i]<100)
        data[data.length]=parseInt(input[i]);
n=data.length;
data_help.length=n
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
while(k && data.length>0){
    for(i=0;i<n;i++){
        if(data[i]>=100){
            data.splice(i,1);
            n--;
            i--;
            continue;
        }
        var help=Math.round((1-data_help[i])*10);
        if(k>=help){
            data[i]=data[i]+help;
            k=k-help;
        }
        else {
            k=0;
            break;
        }
    }
}
var sum=0;
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
data.length=n;
for(i=0;i<n;i++)
    if(input[i]<100)
        data[data.length]=parseInt(input[i]);
n=data.length;
data_help.length=n
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
while(k && data.length>0){
    for(i=0;i<n;i++){
        if(data[i]>=100){
            data.splice(i,1);
            n--;
            i--;
            continue;
        }
        var help=Math.round((1-data_help[i])*10);
        if(k>=help){
            data[i]=data[i]+help;
            k=k-help;
        }
        else {
            k=0;
            break;
        }
    }
}
var sum=0;
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
data.length=n;
data_help.length=n;
for(i=0;i<n;i++)
    data[i]=parseInt(input[i]);
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
for(i=0;i<n;i++){
    var help=Math.round((1-data_help[i])*10);
    if(k>=help){
        data[i]=data[i]+help;
        k=k-help;
    }
    else
        break;
}
var sum=0;
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.floor(parseInt(input[i])/10));
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    data_help[i]=data[i]%10;
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=Math.floor(data[i]/10);
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    try{
        data_help[i]=data[i]%10;
    }catch (e){
        data[i]=10;
    }
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    try{
        data_help[i]=data[i]%10;
    }catch (e){
        data_help[i]=10;
    }
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.round(parseInt(input[i])/10));
n=data.length;
data_help.length=n
for(i=0;i<n;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
for(i=0;i<n;i++){

    var help=Math.round((1-data_help[i])*10);
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]==100){
            sum+=Math.round(data[i]/10);
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data[i]=data[i]+help;
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.round(parseInt(input[i])/10));
n=data.length;
data_help.length=n
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
for(i=0;i<n;i++){
    if(data[i]>=100){
        sum+=Math.round(data[i]/10);
        data.splice(i,1);
        n--;
        i--;
        continue;
    }
    var help=Math.round((1-data_help[i])*10);
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data[i]=data[i]+help;
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])!=100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=10;
n=data.length;
data_help.length=n;
for(i=0;i<n;i++){
    try{
        data_help[i]=data[i]%10;
    }catch (e){
        data_help[i]=0;
    }
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=10;
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    //try{
        sum+=Math.floor(data[i]/10);
    //}catch (e){}
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort(i, high);
        }
    }
//40 108
//20 100 99 50 8 78 44 67 91 75 93 53 96 81 96 86 81 0 58 9 51 63 70 73 80 79 28 82 4 15 60 74 19 17 54 81 11 67 71 66

var input=readline().split(' ');
//var input=['40','108'];
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
//input=['20','100' ,'99' ,'50' ,'8','78' ,'44' ,'67' ,'91', '75', '93', '53', '96' ,'81', '96', '86', '81', '0', '58', '9', '51', '63', '70', '73', '80', '79', '28', '82', '4', '15' ,'60' ,'74', '19', '17', '54', '81' ,'11', '67', '71', '66'];
var data=[];
var data_help=[];
var sum=0;
for(i=0;i<n;i++)
    if(parseInt(input[i])<100)
        data[data.length]=parseInt(input[i]);
    else
        sum+=(Math.floor(parseInt(input[i])/10));
n=data.length;
data_help.length=n
for(i=0;i<n;i++){
    data_help[i]=data[i]%10;
}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();

for(i=0;i<n;i++){
    var help=10-data_help[i];
    if(k>=help){
        data[i]=data[i]+help;
        data_help[i]=0;
        k=k-help;
        if(data[i]>=100){
            sum+=Math.floor(data[i]/10);
            data.splice(i,1);
            data_help.splice(i,1);
            n--;
            i--;
        }
    }
    else {
        break;
    }
}
for(i=0;i<n;i++){
    var help=100-data[i];
    if(k>=help){
        data=(data[i]+help);
        k=k-help;
    }
    else {
        data[i]+=k;
        break;
    }
}
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);
//document.writeln(sum);

function quickSort(low, high) {
        var i = low;
        var j = high;
        var middle = data_help[ Math.round(( low + high ) / 2) ];  // middle - опорный элемент; в нашей реализации он находится посередине между low и high

        do {
            while(data_help[i] < middle)
              {
                ++i;  // ищем элементы для правой части
              }
            while(data_help[j] > middle)
              {
                --j;  // ищем элементы для левой части
              }
            if(i <= j){
                // перебрасываем элементы
                var temp = data_help[i];
                data_help[i] = data_help[j];
                data_help[j] = temp;

                var temp2=data[i];
                data[i]=data[j];
                data[j]=temp2;
                // следующая итерация
                i++; j--;
            }
        }
        while(i < j);

        if(low < j){
          // рекурсивно вызываем сортировку для левой части
          quickSort(data_help, low, j);
        }

        if(i < high){
          // рекурсивно вызываем сортировку для правой части
          quickSort( i, high);
        }
    }
var input=readline().split(' ');
var n=parseInt(input[0]);
var k=parseInt(input[1]);
input=readline().split(' ');
var data=[];
var data_help=[];
data.length=n;
data_help.length=n;
for(i=0;i<n;i++)
    data[i]=parseInt(input[i]);
for(i=0;i<data.length;i++){
    data_help[i]=(data[i]/10)-Math.floor(data[i]/10);

}
quickSort(0,n-1);
data=data.reverse();
data_help=data_help.reverse();
while(k){
for(i=0;i<n;i++){
    var help=Math.round((1-data_help[i])*10);
    if(k>=help){
        data[i]=data[i]+help;
        k=k-help;
    }
    else {
        k=0;
        break;
    }
}
}
var sum=0;
for(i=0;i<n;i++){
    sum+=Math.floor(data[i]/10);
}
print(sum);

input = readline().split(" ").map(Number);
n = input[0];
k = input[1];
a = readline().split(" ").map(Number);

b = [];

for (var i = 0; i < n; i++) {
	b.push( {mod: a[i]%10, i: i} );
}
b.sort(function(x,y) { return x.mod - y.mod}).reverse();

for (var i = 0; i < n; i++) {
	if ( k >= (10 - b[i].mod) ) {
		var add = Math.min(10-b[i].mod, k);
		a[b[i].i] += add;
		k -= add;
	}
}

a.sort();
for (var i = 0; i < n; i++) {
	if (a[i] < 100 && k > 0) {
		var add = Math.min(100 - a[i],k);
		a[i] += add;
		k -= add;
	}
}

answer = 0;
for (var i = 0; i < n; i++) {
	answer += Math.floor(a[i]/10);
}

write(answer);

//write("b[i].mod = " + b[i].mod + "\n");


$$$2^k$$$ teams participate in a playoff tournament. The tournament consists of $$$2^k - 1$$$ games. They are held as follows: first of all, the teams are split into pairs: team $$$1$$$ plays against team $$$2$$$, team $$$3$$$ plays against team $$$4$$$ (exactly in this order), and so on (so, $$$2^{k-1}$$$ games are played in that phase). When a team loses a game, it is eliminated, and each game results in elimination of one team (there are no ties). After that, only $$$2^{k-1}$$$ teams remain. If only one team remains, it is declared the champion; otherwise, $$$2^{k-2}$$$ games are played: in the first one of them, the winner of the game "$$$1$$$ vs $$$2$$$" plays against the winner of the game "$$$3$$$ vs $$$4$$$", then the winner of the game "$$$5$$$ vs $$$6$$$" plays against the winner of the game "$$$7$$$ vs $$$8$$$", and so on. This process repeats until only one team remains.For example, this picture describes the chronological order of games with $$$k = 3$$$:  Let the string $$$s$$$ consisting of $$$2^k - 1$$$ characters describe the results of the games in chronological order as follows:  if $$$s_i$$$ is 0, then the team with lower index wins the $$$i$$$-th game;  if $$$s_i$$$ is 1, then the team with greater index wins the $$$i$$$-th game;  if $$$s_i$$$ is ?, then the result of the $$$i$$$-th game is unknown (any team could win this game). Let $$$f(s)$$$ be the number of possible winners of the tournament described by the string $$$s$$$. A team $$$i$$$ is a possible winner of the tournament if it is possible to replace every ? with either 1 or 0 in such a way that team $$$i$$$ is the champion.You are given the initial state of the string $$$s$$$. You have to process $$$q$$$ queries of the following form:   $$$p$$$ $$$c$$$ — replace $$$s_p$$$ with character $$$c$$$, and print $$$f(s)$$$ as the result of the query.

The first line contains one integer $$$k$$$ ($$$1 \le k \le 18$$$). The second line contains a string consisting of $$$2^k - 1$$$ characters — the initial state of the string $$$s$$$. Each character is either ?, 0, or 1. The third line contains one integer $$$q$$$ ($$$1 \le q \le 2 \cdot 10^5$$$) — the number of queries. Then $$$q$$$ lines follow, the $$$i$$$-th line contains an integer $$$p$$$ and a character $$$c$$$ ($$$1 \le p \le 2^k - 1$$$; $$$c$$$ is either ?, 0, or 1), describing the $$$i$$$-th query.

For each query, print one integer — $$$f(s)$$$.

const memo = [];

const trace = (arr, index) => {
	if (index >= arr.length) {
		return 1;
	}

	if (memo[index] !== undefined) {
		return memo[index];
	}

	if (arr[index] === '1') {
		const res = trace(arr, index*2+1);
		memo[index] = res;
		return res;
	}

	if (arr[index] === '0') {
		const res = trace(arr, index*2+2);
		memo[index] = res;
		return res;
	}

	const res = trace(arr, index*2+1) +
		trace(arr, index*2+2);

	memo[index] = res;
	return res;
}

const traceTop = (index) => {
	if (index < 0)
		return;

	memo[index] = undefined;

	if (index%2 === 0) {
		return traceTop((index - 2)/2);
	}

	return traceTop((index-1)/2);
}

let input = '';
process.stdin.on('data', str => input += str)
process.stdin.on('end', () => {
	const [, s, qCount, ...queries] = input.trim().split('\n');

	const line = s.trim().split('').reverse();

	for (let i=0; i<qCount; i++) {
		const [pos, val] = queries[i].trim().split(' ');
		line[line.length-pos] = val;

		traceTop(line.length-pos)
		console.log(trace(line, 0));
	}
})

var readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var lines = [];
rl.on('line', function(input) {
    lines.push(input);
});
rl.on('close', function() {
    var t = 1// parseInt(lines[0]);
    var l = 1;
    for (var i = 0; i < t; i++) {
        var str = lines[l++]
        var n = +lines[l++]
        var updates = lines.slice(l, l + n).map(x => x.split(' '))
        console.log(solve(str, updates));
        l += n
    }
});

let C2TMAP // ch index -> tree index
let T2CMAP
function solve(str, updates) {
    const chs = str.split('')
    const nodes = []
    createTree(nodes, chs)
    return updates.map(([i, ch]) => {
        const idx = +i - 1
        chs[idx] = ch
        updateTree(nodes, chs, idx)
        return nodes[0].v
    }).join('\n')
}

//    0123 45 6
// -> 6 45 0123
function createIndexMap(total) {
    T2CMAP = {}
    C2TMAP = {}

    let step = 2
    let chIdx = 0
    while (step <= total) {
        const limit = total / step // count of each level
        let treeIdx = limit - 1
        for (let i = 0; i < limit; i++) {
            T2CMAP[treeIdx] = chIdx
            C2TMAP[chIdx] = treeIdx
            chIdx++
            treeIdx++
        }
        step *= 2
    }
}

function createTree(nodes, chs) {
    const total = chs.length + 1
    createIndexMap(total)

    let step = total
    let l, r, limit
    while (step >= 1) {
        l = 0
        limit = total / step
        for (let i = 0; i < limit; i++) {
            r = l + step - 1
            const node = {
                l,
                r,
                v: 1,
                i: nodes.length
            }
            nodes[node.i] = node

            l = r + 1
        }
        step /= 2
    }

    // init v
    for (let i = 0; i < chs.length; i++) {
        const node = nodes[C2TMAP[i]]
        node.v = getMerge(nodes, chs, node)
    }
}

function updateTree(nodes, chs, idx) {
    let node = nodes[C2TMAP[idx]]
    while (1) {
        node.v = getMerge(nodes, chs, node)
        if (node.i === 0) break
        node = nodes[Math.floor((node.i - 1) / 2)]
    }
}

function getMerge(nodes, chs, node) {
    const ch = chs[T2CMAP[node.i]]
    const left = nodes[node.i * 2 + 1]
    const right = nodes[node.i * 2 + 2]
    if (ch === '0') {
        return left.v
    } else if (ch === '1') {
        return right.v
    } else {
        return left.v + right.v
    }
}

const trace = (arr, index) => {
	if (index > arr.length) {
		return 1;
	}

	if (arr[index] === '1') {
		return trace(arr, index*2+1);
	}

	if (arr[index] === '0') {
		return trace(arr, index*2+2);
	}

	return trace(arr, index*2+1) +
		trace(arr, index*2+2);
}

const solve = (str) => {
	const reverse = [...str].reverse();

	return trace(reverse, 0);
}

let input = '';
process.stdin.on('data', str => input += str)
process.stdin.on('end', () => {
	const [, s, qCount, ...queries] = input.trim().split('\n');

	const line = s.trim().split('');

	for (let i=0; i<qCount; i++) {
		const [pos, val] = queries[i].trim().split(' ');
		line[pos-1] = val;
		console.log(solve(line));
	}
})

const trace = (arr, index) => {
	if (index > arr.length) {
		return 1;
	}

	if (arr[index] === '1') {
		return trace(arr, index*2+1);
	}

	if (arr[index] === '0') {
		return trace(arr, index*2+2);
	}

	return trace(arr, index*2+1) +
		trace(arr, index*2+2);
}

const solve = (str) => {
	const reverse = [...str].reverse();

	return trace(reverse, 0);
}

let input = '';
process.stdin.on('data', str => input += str)
process.stdin.on('end', () => {
	const [k, s, qCount, ...queries] = input.trim().split('\n');

	const line = s.split('');

	for (let i=0; i<qCount; i++) {
		const [pos, val] = queries[i].split(' ');
		line[pos-1] = val;
		console.log(solve(line));
	}
})

var readline = require('readline');

var rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
var lines = [];
rl.on('line', function(input) {
    lines.push(input);
});
rl.on('close', function() {
    var t = 1// parseInt(lines[0]);
    var l = 1;
    for (var i = 0; i < t; i++) {
        var str = lines[l++]
        var n = +lines[l++]
        var updates = lines.slice(l, l + n).map(x => x.split(' '))
        console.log(solve(str, updates));
        l += n
    }
});

function solve(str, updates) {
    const chs = str.split('')
    return updates.map(([i, ch]) => {
        chs[+i - 1] = ch
        return cal(chs)
    }).join('\n')
}

function cal(chs) {
    let base = chs.length + 1
    let count = Array(base).fill(1)
    let next = []
    let pos = 0
    while (base > 1) {
        base /= 2
        for (let i = 0; i < base; i++) {
            const ch = chs[pos++]
            if (ch === '0') {
                next.push(count[i])
            } else if (ch === '1') {
                next.push(count[i + 1])
            } else {
                next.push(count[i] + count[i + 1])
            }
        }
        // console.log(next)
        count = next
        next = []
    }
    return count[0]
}


Everybody knows what an arithmetic progression is. Let us remind you just in case that an arithmetic progression is such sequence of numbers a1, a2, ..., an of length n, that the following condition fulfills: a2 - a1 = a3 - a2 = a4 - a3 = ... = ai + 1 - ai = ... = an - an - 1.For example, sequences [1, 5], [10], [5, 4, 3] are arithmetic progressions and sequences [1, 3, 2], [1, 2, 4] are not.Alexander has n cards containing integers. Arthur wants to give Alexander exactly one more card with a number so that he could use the resulting n + 1 cards to make an arithmetic progression (Alexander has to use all of his cards).Arthur has already bought a card but he hasn't written a number on it. Help him, print all integers that you can write on a card so that the described condition fulfilled.

The first line contains integer n (1 ≤ n ≤ 105) — the number of cards. The next line contains the sequence of integers — the numbers on Alexander's cards. The numbers are positive integers, each of them doesn't exceed 108.

If Arthur can write infinitely many distinct integers on the card, print on a single line -1. Otherwise, print on the first line the number of integers that suit you. In the second line, print the numbers in the increasing order. Note that the numbers in the answer can exceed 108 or even be negative (see test samples).

var n = +readline();
var a = readline().split(' ').map(function(v){
	return +v;
});

a.sort(function(a,b){ return a===b?0:a>b?1:-1; });

if(n===1){
	print(-1);
}else{
	var k = {};
	for(var i=1; i<n; i++){
		k[a[i]-a[i-1]]=true;
	}
	k=Object.keys(k).map(function(v){return +v;});
	if(k.length===1){
		if(k[0]===0){
			print(1);
			print(a[0]);
		}else{
			if( a.length==2 && (a[1]-a[0])%2==0 ){
				print(3);
				print([a[0]-k[0], a[0]+(a[1]-a[0])/2, a[n-1]+k[0]].join(' '));
			}else{
				print(2);
				print([a[0]-k[0], a[n-1]+k[0]].join(' '));
			}
		}
	}else if(k.length===2){
		var k0 = Math.min(k[0], k[1]);
		var k1 = Math.max(k[0], k[1]);
		if(k0*2==k1){
			var f=false;
			var e=false;
			var ans;
			for(var i=0; i<n-1; i++){
				if(a[i]+k0!==a[i+1]){
					if(!f){
						f=true;
						ans=a[i]+k0;
					}else{
						e=true;
					}
				}
			}
			if(e){
				print(0);
			}else{
				print(1);
				print(ans);
			}
		}else{
			print(0);
		}
	}else{
		print(0);
	}
}

function main()
{
    var N = parseInt( readline() );
    var numbers = readline().split(' ').map( function(item, index, array){ return parseInt(item); } );
    numbers.sort( function(a, b) { return a - b; } );

    if ( N == 1 )
    {
        print(-1);
    }
    else if ( N == 2 )
    {
        if ( numbers[0] == numbers[1] )
        {
            print(1);
            print( numbers[0] );
        }
        else
        {
            var ans = [];
            var diff = numbers[1] - numbers[0];
            ans.push( numbers[0] - diff );
            if ( diff % 2 == 0 ) ans.push( (numbers[0] + numbers[1]) / 2 );
            ans.push( numbers[1] + diff );
            print( ans.length );
            print( ans.join(' ') );
        }
    }
    else
    {
        var gaps = [];
        for (var i = 1; i < N; i++) gaps.push( numbers[i] - numbers[i-1] );
        gaps.sort(function(a, b){ return a - b; });
        gaps = gaps.filter( function(item, index, array){ return (index==0 || item != array[index-1]); } );

        var ans = [];
        if ( gaps.length == 1 )
        {
            ans.push( numbers[0] - gaps[0] );
            if ( gaps[0] != 0 ) ans.push( numbers[numbers.length - 1] + gaps[0] )
        }
        else if ( gaps.length == 2 && 2*gaps[0] == gaps[1] )
        {
            var Count = 0;
            for (var i = 1; i < N; i++) if( numbers[i] - numbers[i-1] == gaps[1] )
            {
                ans.push( (numbers[i] + numbers[i-1]) / 2 );
            }
            if ( ans.length > 1 ) ans = [];
        }

        print( ans.length );
        print( ans.join(' ') );
    }
}

main();

function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var integers = tokenizeIntegers(readline());
	var cardNum = integers[0];
	var cards = tokenizeIntegers(readline());
	cards.sort(function(a, b) { return a-b; });

	if (cardNum == 1) {
		print(-1);
	}
	else if (cardNum == 2) {
		var a = cards[0], b = cards[1];
		if (a == b) {
			print(1);
			print(a);
		}
		else if ((b-a)%2 == 1) {
			print(2);
			print(a-(b-a), b+(b-a));
		}
		else {
			print(3);
			print(a-(b-a), (a+b)/2, b+(b-a));
		}
	}
	else {
		var gaps = [];
		for (var i = 1; i < cardNum; i += 1) {
			gaps.push(cards[i]-cards[i-1]);
		}

		gaps.sort(function(a, b) { return a-b; });
		var small = gaps[0], big = gaps[gaps.length-1];

		if (small == big) {
			if (small == 0) {
				print(1);
				print(cards[0]);
			}
			else {
				print(2);
				print(cards[0]-small, cards[cardNum-1]+small);
			}
		}
		else {
			if (gaps[gaps.length-2] != small) {
				print(0);
				return;
			}
			if (2*small != big) {
				print(0);
				return;
			}
			for (var i = 1; i < cardNum; i += 1) {
				if (cards[i]-cards[i-1] == big) {
					print(1);
					print(cards[i-1]+small);
					return;
				}
			}
		}
	}

}

main();

var n = +readline();
var num = readline().split(' ').map(function(v){
	return +v;
});

var _flg=false;
num.sort(function(a,b){
	if(a==b){
		_flg=true;
		return 0;
	}else if(a>b){
		return 1;
	}else{
		return -1;
	}
});
if(n==1){
	print(-1);
}else if(_flg){
	print(0);
}else{

var arr = [];
for(var i=1;i<n;i++){
	arr.push( num[i]-num[i-1] );
}
var gcd=function(a,b){
	while(b!=0){
		var r=b;
		b=a%b;
		a=r;
	}
	return a;
};
var g=arr[0];
for(var i=1;i<arr.length;i++){
	g = gcd(g, arr[i]);
}

var ret=[];
for(var i=0;i<n-1;i++){

	var v = num[i]+g;
	while(v!==num[i+1]){
		ret.push(v);
		v=v+g;
	}
}

if(ret.length==0){
	print(2);
	print([num[0]-g, num[n-1]+g].join(' '));
}else{
	print(ret.length);
	print(ret.join(' '));
}

}

var n = +readline();
var a = readline().split(' ').map(function(v){
	return +v;
});

a.sort(function(a,b){ return a===b?0:a>b?1:-1; });

if(n===1){
	print(-1);
}else{
	var k = {};
	for(var i=1; i<n; i++){
		k[a[i]-a[i-1]]=true;
	}
	k=Object.keys(k).map(function(v){return +v;});
	if(k.length===1){
		if(k[0]===0){
			print(1);
			print(a[0]);
		}else{
			if( a.length==2 && (a[1]-a[0])%2==0 ){
				print(2);
				print([a[0]-k[0], a[0]+(a[1]-a[0])/2, a[n-1]+k[0]].join(' '));
			}else{
				print(2);
				print([a[0]-k[0], a[n-1]+k[0]].join(' '));
			}
		}
	}else if(k.length===2){
		var k0 = Math.min(k[0], k[1]);
		var k1 = Math.max(k[0], k[1]);
		if(k0*2==k1){
			var f=false;
			var e=false;
			var ans;
			for(var i=0; i<n-1; i++){
				if(a[i]+k0!==a[i+1]){
					if(!f){
						f=true;
						ans=a[i]+k0;
					}else{
						e=true;
					}
				}
			}
			if(e){
				print(-1);
			}else{
				print(1);
				print(ans);
			}
		}else{
			print(-1);
		}
	}else{
		print(-1);
	}
}

var n = +readline();
var num = readline().split(' ').map(function(v){
	return +v;
});

var _flg=1;
num.sort(function(a,b){
	if(a==b){
		_flg++;
		return 0;
	}else if(a>b){
		return 1;
	}else{
		return -1;
	}
});
if(n==1){
	print(-1);
}else if(_flg>1){
	if(num.length==_flg){
		print(1);
		print(num[0]);
	}else{
		print(0);
	}
}else{

var arr = [];
for(var i=1;i<n;i++){
	arr.push( num[i]-num[i-1] );
}
var gcd=function(a,b){
	while(b!=0){
		var r=b;
		b=a%b;
		a=r;
	}
	return a;
};

var map={};
arr.forEach(function(v){
	map[v]=true;
});

var k = Object.keys(map);
if( k.length>2 ){
	print(0);
}else if(k.length===2){
	if(k[0]*2==k[1]||k[1]*2==k[0]){
		var ret=[];
		var g = Math.min(+k[0], +k[1]);
		for(var i=0;i<n-1;i++){

			var v = num[i]+g;
			while(v!==num[i+1]){
				ret.push(v);
				v=v+g;
			}
		}
		print(ret.length);
		print(ret.join(' '));
	}else{
		print(0);
	}
}else{
	if(n==2&& (num[1]-num[0])%2==0 ){
		print(3);
		print([num[0]-k[0], num[0]+(num[1]-num[0])/2,num[1]+ +k[0]].join(' '));
	}else{
		print(2);
		print([num[0]-k[0], num[n-1]+ +k[0]].join(' '));
	}
}

}

var n = +readline();
var num = readline().split(' ').map(function(v){
	return +v;
});

var _flg=false;
num.sort(function(a,b){
	if(a==b){
		_flg=true;
		return 0;
	}else if(a>b){
		return 1;
	}else{
		return -1;
	}
});
if(n==1){
	print(-1);
}else if(_flg){
	if(num.length==2){
		print(1);
		print(num[0]);
	}else{
		print(0);
	}
}else{

var arr = [];
for(var i=1;i<n;i++){
	arr.push( num[i]-num[i-1] );
}
var gcd=function(a,b){
	while(b!=0){
		var r=b;
		b=a%b;
		a=r;
	}
	return a;
};

var map={};
arr.forEach(function(v){
	map[v]=true;
});

var k = Object.keys(map);
if( k.length>2 ){
	print(0);
}else if(k.length===2){
	if(k[0]*2==k[1]||k[1]*2==k[0]){
		var ret=[];
		var g = Math.min(+k[0], +k[1]);
		for(var i=0;i<n-1;i++){

			var v = num[i]+g;
			while(v!==num[i+1]){
				ret.push(v);
				v=v+g;
			}
		}
		print(ret.length);
		print(ret.join(' '));
	}else{
		print(0);
	}
}else{
	if(n==2&& (num[1]-num[0])%2==0 ){
		print(3);
		print([num[0]-k[0], num[0]+(num[1]-num[0])/2,num[1]+ +k[0]].join(' '));
	}else{
		print(2);
		print([num[0]-k[0], num[n-1]+ +k[0]].join(' '));
	}
}

}

var n = +readline();
var a = readline().split(' ').map(function(v){
	return +v;
});

a.sort(function(a,b){ return a===b?0:a>b?1:-1; });

if(n===1){
	print(-1);
}else{
	var k = {};
	for(var i=1; i<n; i++){
		k[a[i]-a[i-1]]=true;
	}
	k=Object.keys(k).map(function(v){return +v;});
	if(k.length===1){
		if(k[0]===0){
			print(1);
			print(a[0]);
		}else{
			if( a.length==2 && (a[1]-a[0])%2==0 ){
				print(2);
				print([a[0]-k[0], a[0]+(a[1]-a[0])/2, a[n-1]+k[0]].join(' '));
			}else{
				print(2);
				print([a[0]-k[0], a[n-1]+k[0]].join(' '));
			}
		}
	}else if(k.length===2){
		var k0 = Math.min(k[0], k[1]);
		var k1 = Math.max(k[0], k[1]);
		if(k0*2==k1){
			var f=false;
			var e=false;
			var ans;
			for(var i=0; i<n-1; i++){
				if(a[i]+k0!==a[i+1]){
					if(!f){
						f=true;
						ans=a[i]+k0;
					}else{
						e=true;
					}
				}
			}
			if(e){
				print(0);
			}else{
				print(1);
				print(ans);
			}
		}else{
			print(0);
		}
	}else{
		print(0);
	}
}

var n = +readline();
var num = readline().split(' ').map(function(v){
	return +v;
});

var _flg=false;
num.sort(function(a,b){
	if(a==b){
		_flg=true;
		return 0;
	}else if(a>b){
		return 1;
	}else{
		return -1;
	}
});
if(n==1){
	print(-1);
}else if(_flg){
	print(0);
}else{

var arr = [];
for(var i=1;i<n;i++){
	arr.push( num[i]-num[i-1] );
}
var gcd=function(a,b){
	while(b!=0){
		var r=b;
		b=a%b;
		a=r;
	}
	return a;
};
var g=arr[0];
for(var i=1;i<arr.length;i++){
	g = gcd(g, arr[i]);
}

var ret=[];
for(var i=0;i<n-1;i++){

	var v = num[i]+g;
	while(v!==num[i+1]){
		ret.push(v);
		v=v+g;
	}
}

print(ret.length);
print(ret.join(' '));

}

var n = +readline();
var num = readline().split(' ').map(function(v){
	return +v;
});

var _flg=false;
num.sort(function(a,b){
	if(a==b){
		_flg=true;
		return 0;
	}else if(a>b){
		return 1;
	}else{
		return -1;
	}
});
if(n==1){
	print(-1);
}else if(_flg){
	print(0);
}else{

var arr = [];
for(var i=1;i<n;i++){
	arr.push( num[i]-num[i-1] );
}
var gcd=function(a,b){
	while(b!=0){
		var r=b;
		b=a%b;
		a=r;
	}
	return a;
};

var map={};
arr.forEach(function(v){
	map[v]=true;
});

var k = Object.keys(map);
if( k.length>2 ){
	print(0);
}else if(k.length===2){
	if(k[0]*2==k[1]||k[1]*2==k[0]){
		var ret=[];
		var g = Math.min(+k[0], +k[1]);
		for(var i=0;i<n-1;i++){

			var v = num[i]+g;
			while(v!==num[i+1]){
				ret.push(v);
				v=v+g;
			}
		}
		print(ret.length);
		print(ret.join(' '));
	}else{
		print(0);
	}
}else{
	if(n==2&& (num[1]-num[0])%2==0 ){
		print(3);

		print([num[0]-k[0], num[0]+(num[1]-num[0])/2,num[1]+ +k[0]].join(' '));
	}else{
		print(2);
		print([num[0]-k[0], num[n-1]+ +k[0]].join(' '));
	}
}

}

function main()
{
    var N = parseInt( readline() );
    var numbers = readline().split(' ').map( function(item, index, array){ return parseInt(item); } );
    numbers.sort( function(a, b) { return a - b; } );

    if ( N == 1 )
    {
        print(-1);
    }
    else if ( N == 2 )
    {
        if ( numbers[0] == numbers[1] )
        {
            print(1);
            print( numbers[0] );
        }
        else
        {
            var ans = [];
            var diff = numbers[1] - numbers[0];
            ans.push( numbers[0] - diff );
            if ( diff % 2 == 0 ) ans.push( (numbers[0] + numbers[1]) / 2 );
            ans.push( numbers[1] + diff );
            print( ans.length );
            print( ans.join(' ') );
        }
    }
    else
    {
        var gaps = [];
        for (var i = 1; i < N; i++) gaps.push( numbers[i] - numbers[i-1] );
        gaps.sort(function(a, b){ return a - b; });
        gaps = gaps.filter( function(item, index, array){ return (index==0 || item != array[index-1]); } );

        var ans = [];
        if ( gaps.length == 1 )
        {
            ans.push( numbers[0] - gaps[0] );
            ans.push( numbers[numbers.length - 1] + gaps[0] )
        }
        else if ( gaps.length == 2 && 2*gaps[0] == gaps[1] )
        {
            var Count = 0;
            for (var i = 1; i < N; i++) if( numbers[i] - numbers[i-1] == gaps[1] )
            {
                ans.push( (numbers[i] + numbers[i-1]) / 2 );
            }
            if ( ans.length > 1 ) ans = [];
        }

        print( ans.length );
        print( ans.join(' ') );
    }
}

main();

function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var integers = tokenizeIntegers(readline());
	var cardNum = integers[0];
	var cards = tokenizeIntegers(readline());
	cards.sort(function(a, b) { return a-b; });

	if (cardNum == 1) {
		print(-1);
	}
	else if (cardNum == 2) {
		var a = cards[0], b = cards[1];
		if (a == b) {
			print(1);
			print(a);
		}
		else if ((b-a)%2 == 1) {
			print(2);
			print(a-(b-a), b+(b-a));
		}
		else {
			print(3);
			print(a-(b-a), (a+b)/2, b+(b-a));
		}
	}
	else {
		var gaps = [];
		for (var i = 1; i < cardNum; i += 1) {
			gaps.push(cards[i]-cards[i-1]);
		}

		gaps.sort(function(a, b) { return a-b; });
		var small = gaps[0], big = gaps[gaps.length-1];

		if (small == big) {
			if (small == 0) {
				print(1);
				print(cards[0]);
			}
			else {
				print(2);
				print(cards[0]-small, cards[cardNum-1]+small);
			}
		}
		else {
			if (gaps[gaps.length-2] != small) {
				print(0);
				return;
			}
			for (var i = 1; i < cardNum; i += 1) {
				if (cards[i]-cards[i-1] == big) {
					print(1);
					print(cards[i-1]+small);
					return;
				}
			}
		}
	}

}

main();

function trim(s) {
	return s.replace(/^\s+|\s+$/gm, '');
}

function tokenize(s) {
	return trim(s).split(/\s+/);
}

function tokenizeIntegers(s) {
	var tokens = tokenize(s);
	for (var i = 0; i < tokens.length; i += 1) {
		tokens[i] = parseInt(tokens[i]);
	};
	return tokens;
}

function main() {
	var integers = tokenizeIntegers(readline());
	var cardNum = integers[0];
	var cards = tokenizeIntegers(readline());
	cards.sort(function(a, b) { return a-b; });

	if (cardNum == 1) {
		print(-1);
	}
	else if (cardNum == 2) {
		var a = cards[0], b = cards[1];
		if (a == b) {
			print(1);
			print(a);
		}
		else if ((b-a)%2 == 1) {
			print(2);
			print(a-(b-a), b+(b-a));
		}
		else {
			print(3);
			print(a-(b-a), (a+b)/2, b+(b-a));
		}
	}
	else {
		var gaps = [];
		for (var i = 1; i < cardNum; i += 1) {
			gaps.push(cards[i]-cards[i-1]);
		}

		gaps.sort(function(a, b) { return a-b; });
		var small = gaps[0], big = gaps[gaps.length-1];

		if (small == big) {
			if (small == 0) {
				print(1);
				print(cards[0]);
			}
			else {
				print(2);
				print(cards[0]-small, cards[cardNum-1]+small);
			}
		}
		else {
			if (gaps[gaps.length-2] != small) {
				print(0);
				return;
			}
			if (2*small != big) {
				print(0);
			}
			for (var i = 1; i < cardNum; i += 1) {
				if (cards[i]-cards[i-1] == big) {
					print(1);
					print(cards[i-1]+small);
					return;
				}
			}
		}
	}

}

main();


Polycarp has created his own training plan to prepare for the programming contests. He will train for $$$n$$$ days, all days are numbered from $$$1$$$ to $$$n$$$, beginning from the first.On the $$$i$$$-th day Polycarp will necessarily solve $$$a_i$$$ problems. One evening Polycarp plans to celebrate the equator. He will celebrate it on the first evening of such a day that from the beginning of the training and to this day inclusive he will solve half or more of all the problems.Determine the index of day when Polycarp will celebrate the equator.

The first line contains a single integer $$$n$$$ ($$$1 \le n \le 200\,000$$$) — the number of days to prepare for the programming contests. The second line contains a sequence $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10\,000$$$), where $$$a_i$$$ equals to the number of problems, which Polycarp will solve on the $$$i$$$-th day.

Print the index of the day when Polycarp will celebrate the equator.

NoteIn the first example Polycarp will celebrate the equator on the evening of the second day, because up to this day (inclusive) he will solve $$$4$$$ out of $$$7$$$ scheduled problems on four days of the training.In the second example Polycarp will celebrate the equator on the evening of the third day, because up to this day (inclusive) he will solve $$$6$$$ out of $$$12$$$ scheduled problems on six days of the training.

n=Number(readline());a=readline().split(' ').map(Number);
e=a.reduce((r, i) => r + i, 0)/2;i=0;
while (e > 0) e -= a[i++];
print(i);

var a = parseInt(readline());
var b = readline().split(' ').map(function (i) { return parseInt(i); });
var c = b.reduce((a, b) => a + b);
var d = c / 2;
var e = 0;
for (var i = 0; i < b.length; i++) {
  e = e + b[i];
  if (e >= d) break;
}
print(i + 1);

var row = readline().split(" ").map(function(x) { return parseInt(x); });
var n = row[0];

var a = [];
var total = 0;
row = readline().split(" ").map(function(x) { return parseInt(x); });
for(var i = 0; i < n; i++) {
	a.push(row[i]);
	total += parseInt(row[i]);
}

var current = 0;
for(var i = 0; i < n; i++) {
    current += a[i];
	if(total / current <= 2) {
	    write(i + 1);
	    break;
	}
}

function main() {
  var n = Number(readline());
  var a = readline()
    .split(' ')
    .map(l => Number(l));
  var sum = [a[0]];

  for (var i = 1; i < a.length; i++) {
    sum[i] = sum[i - 1] + a[i];
  }

  var equator = sum[sum.length - 1] / 2;

  for (var i = 0; i < sum.length; i++) {
    if (sum[i] >= equator) {
      return print(i + 1);
    }
  }
}

main();

function main() {
    var n = readline();
    var a = readline().split(' ').map(l => Number(l));

    var sum = 0;
    for(var i = 0; i < n; i++)
        sum += a[i];

    var cnt = 0;
    for(var i = 0; i < n; i++) {
        cnt += a[i];

        if(2 * cnt >= sum)
            return print(i + 1), 0;
    }

    return 0;
}

main();

var a = readline();
var b = readline();
print(a);

function main() {
  var n = Number(readline());
  var a = readline()
    .split(' ')
    .map(l => Number(l));
  var sum = [a[0]];

  for (var i = 1; i < a.length; i++) {
    sum[i] = sum[i - 1] + a[i];
  }

  var equator = sum[sum.length - 1] / 2;

  for (var i = 1; i < sum.length; i++) {
    if (sum[i] >= equator) {
      return print(i + 1);
    }
  }
}

main();

function main() {
  var n = Number(readline());
  var a = readline()
    .split(' ')
    .map(l => Number(l));
  var sum = [a[0]];

  for (var i = 1; i < a.length; i++) {
    sum[i] = sum[i - 1] + a[i];
  }

  var closest = sum[0];
  var closestIndex = 0;

  for (var i = 1; i < sum.length; i++) {
    var iClose = Math.abs(sum[i] - sum[sum.length - 1] / 2);
    if (iClose < closest) {
      closest = iClose;
      closestIndex = i;
    }
  }

  print(closestIndex + 1);
}

main();