Problem: Bachgold problem is very easy to formulate. Given a positive integer n represent it as a sum of maximum possible number of prime numbers. One can prove that such representation exists for any integer greater than 1.

Recall that integer k is called prime if it is greater than 1 and has exactly two positive integer divisors — 1 and k. 

Input

The only line of the input contains a single integer n (2 ≤ n ≤ 100 000).

Output

The first line of the output contains a single integer k — maximum possible number of primes in representation.

The second line should contain k primes with their sum equal to n. You can print them in any order. If there are several optimal solution, print any of them.

Examples

Input

5


Output

2
2 3


Input

6


Output

3
2 2 2

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Main{ 
   static class Fast{
     public BufferedReader br;
     public StringTokenizer st;
     
     public Fast(){
          br =new BufferedReader(new InputStreamReader(System.in));
     }
     
     String next(){
          while(st==null || !st.hasMoreTokens()){
               try{
                    st=new StringTokenizer(br.readLine());
               }
               catch(IOException e){
                    throw new RuntimeException(e);
               }
               
          }
               return st.nextToken();
          }
     int nextInt(){
          return Integer.parseInt(next());
     }

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

 }
  
 

   static void sort(int[] a) {
      ArrayList<Integer> list=new ArrayList<>();
      for (int i:a) list.add(i);
      Collections.sort(list);
      for (int i=0; i<a.length; i++) a[i]=list.get(i);
    } 
  static long modularExponentiation(long x,long n,long M)
   {
      long result=1;
       x=x%M;
      while(n>0)
      {
          if(n % 2 ==1)
              result=(result * x)%M;
          x=(x*x)%M;
          n=n/2;
      }
      return result;
    }
    // public static boolean dpRecurse(int i,int j,int k,int a[]){
    //       if (i==j) return true;
    //       if (j-i==1){
    //            if (Math.abs(a[j]-a[i])>k) return false;
    //            else return true;
    //       }
          
    //       if (Math.abs(a[i]-a[i+1])>k) return false;
    //       else return dpRecurse(i+1,j,k,a);
             
    //  }

    //public 
	public static void main(String[] args)throws Exception{
         //StringTokenizer st;//! @ % & * () _ {} # ~ : < > ? "" | ^
          Fast f=new Fast();
         PrintWriter out = new PrintWriter(System.out);
      
         //  int x=Integer.parseInt(st.nextToken());
         
        //st=new StringTokenizer(br.readLine()); 
         // int t=f.nextInt();
         // while(t-->0){
             int n=f.nextInt();
             
             int ans=0;
             boolean k=false;
             if (n%2==1) {
               n=n-3;
               ans++;
               k=true;
             }

             ans+=n/2;
             out.println(ans);
             for (int i=0;i<n/2;i++) {
               out.print(2+" ");
             }

             if (k) {
               out.print(3);
             }
             







         //}
        //out.println(mh);
    out.close();

}
}