Problem: Little X used to play a card game called "24 Game", but recently he has found it too easy. So he invented a new game.

Initially you have a sequence of n integers: 1, 2, ..., n. In a single step, you can pick two of them, let's denote them a and b, erase them from the sequence, and append to the sequence either a + b, or a - b, or a × b.

After n - 1 steps there is only one number left. Can you make this number equal to 24?

Input

The first line contains a single integer n (1 ≤ n ≤ 105).

Output

If it's possible, print "YES" in the first line. Otherwise, print "NO" (without the quotes).

If there is a way to obtain 24 as the result number, in the following n - 1 lines print the required operations an operation per line. Each operation should be in form: "a op b = c". Where a and b are the numbers you've picked at this operation; op is either "+", or "-", or "*"; c is the result of corresponding operation. Note, that the absolute value of c mustn't be greater than 1018. The result of the last operation must be equal to 24. Separate operator sign and equality sign from numbers with spaces.

If there are multiple valid answers, you may print any of them.

Examples

Input

1


Output

NO


Input

8


Output

YES
8 * 7 = 56
6 * 5 = 30
3 - 4 = -1
1 - 2 = -1
30 - -1 = 31
56 - 31 = 25
25 + -1 = 24

Solution (in JAVA):

Solution:
import java.io.*;
import java.lang.reflect.Array;
import java.util.*;
public class test {
    int max = 0;
    long max1 = 0;
    boolean visited[][];
    int parent[];
    boolean bi=true;
    StringBuilder cout=new StringBuilder("");
    int color[];
    PrintStream out = System.out;
    int signx[] = {1,-1,0 ,0, 1, -1,-1,1};
    int signy[]=  {0,0,1,-1,  1,-1,1,-1};
    public static void main(String args[]) throws IOException {
        test obj = new test();
        obj.start();
    }

    void start() throws IOException {
   // Reader sc = new Reader();
       // BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       Scanner sc=new Scanner(System.in);
       int n=sc.nextInt();
        if(n<=3)
            out.println("NO");
        else
        {
            out.println("YES");
            int t=n%4;
            switch(t)
            {
                case 0:
                {
                    out.println("4 * 3 = 12");
                    out.println("12 * 2 = 24");
                    out.println("24 * 1 = 24");
                    while(n>4)
                    {
                        out.println(n+" - "+(n-1)+" = "+1);
                        out.println(n-3+" - "+(n-2)+" = "+(-1));
                        out.println(1+" + "+(-1)+" = "+0);
                        out.println("24 - 0 =  24");
                        n-=4;
                    }
                    break;
                }
                case 1:
                {
                    out.println("5 * 4 = 20");
                    out.println("3 - 1 = 2");
                    out.println("2 * 2 = 4");
                    out.println("20 + 4 = 24");
                    while(n>5)
                    {
                        out.println(n+" - "+(n-1)+" = "+1);
                        out.println(n-3+" - "+(n-2)+" = "+(-1));
                        out.println(1+" + "+(-1)+" = "+0);
                        out.println("24 - 0 =  24");
                        n-=4;
                    }
break;
                }
                case 2:
                {
                 out.println("5 * 4 = 20");
                    out.println("20 + 6 = 26");
                    out.println("3 - 2 = 1");
                    out.println("1 + 1 = 2");
                    out.println("26 - 2 = 24");
                    while(n>6)
                    {
                        out.println(n+" - "+(n-1)+" = "+1);
                        out.println(n-3+" - "+(n-2)+" = "+(-1));
                        out.println(1+" + "+(-1)+" = "+0);
                        out.println("24 - 0 =  24");
                        n-=4;
                    }
                 break;
                }
                case 3:
                {
                    out.print("5 - 3 = 2\n" +
                            "2 * 4 = 8\n" +
                            "1 + 2 = 3\n" +
                            "8 * 3 = 24\n" +
                            "7 - 6 = 1\n" +
                            "24 * 1 = 24\n");
                    while(n>7)
                    {
                        out.println(n+" - "+(n-1)+" = "+1);
                        out.println(n-3+" - "+(n-2)+" = "+(-1));
                        out.println(1+" + "+(-1)+" = "+0);
                        out.println("24 - 0 =  24");
                        n-=4;
                    }
                    break;
                }
            }
        }
    }


    //<---------------------------------------------------------------------------------------------------------------->//

    //printing 2-d array
    private void println(int[][] a,int n,int m) {
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
                System.out.print(a[i][j]+" ");
            System.out.println();
        }

    }
    void dfs(char a[][],char t,int i,int j,int n,int m,int p,int q)
    {
        //  out.print(" "+i+" "+j+" "+t);
        visited[i][j]=true;
        for(int c=0;c<4;c++)
        {
            int temp=i+signx[c];
            int temp1=j+signy[c];
            if(temp>=0&&temp<n&&temp1>=0&&temp1<m)
            {
                if(a[temp][temp1]==t&&(temp!=p||temp1!=q)&&!visited[temp][temp1])
                    dfs(a,t,temp,temp1,n,m,i,j);
                else if(a[temp][temp1]==t&&(temp!=p||temp1!=q)&&visited[temp][temp1]) {
                    max = 1;
                }
            }
        }

    }
    void println(ArrayList<Long> a)
    {
        for (Long b:a
                ) {
            System.out.print(b+" ");
        }
    }


    //modified dfs for chessboard, matrix
    void dfs(char a[][],int i,int j,char t,int n,int m,int d,int p,int q,boolean visited[][])
    {

    }


    //constructing segment tree
    private void constructseg(long[] seg, long[] input, int p, int q, int pos) {
        if(p==q)
        {
            seg[pos]=input[p];
            return;
        }
        int mid=(q+p)/2;
        constructseg(seg,input,p,mid,2*pos+1);
        constructseg(seg,input,mid+1,q,2*pos+2);
        seg[pos]=seg[2*pos+1]+seg[2*pos+2];
    }

    /*  void bipartite(ArrayList<Integer> a[],int i)
      {
          int presentcolor=color[i];
          int nextcolor;
          if(color[i]==0) {
              nextcolor=1;
            b.add(i);
          }
          else
          {
              nextcolor=0;
              c.add(i);
          }
          for(int j=0;j<a[i].size();j++)
          {
              if(color[a[i].get(j)]==presentcolor)
                  bi=false;
              else if(color[a[i].get(j)]==-1)
              {
                  color[a[i].get(j)]=nextcolor;
                  bipartite(a,a[i].get(j));
              }
          }

      }*/
    //traversing through a arrayList graph
    void dfs(ArrayList<Integer> node[],int i)
    {

      /*  visited[i]=true;
   /*     if(cat[i]==1) {
            count++;
        }
        else
            count=0;
        if(count>k) {
            return;
        }
        if(node[i].size()==1&&i!=0) {
            max += 1;
        }
        for (int j = 0; j < node[i].size(); j++) {
            if(!visited[node[i].get(j)]) {
                max--;
                dfs(node, node[i].get(j));
            }
        }*/

    }


    //printing arraylist array
    void println(ArrayList<Integer> a[])
    {
        for (ArrayList<Integer> b:a
                ) {
            System.out.println(b.toString());
        }
    }

    //sorting 2 array based on a, Complexity is O(n^2)
    void sort(int a[],int b[],int n)
    {
        for(int i=1;i<n;i++)
        {
            int index=i;
            for(int j=i-1;j>=0;j--)
            {
                //  println(a);
                if(a[index]<a[j])
                {
                    int temp=a[index];
                    int temp2=b[index];
                    a[index]=a[j];
                    b[index]=b[j];
                    a[j]=temp;
                    b[j]=temp2;
                    index=j;

                }
                else
                    break;
            }
        }

    }
    // to create and initialize Integer array
    private int[] intArray(int a, Scanner sc) {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }

    private int[] intArray(int a, Reader sc) throws IOException {
        int temp[]=new int[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextInt();
        }
        return temp;
    }// / to create and initialize Long Array
    private long[] longArray(int a, Scanner sc) {
        long temp[]=new long[a];
        for(int i=0;i<a;i++) {
            temp[i]=sc.nextLong();
        }
        return temp;
    }

    // displaying Map contents key--value
    public static void printMap(Map mp) {
        Iterator it = mp.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry pair = (Map.Entry)it.next();
            System.out.println(pair.getKey() + " = " + pair.getValue());
            it.remove(); // avoids a ConcurrentModificationException
        }
    }


    // Return arrayList of minimum factor of number
    // 24= 2*2*2*3;
    private ArrayList<Integer> minFactor(int a) {
        ArrayList<Integer> obj=new ArrayList<>();
        for(int i=2;i<=a;i++)
        {
            while(a!=0&&a%i==0)
            {
                obj.add(i);
                a/=i;
            }
        }
        return obj;
    }


    // check whether the number is prime or not
    public static boolean isPrimeNumber(int i) {
        int factors = 0;
        int j = 1;

        while(j <= i)
        {
            if(i % j == 0)
            {
                factors++;
            }
            j++;
        }
        return (factors == 2);
    }

    // creating and initializing arrayList
    private void initArrayList(ArrayList<Integer>[] tempa) {
        for(int i=0;i<tempa.length;i++)
            tempa[i]=new ArrayList<>();
    }

    // return factorial contents as ArrayList
    private ArrayList<Integer> factdigit(int i)
    {
        ArrayList<Integer> temp=new ArrayList<>();
        for(int j=i;j>1;j--)
        {
            temp.add(j);
        }
        return temp;
    }

    //printing Integer array
    private  void println(int a[])
    {
        for(int i=0;i<a.length;i++)
            System.out.print(a[i]+" ");
    }
    int factorial(int n){
        if (n == 0)
            return 1;
        else
            return((n %1000000007)* (factorial(n-1)%1000000007));
    }
}





class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[300]; // line length
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n')
                break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');

        if (neg)
            return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();
        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');
        if (neg)
            return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ')
            c = read();
        boolean neg = (c == '-');
        if (neg)
            c = read();

        do {
            ret = ret * 10 + c - '0';
        }
        while ((c = read()) >= '0' && c <= '9');

        if (c == '.') {
            while ((c = read()) >= '0' && c <= '9') {
                ret += (c - '0') / (div *= 10);
            }
        }

        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null)
            return;
        din.close();
    }
}

//Pair implementation
class Pair<A, C> {
    public A a;
    public C c;

    Pair(A a, C c) {
        this.a = a;
        this.c = c;
    }

    A getKey() {
        return this.a;
    }

    C getValue() {
        return this.c;
    }

    void print() {
        System.out.println(this.a + " " + this.c);
    }
}