As you know, all the kids in Berland love playing with cubes. Little Petya has n towers consisting of cubes of the same size. Tower with number i consists of ai cubes stacked one on top of the other. Petya defines the instability of a set of towers as a value equal to the difference between the heights of the highest and the lowest of the towers. For example, if Petya built five cube towers with heights (8, 3, 2, 6, 3), the instability of this set is equal to 6 (the highest tower has height 8, the lowest one has height 2). 

The boy wants the instability of his set of towers to be as low as possible. All he can do is to perform the following operation several times: take the top cube from some tower and put it on top of some other tower of his set. Please note that Petya would never put the cube on the same tower from which it was removed because he thinks it's a waste of time. 

Before going to school, the boy will have time to perform no more than k such operations. Petya does not want to be late for class, so you have to help him accomplish this task.

Input

The first line contains two space-separated positive integers n and k (1 ≤ n ≤ 100, 1 ≤ k ≤ 1000) — the number of towers in the given set and the maximum number of operations Petya can perform. The second line contains n space-separated positive integers ai (1 ≤ ai ≤ 104) — the towers' initial heights.

Output

In the first line print two space-separated non-negative integers s and m (m ≤ k). The first number is the value of the minimum possible instability that can be obtained after performing at most k operations, the second number is the number of operations needed for that.

In the next m lines print the description of each operation as two positive integers i and j, each of them lies within limits from 1 to n. They represent that Petya took the top cube from the i-th tower and put in on the j-th one (i ≠ j). Note that in the process of performing operations the heights of some towers can become equal to zero.

If there are multiple correct sequences at which the minimum possible instability is achieved, you are allowed to print any of them.

Examples

Input

3 2
5 8 5


Output

0 2
2 1
2 3


Input

3 4
2 2 4


Output

1 1
3 2


Input

5 3
8 3 2 6 3


Output

3 3
1 3
1 2
1 3

Note

In the first sample you need to move the cubes two times, from the second tower to the third one and from the second one to the first one. Then the heights of the towers are all the same and equal to 6.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.NoSuchElementException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author el-Bishoy
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        DIv2B479_Towers solver = new DIv2B479_Towers();
        solver.solve(1, in, out);
        out.close();
    }

    static class DIv2B479_Towers {
        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int n = in.nextInt(), k = in.nextInt();

            IndexMaxPQ<Integer> maxQue = new IndexMaxPQ<>(n);
            IndexMinPQ<Integer> minQue = new IndexMinPQ<>(n);
            for (int i = 0; i < n; i++) {
                int a = in.nextInt();
                minQue.insert(i, a);
                maxQue.insert(i, a);
            }

            StringBuilder ans = new StringBuilder();

            int cnt = 0;
            int diff;


            int prevDiff;
            int maxIdx = maxQue.maxIndex();
            int minIdx = minQue.minIndex();

            int min = minQue.minKey();
            int max = maxQue.maxKey();

            diff = Math.abs(max - min);


            if (diff <= 1) {
                out.println(diff + " " + 0);
                return;
            }


//        ans.append((maxIdx + 1) + " " + (minIdx + 1)).append("\n");
//        maxQue.decreaseKey(maxQue.maxIndex(), maxQue.maxKey() - 1);
//        minQue.increaseKey(minQue.minIndex(), minQue.minKey() + 1);
//
//        //update to reverse consistenty
//        minQue.decreaseKey(maxIdx, max - 1);
//        maxQue.increaseKey(minIdx, min + 1);
//
//        min = minQue.minKey();
//        max = maxQue.maxKey();
//
//        prevDiff = diff;
//        cnt++;
//        k--;
            while (k-- > 0) {

                maxIdx = maxQue.maxIndex();
                minIdx = minQue.minIndex();
                min = minQue.minKey();
                max = maxQue.maxKey();
                diff = Math.abs(max - min);

                if (diff <= 1)
                    break;


                cnt++;
                ans.append((maxIdx + 1) + " " + (minIdx + 1)).append("\n");
                maxQue.decreaseKey(maxQue.maxIndex(), maxQue.maxKey() - 1);
                minQue.increaseKey(minQue.minIndex(), minQue.minKey() + 1);
                //update to reverse consistenty
                minQue.decreaseKey(maxIdx, max - 1);
                maxQue.increaseKey(minIdx, min + 1);
            }

            out.println((maxQue.maxKey() - minQue.minKey()) + " " + cnt);
            out.println(ans);
        }

        public class IndexMaxPQ<Key extends Comparable<Key>> {
            private int n;
            private int[] pq;
            private int[] qp;
            private Key[] keys;

            public IndexMaxPQ(int maxN) {
                if (maxN < 0) throw new IllegalArgumentException();
                n = 0;
                keys = (Key[]) new Comparable[maxN + 1];    // make this of length maxN??
                pq = new int[maxN + 1];
                qp = new int[maxN + 1];                   // make this of length maxN??
                for (int i = 0; i <= maxN; i++)
                    qp[i] = -1;
            }

            public boolean contains(int i) {
                return qp[i] != -1;
            }

            public void insert(int i, Key key) {
                if (contains(i)) throw new IllegalArgumentException("index is already in the priority queue");
                n++;
                qp[i] = n;
                pq[n] = i;
                keys[i] = key;
                swim(n);
            }

            public int maxIndex() {
                if (n == 0) throw new NoSuchElementException("Priority queue underflow");
                return pq[1];
            }

            public Key maxKey() {
                if (n == 0) throw new NoSuchElementException("Priority queue underflow");
                return keys[pq[1]];
            }

            public void increaseKey(int i, Key key) {
                if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
                if (keys[i].compareTo(key) >= 0)
                    throw new IllegalArgumentException("Calling increaseKey() with given argument would not strictly increase the key");

                keys[i] = key;
                swim(qp[i]);
            }

            public void decreaseKey(int i, Key key) {
                if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
                if (keys[i].compareTo(key) <= 0)
                    throw new IllegalArgumentException("Calling decreaseKey() with given argument would not strictly decrease the key");

                keys[i] = key;
                sink(qp[i]);
            }

            private boolean less(int i, int j) {
                return keys[pq[i]].compareTo(keys[pq[j]]) < 0;
            }

            private void exch(int i, int j) {
                int swap = pq[i];
                pq[i] = pq[j];
                pq[j] = swap;
                qp[pq[i]] = i;
                qp[pq[j]] = j;
            }

            private void swim(int k) {
                while (k > 1 && less(k / 2, k)) {
                    exch(k, k / 2);
                    k = k / 2;
                }
            }

            private void sink(int k) {
                while (2 * k <= n) {
                    int j = 2 * k;
                    if (j < n && less(j, j + 1)) j++;
                    if (!less(k, j)) break;
                    exch(k, j);
                    k = j;
                }
            }

        }

        public class IndexMinPQ<Key extends Comparable<Key>> {
            private int maxN;
            private int n;
            private int[] pq;
            private int[] qp;
            private Key[] keys;

            public IndexMinPQ(int maxN) {
                if (maxN < 0) throw new IllegalArgumentException();
                this.maxN = maxN;
                n = 0;
                keys = (Key[]) new Comparable[maxN + 1];    // make this of length maxN??
                pq = new int[maxN + 1];
                qp = new int[maxN + 1];                   // make this of length maxN??
                for (int i = 0; i <= maxN; i++)
                    qp[i] = -1;
            }

            public boolean contains(int i) {
                if (i < 0 || i >= maxN) throw new IllegalArgumentException();
                return qp[i] != -1;
            }

            public void insert(int i, Key key) {
                if (i < 0 || i >= maxN) throw new IllegalArgumentException();
                if (contains(i)) throw new IllegalArgumentException("index is already in the priority queue");
                n++;
                qp[i] = n;
                pq[n] = i;
                keys[i] = key;
                swim(n);
            }

            public int minIndex() {
                if (n == 0) throw new NoSuchElementException("Priority queue underflow");
                return pq[1];
            }

            public Key minKey() {
                if (n == 0) throw new NoSuchElementException("Priority queue underflow");
                return keys[pq[1]];
            }

            public void decreaseKey(int i, Key key) {
                if (i < 0 || i >= maxN) throw new IllegalArgumentException();
                if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
                if (keys[i].compareTo(key) <= 0)
                    throw new IllegalArgumentException("Calling decreaseKey() with given argument would not strictly decrease the key");
                keys[i] = key;
                swim(qp[i]);
            }

            public void increaseKey(int i, Key key) {
                if (i < 0 || i >= maxN) throw new IllegalArgumentException();
                if (!contains(i)) throw new NoSuchElementException("index is not in the priority queue");
                if (keys[i].compareTo(key) >= 0)
                    throw new IllegalArgumentException("Calling increaseKey() with given argument would not strictly increase the key");
                keys[i] = key;
                sink(qp[i]);
            }

            private boolean greater(int i, int j) {
                return keys[pq[i]].compareTo(keys[pq[j]]) > 0;
            }

            private void exch(int i, int j) {
                int swap = pq[i];
                pq[i] = pq[j];
                pq[j] = swap;
                qp[pq[i]] = i;
                qp[pq[j]] = j;
            }

            private void swim(int k) {
                while (k > 1 && greater(k / 2, k)) {
                    exch(k, k / 2);
                    k = k / 2;
                }
            }

            private void sink(int k) {
                while (2 * k <= n) {
                    int j = 2 * k;
                    if (j < n && greater(j, j + 1)) j++;
                    if (!greater(k, j)) break;
                    exch(k, j);
                    k = j;
                }
            }

        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }
}

