/******/ (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");


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]
}


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();

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 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();


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();

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 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;
	}
}

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);

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();