The Queen of England has n trees growing in a row in her garden. At that, the i-th (1 ≤ i ≤ n) tree from the left has height ai meters. Today the Queen decided to update the scenery of her garden. She wants the trees' heights to meet the condition: for all i (1 ≤ i < n), ai + 1 - ai = k, where k is the number the Queen chose.

Unfortunately, the royal gardener is not a machine and he cannot fulfill the desire of the Queen instantly! In one minute, the gardener can either decrease the height of a tree to any positive integer height or increase the height of a tree to any positive integer height. How should the royal gardener act to fulfill a whim of Her Majesty in the minimum number of minutes?

Input

The first line contains two space-separated integers: n, k (1 ≤ n, k ≤ 1000). The second line contains n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 1000) — the heights of the trees in the row. 

Output

In the first line print a single integer p — the minimum number of minutes the gardener needs. In the next p lines print the description of his actions. 

If the gardener needs to increase the height of the j-th (1 ≤ j ≤ n) tree from the left by x (x ≥ 1) meters, then print in the corresponding line "+ j x". If the gardener needs to decrease the height of the j-th (1 ≤ j ≤ n) tree from the left by x (x ≥ 1) meters, print on the corresponding line "- j x".

If there are multiple ways to make a row of trees beautiful in the minimum number of actions, you are allowed to print any of them.

Examples

Input

4 1
1 2 1 5


Output

2
+ 3 2
- 4 1


Input

4 1
1 2 3 4


Output

0
import java.io.*;
import java.util.*;
 
public class Main {
	static class FastReader{ 
        BufferedReader br; 
        StringTokenizer st; 
        public FastReader(){br = new BufferedReader(new InputStreamReader(System.in));}
        String next(){while (st == null || !st.hasMoreElements()){try{st = new StringTokenizer(br.readLine());} 
        catch (IOException  e){e.printStackTrace();}}return st.nextToken();}
        int nextInt(){ return Integer.parseInt(next());}long nextLong(){return Long.parseLong(next());}double nextDouble(){return Double.parseDouble(next());}
        String nextLine(){String str = ""; try{str = br.readLine(); } catch (IOException e) {e.printStackTrace();} return str; } 
    }
	static FastReader sc = new FastReader();
	static long mod = (long) (1e9+7);
	static List<Integer> g[];
	public static void main (String[] args){
        PrintWriter out = new PrintWriter(System.out);
        int t = 1;
//        t = sc.nextInt();
        z :for(int tc=1;tc<=t;tc++){
        	int n = sc.nextInt(), k = sc.nextInt();
        	int a[] = new int[n];
        	for(int i=0;i<n;i++) a[i] = sc.nextInt();
        	int max = Integer.MAX_VALUE, idx = 0;
        	List<int[]> ans = new ArrayList<>();
        	for(int i=0;i<n;i++) {
        		boolean is = true;
        		int forw = a[i];
        		int cnt = 0;
        		for(int j=i-1;j>=0&&is;j--) {
        			if(a[j] != forw-k) {
        				forw = forw-k;
        				cnt++;
        			}
        			else forw = a[j];
        			if(forw<=0) is = false;
        		}
        		int prev = a[i];
        		for(int j=i+1;j<n&&is;j++) {
        			if(a[j]!=prev+k) {
        				prev += k;
        				cnt++;
        			}
        			else prev = a[j];
        		}
        		if(is && cnt<max) {
        			max = cnt;
        			idx = i;
        		}
        	}
        	
        	for(int j=idx-1;j>=0;j--) {
    			if(a[j]!=a[j+1]-k) {
    				ans.add(new int[] {j,a[j+1]-k-a[j]});
    			}
    			a[j] = a[j+1]-k;
    		}
        	for(int j=idx+1;j<n;j++) {
        		if(a[j]!=a[j-1]+k) {
        			ans.add(new int[] {j,a[j-1]+k-a[j]});
        		}
        		a[j] = a[j-1]+k;
        	}
        	Collections.sort(ans,new Comparator<int[]>() {

				@Override
				public int compare(int[] o1, int[] o2) {
					return o1[0] - o2[0];
				}
        		
        	});
        	out.write(ans.size()+"\n");
        	for(int b[] : ans) {
        		if(b[1]>0) {
        			out.write("+ ");
        		}
        		else {
        			out.write("- ");
        		}
        		out.write((b[0]+1)+" "+Math.abs(b[1])+"\n");
        	}
        }
		out.close();
	}
}
class pair implements Comparable<pair>{
	int a;
	int c;
	int b;
	pair(int val,int c,int r){
		this.a = val;
		this.c = c;
		this.b = r;
	}
	@Override
	public int compareTo(pair o) {
		return (int) (this.a - o.a);
	}
}