Problem: Polycarp has guessed three positive integers a, b and c. He keeps these numbers in secret, but he writes down four numbers on a board in arbitrary order — their pairwise sums (three numbers) and sum of all three numbers (one number). So, there are four numbers on a board in random order: a+b, a+c, b+c and a+b+c.

You have to guess three numbers a, b and c using given numbers. Print three guessed integers in any order.

Pay attention that some given numbers a, b and c can be equal (it is also possible that a=b=c).

Input

The only line of the input contains four positive integers x_1, x_2, x_3, x_4 (2 ≤ x_i ≤ 10^9) — numbers written on a board in random order. It is guaranteed that the answer exists for the given number x_1, x_2, x_3, x_4.

Output

Print such positive integers a, b and c that four numbers written on a board are values a+b, a+c, b+c and a+b+c written in some order. Print a, b and c in any order. If there are several answers, you can print any. It is guaranteed that the answer exists.

Examples

Input


3 6 5 4


Output


2 1 3


Input


40 40 40 60


Output


20 20 20


Input


201 101 101 200


Output


1 100 100

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class Main {
	static ArrayList<Integer> adj[];
	static ArrayList<Edge> adjlist[];



	static int n;

	public static void main(String args[]) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
	int x1=sc.nextInt();
			int x2=sc.nextInt();
			int x3=sc.nextInt();
			int x4=sc.nextInt();
	        int max=Math.max(Math.max(x1, x2),Math.max(x3, x4));
	if(max==x1) {
	        int a=max-x2;
	 int b=max-x3;
	 int c=max-x4;
	 System.out.println(a+" "+b+" "+c);
			out.flush();
	}
	else if(max==x2) {
        int a=max-x1;
 int b=max-x3;
 int c=max-x4;
 System.out.println(a+" "+b+" "+c);
		out.flush();
   }
	else if(max==x3) {
        int a=max-x1;
 int b=max-x2;
 int c=max-x4;
 System.out.println(a+" "+b+" "+c);
		out.flush();
   }
	else if(max==x4) {
        int a=max-x1;
 int b=max-x2;
 int c=max-x3;
 System.out.println(a+" "+b+" "+c);
		out.flush();
   }
	
	}
	static int up[][];
	static int tin[];
	static int tout[];
	static int timer=0;
	static int[] height,first;
	static int l=0;
	static int parent[];
	static void binarylifting(int v,int p) {
		tin[v] = ++timer;
		up[v][0] = p;
			
		    for (int i = 1; i <=l; ++i) {
		        up[v][i] = up[up[v][i-1]][i-1];
		        
		    }
		        for (int i = 0; i < adj[v].size(); i++) {
		    		int u=adj[v].get(i);
		        	if (u != p)
			    	{
			    		binarylifting(u, v);
			    	}	
				}
		        
		    	
		        
		    
		        tout[v] = ++timer;
	}
	static boolean is_ancestor(int u, int v)
	{
	    return tin[u] <= tin[v] && tout[u] >= tout[v];
	}
	static int lca(int u, int v)
	{
	    if (is_ancestor(u, v))
	        return u;
	    if (is_ancestor(v, u))
	        return v;
	    for (int i = l; i >= 0; --i) {
	        if (!is_ancestor(up[u][i], v))
	            u = up[u][i];
	    }
	    return up[u][0];
	}
	static boolean vis[];
	static void dfs(int u,int h) {
		vis[u]=true;
		height[u]=h;
		for(int v:adj[u]) {
			if(!vis[v]) {
				parent[v]=u;
				dfs(v,h+1);
			}
		}
	}
	static class Edge implements Comparable<Edge>
	{
		int node;int cost;  
		
		Edge(int a, int b) { node = a;	cost = b; }
		
		public int compareTo(Edge e){ return cost-e.cost;	}
	}
	
	
	


	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream system) {
			br = new BufferedReader(new InputStreamReader(system));
		}
 
		public Scanner(String file) throws Exception {
			br = new BufferedReader(new FileReader(file));
		}
 
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}
 
		public String nextLine() throws IOException {
			return br.readLine();
		}
 
		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}
 
		public double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}
 
		public char nextChar() throws IOException {
			return next().charAt(0);
		}
 
		public Long nextLong() throws IOException {
			return Long.parseLong(next());
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
		public void waitForInput() throws InterruptedException {
			Thread.sleep(3000);
		}
	}
}