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.*;
import java.util.*;
import java.util.stream.*;

import static java.util.stream.Collectors.groupingBy;

public class Main {

    private interface Input extends Closeable {
        String next() throws IOException;

        default int nextInt() throws IOException {
            return Integer.parseInt(next());
        }

        default long nextLong() throws IOException {
            return Long.parseLong(next());
        }
    }

    private static class StandardInput implements Input {
        private final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        private StringTokenizer stringTokenizer;

        @Override
        public void close() throws IOException {
            reader.close();
        }

        @Override
        public String next() throws IOException {
            if (stringTokenizer == null || !stringTokenizer.hasMoreTokens()) {
                stringTokenizer = new StringTokenizer(reader.readLine());
            }
            return stringTokenizer.nextToken();
        }
    }

    public static class MapData {
        Map<Character, List<Integer>> myMap = new HashMap<>();

        public void add(Character character, Integer index) {
            if (!myMap.containsKey(character)) {
                List<Integer> myList = new ArrayList<>();
                myList.add(index);
                myMap.put(character, myList);
            } else {
                List<Integer> myList = myMap.get(character);
                myList.add(index);
            }
        }

        public List<Integer> getAvailableIndex() {
            return myMap.entrySet().stream().map(Map.Entry::getValue).flatMap(List::stream).collect(Collectors.toList());
        }

        public int pop(Character character) {
            if (!myMap.containsKey(character))
                return popFromQuestion();
            else {
                List<Integer> myList = myMap.get(character);
                if (myList.size() > 0)
                    return myList.remove(myList.size() - 1);
                else return popFromQuestion();
            }
        }

        private int popFromQuestion() {
            if (!myMap.containsKey('?'))
                return -1;
            else {
                List<Integer> myList = myMap.get('?');
                if (myList.size() > 0)
                    return myList.remove(myList.size() - 1);
                else return -1;
            }
        }
    }

    public static class MyObject {
        int i;
        char character;


        MyObject(int i, char j) {
            this.i = i;
            this.character = j;
        }
    }

    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        List<Long> data = LongStream.range(0, 4).boxed().map(i -> scanner.nextLong()).sorted().collect(Collectors.toList());
        long c = data.get(3) - data.get(0);
        long b = data.get(3) - data.get(1);
        long a = data.get(3) - data.get(2);

        System.out.println(a + " " + b + " " + c);
    }

    private static boolean satisfy(int j, List<Integer> view, int value) {
        return (view.get(j) >= value);

    }
}