Problem: This is an interactive problem. You have to use a flush operation right after printing each line. For example, in C++ you should use the function fflush(stdout), in Java — System.out.flush(), in Pascal — flush(output) and in Python — sys.stdout.flush().

Mr. Chanek wants to buy a flamingo to accompany his chickens on his farm. Before going to the pet shop, Mr. Chanek stops at an animal festival to have fun. It turns out there is a carnival game with a flamingo as the prize.

There are N mysterious cages, which are numbered from 1 to N. Cage i has A_i (0 ≤ A_i ≤ 10^3) flamingoes inside (1 ≤ i ≤ N). However, the game master keeps the number of flamingoes inside a secret. To win the flamingo, Mr. Chanek must guess the number of flamingoes in each cage.

Coincidentally, Mr. Chanek has N coins. Each coin can be used to ask once, what is the total number of flamingoes inside cages numbered L to R inclusive? With L < R.

Input

Use standard input to read the responses of your questions.

Initially, the judge will give an integer N (3 ≤ N ≤ 10^3), the number of cages, and the number of coins Mr. Chanek has.

For each of your questions, the jury will give an integer that denotes the number of flamingoes from cage L to R inclusive.

If your program does not guess the flamingoes or ask other questions, you will get "Wrong Answer". Of course, if your program asks more questions than the allowed number, your program will get "Wrong Answer".

Output

To ask questions, your program must use standard output.

Then, you can ask at most N questions. Questions are asked in the format "? L R", (1 ≤ L < R ≤ N). 

To guess the flamingoes, print a line that starts with "!" followed by N integers where the i-th integer denotes the number of flamingo in cage i. After answering, your program must terminate or will receive the "idle limit exceeded" verdict. You can only guess the flamingoes once.

Examples

Input

6
 
5
 
15
 
10
 

Output

 
? 1 2
 
? 5 6
 
? 3 4
 
! 1 4 4 6 7 8

Note

In the sample input, the correct flamingoes amount is [1, 4, 4, 6, 7, 8].

Solution (in JAVA):

Solution:
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.security.acl.LastOwnerException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Set;
import java.util.SortedSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import javax.sound.midi.Soundbank;
import org.omg.PortableInterceptor.LOCATION_FORWARD;


public class Main {

  public static PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));

  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[] nextSArray() {
      String sr[] = null;
      try {
        sr = br.readLine().trim().split(" ");
      } catch (IOException e) {
        e.printStackTrace();
      }
      return sr;
    }

    String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }

      return str;
    }
  }

//  static long mod = 1000000007;
//
//  static ArrayList<String> al=new ArrayList<>();
//  public static int n;
//
//  static  long inversion=0;
//
//  // static long arr[];
//static long tree[] = new long[100000];
//static void MakeTree(long arr[],int s,int e,int i)
//{
//  if(s==e)
//  {
//    tree[i] = arr[s];
//    return;
//  }
//  if(s<e)
//  {
//    int mid = (s+e)/2;
//    MakeTree(arr,s,mid,2*i);
//    MakeTree(arr,mid+1,e,2*i+1);
//    tree[i] = Math.min(tree[2*i],tree[2*i+1]);
//  }
//  return;
//}

//static long MinQuery(int s,int e,int qs,int qe,int i)
//{
//  long t=0;
//
//  if(qe<s || qs>e)
//  { t= Long.MAX_VALUE;}
//  else if(s==e)
//  {
//    t = tree[i];
//  }
//  else if(qs==s&&qe==e)
//  {
//    t = tree[i];
//
//  }
//  else {
//    int mid = (s + e) / 2;
//    t= Math.min(MinQuery(s, mid, qs, qe, 2 * i), MinQuery(mid + 1, e, qs, qe, 2 * i + 1));
//
//  }
//
//  return t;
//}
//
//public static void  UpdateQuery(int s,int e,int i,int qi,long val)
//{
//  if(qi<s||qi>e)
//    return;
//  if(s==e)
//  {
//    if(s==qi)
//      tree[i]=val;
//    return;
//  }
//  int mid = (s+e)/2;
//  UpdateQuery(s,mid,2*i,qi,val);
//  UpdateQuery(mid+1,e,2*i+1,qi,val);
//
//
//
//}

  //public static int QueryTime(int s,int e,int qs,int qe,long k,int i)
//{
//
//  if(qe<s || qs>e)
//  {
//
//    return 0;}
//  if(s>=qs && e<=qe)
//  {
//    int index = Collections.binarySearch(tree[i].al , k);
//    if(index<0)
//      index = Math.abs(index)-1;
//    //System.out.println(tree[i].al.size()-index);
//    return tree[i].al.size()-index;
//  }
//  int mid = (s+e)/2;
//  int m1 = QueryTime(s,mid,qs,qe,k,2*i);
//  int m2 = QueryTime(mid+1,e,qs,qe,k,2*i+1);
//
// // System.out.println((m1+m2) +" "+m1+" "+m2);
//  return m1+m2;
//}
//  public static ArrayList<Long> MakeTree(int s,int e,long arr[],int i)
//  {
//    if(s==e)
//    {
//      ArrayList<Long>al=new ArrayList<>();
//      al.add(arr[s]);
//      Node n = new Node(al);
//      tree[i]=n;
//      return al;
//    }
//    int mid = (s+e)/2;
//    ArrayList<Long> al1=MakeTree(s,mid,arr,2*i);
//    ArrayList<Long> al2=MakeTree(mid+1,e,arr,2*i+1);
//    ArrayList<Long>al=new ArrayList<>();
////    System.out.println("al1" +al1.toString());
////    System.out.println("al2" +al2.toString());
//
//    int ai=0,bi=0;
//    while(ai<al1.size() && bi<al2.size())
//    {
//      if(al1.get(ai)<al2.get(bi))
//      {
//        al.add(al1.get(ai));
//        ++ai;
//      }
//      else
//      {
//        al.add(al2.get(bi));
//        ++bi;
//      }
//    }
//    while(ai<al1.size())
//    {
//      al.add(al1.get(ai++));
//    }
//    while(bi<al2.size())
//    {
//      al.add(al2.get(bi++));
//    }
////    System.out.println("al"+al.toString());
//
//    Node n=new Node(al);
//    tree[i]=n;
//    return al;
//  }
//
//
//  static  int arr[][];
//  static Node tree[]=new Node[400070];
  static long powmodulo(long a, long p) {
    if (p == 0)
      return 1 % mod;
    if (p == 1)
      return a % mod;
    long ans = 1;
    while (p > 0) {
      if ((p & 1) > 0) {
        ans = (ans * a) % mod;
      }
      a = (a * a) % mod;
      p = p >> 1;
    }
    return ans % mod;
  }

  static long mod = 1000000007;

  static long gcd(long a,long b)
  {
    if(a==0)
      return b;
    return  gcd(b%a,a);
  }

  static String s;
  static  int ans=1;

  public static void Find(int [][] arr ,int i,int j,int ci)
  {
    if(ci==48 || (i==6&&j==6))
      return;
    char ch = s.charAt(ci);
      if(ch=='U')
      {
        arr[i-1][j]=1;
        Find(arr,i-1,j,ci+1);
      }
      if(ch=='D')
      {
        arr[i+1][j]=1;
        Find(arr,i+1,j,ci+1);
      }
      if(ch=='L')
      {
        arr[i][j-1]=1;
        Find(arr,i,j-1,ci+1);
      }
      if(ch=='R')
      {
        arr[i][j+1]=1;
        Find(arr,i,j+1,ci+1);
      }
      if(ch=='?')
      {
        int k=0;
        if((i-1)>=0 && arr[i-1][j]==0)
        {
          ++k;
          arr[i-1][j]=1;
          Find(arr, i-1,j,ci+1);
          arr[i-1][j]=0;
        }
        if(i+1<7 && arr[i+1][j]==0)
        {
          ++k;
          arr[i+1][j]=1;
          Find(arr, i+1,j,ci+1);
          arr[i+1][j]=0;
        }
        if(j-1>=0 && arr[i][j-1]==0)
        {
          ++k;
          arr[i][j-1]=1;
          Find(arr, i,j-1,ci+1);
          arr[i][j-1]=0;
        }
        if(j+1<7 && arr[i][j+1]==0)
        {
          ++k;
          arr[i][j+1]=1;
          Find(arr, i,j+1,ci+1);
          arr[i][j+1]=0;
        }
        ans=ans*k;

      }
  }





  public static void main(String[] args) throws Exception {
    FastReader sc = new FastReader();

//   int t1=sc.nextInt();
//    for (int t = 0; t < t1; t++) {

      int n=sc.nextInt();
      int arr[]=new int[n];
      System.out.println("? 1 2");
      int f12=sc.nextInt();
    System.out.println("? 2 3");
      int f23=sc.nextInt();
    System.out.println("? 1 3");
      int f13=sc.nextInt();
      arr[0]=f13-f23;
      arr[1] = f12-arr[0];
      arr[2] = f23-arr[1];
      int sum = f13;
      for(int i=3;i<n;++i)
      {

        System.out.println("? 1 "+(i+1));
        int x=sc.nextInt();
        arr[i] = x-sum;
        sum=x;
      }
    System.out.println("! "+Arrays.toString(arr).replaceAll("[\\[|\\]|,]",""));
    System.out.close();



    }
  }


class Pair
{
  int a; int b;
  Pair(int a,int b)
  {
    this.a=a;
    this.b=b;
  }
}

// out.println(al.toString().replaceAll("[\\[|\\]|,]",""));