Little C loves number «3» very much. He loves all things about it.

Now he has a positive integer n. He wants to split n into 3 positive integers a,b,c, such that a+b+c=n and none of the 3 integers is a multiple of 3. Help him to find a solution.

Input

A single line containing one integer n (3 ≤ n ≤ 10^9) — the integer Little C has.

Output

Print 3 positive integers a,b,c in a single line, such that a+b+c=n and none of them is a multiple of 3.

It can be proved that there is at least one solution. If there are multiple solutions, print any of them.

Examples

Input

3


Output

1 1 1

Input

233

Output

77 77 79
	import java.io.BufferedWriter;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.io.OutputStreamWriter;
	import java.io.PrintWriter;
	import java.io.Writer;
	import java.util.Arrays;
	import java.util.InputMismatchException;
	import java.util.*;
	import java.io.*;
	import java.math.*;
	public class Main
	 
	{
	   public static long pow(long a, long b)
		{
			long result=1;
			while(b>0)
			{
				if (b % 2 != 0)
				{
					result=(result*a);
					b--;
				} 
				a=(a*a);
				b /= 2;
			}   
					return result;
		}
		public static long fact(long num)
		{
					long fact=1;
					int i=0;
					for(i=1; i<=num; i++)
					{
						fact=fact*i;
					}
					return fact;
				}
				public static long gcd(long a, long b)
				{
					if (a == 0)
						return b;
					return gcd(b%a, a);
				}
				
				public static long lcm(int a,int b)
				{
					return a * (b / gcd(a, b));
				}
				public static long sum(int h)
				{
					return (h*(h+1)/2);
				}
				public static void dfs(int parent,boolean[] visited)
				{
					ArrayList<Integer> arr=new ArrayList<Integer>();
					arr=graph.get(parent);
					visited[parent]=true;
					for(int i=0;i<arr.size();i++)
					{
						int num=arr.get(i);
						if(visited[num]==false)
						{
							dfs(num,visited);
						}
						else
						{
							
						}
					}
				}
				static int[] storing1;
				static int[] storing2;
				static ArrayList<ArrayList<Integer>> graph;
				static InputReader in=new InputReader(System.in);
				static OutputWriter out=new OutputWriter(System.out);
				public static long Long()
				{
					String s=in.String();
					return Long.parseLong(s);
				}
				public static void pln(String value)
				{
					System.out.println(value);
				}
				
			
				public static int[][] preprocess(int[] a,int n)
				{
					int[][] sparse=new int[n][(int)(Math.log(n)/Math.log(2))+1];
					for(int i=0;i<n;i++)
					{
						sparse[i][0]=i;
					}
					for(int j=1;(int)Math.pow(2,j)<=n;j++)
					{
						for(int i=0;i+(int)Math.pow(2,j)-1<n;i++)
						{
							if(a[sparse[i][j-1]]>a[sparse[i+(int)Math.pow(2,j-1)][j-1]])
							{
								sparse[i][j]=sparse[i][j-1];
							}
							else
							{
								sparse[i][j]=sparse[i+(int)Math.pow(2,j-1)][j-1];
							}
						}
					}
					return sparse;
				}
				
				public static int sparseQuery(int low,int high,int[][] sparse,int[] a)
				{
					int l=high-low+1;
					int k=(int)(Math.log(l)/Math.log(2));
					int ans=0;
					if(a[sparse[low][k]]>a[sparse[low+l-(int)Math.pow(2,k)][k]])
						ans=sparse[low][k];
					else
						ans=sparse[low+l-(int)Math.pow(2,k)][k];
					return ans;
				}
				
				
				
				
				
				
				public static void main(String args[])throws IOException
				{
				//	long a=pow(26,1000000005);
				 //   BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
				//	ArrayList<Integer> index=new ArrayList<>();
				//	ArrayList<Integer> index1=new ArrayList<>();
				//	ArrayList<Integer> index2=new ArrayList<>();
					TreeSet<Integer> ar=new TreeSet<Integer>();
					TreeSet<Integer> ar1=new TreeSet<Integer>();
					TreeSet<Integer> ar2=new TreeSet<Integer>();
					TreeSet<Integer> ts=new TreeSet<>();
					//TreeSet<Integer> ts1=new TreeSet<>();
					HashMap<Integer,Integer> hash=new HashMap<Integer,Integer>();
					long n=Long();
					{
						long num1=n/3;
						long num=n%3;
					//	pln(num1+" "+num);
						if(num1%3!=0)
						{
							if(num1%3==1)
							{
								if(num==1)
								{
									pln(num1+" "+num1+" "+(num1+1));
								}
								if(num==2)
								{
									pln(num1+" "+(num1+1)+" "+(num1+1));
								}
								if(num==0)
								{
									pln((num1)+" "+(num1)+" "+(num1));
								}
							}
							else if(num1%3==2)
							{
								if(num==1)
									pln((num1)+" "+(num1-1)+" "+(num1+2));
								else if(num==2)
								{
									pln((num1+2)+" "+num1+" "+num1);
								}
								else if(num==0)
								{
									pln(num1+" "+num1+" "+num1);
								}
							}
						}
						else
						{
							if(num==1)
							{
								System.out.println((num1-1)+" "+(num1+1)+" "+(num1+1));
							}
							else if(num==2)
							{
								pln((num1+2)+" "+(num1+2)+" "+(num1-2));
							}
							else if(num==0)
							{
								pln((num1-1)+" "+(num1-1)+" "+(num1+2));
							}
						}
					}
				}
			}
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			 
			class InputReader {
				 
				private InputStream stream;
				private byte[] buf = new byte[1024];
				private int curChar;
				private int numChars;
				private SpaceCharFilter filter;
			 
				public InputReader(InputStream stream) {
					this.stream = stream;
				}
			 
				public int read() {
					if (numChars== -1)
						throw new InputMismatchException();
					if (curChar >= numChars) {
						curChar = 0;
						try {
							numChars = stream.read(buf);
						} catch (IOException e) {
							throw new InputMismatchException();
						}
						if (numChars <= 0)
							return -1;
					}
					return buf[curChar++];
				}
				public int Int() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					int sgn = 1;
					if (c == '-') {
						sgn = -1;
						c = read();
					}
					int res = 0;
					do {
						if (c < '0' || c > '9')
							throw new InputMismatchException();
						res *= 10;
						res += c - '0';
						c = read();
					} while (!isSpaceChar(c));
					return res * sgn;
				}
			 
				public String String() {
					int c = read();
					while (isSpaceChar(c))
						c = read();
					StringBuilder res = new StringBuilder();
					do {
						res.appendCodePoint(c);
						c = read();
					} while (!isSpaceChar(c));
					return res.toString();
				}
			 
				public boolean isSpaceChar(int c) {
					if (filter != null)
						return filter.isSpaceChar(c);
					return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
				}
			 
				public String next() {
					return String();
				}
			 
				public interface SpaceCharFilter {
					public boolean isSpaceChar(int ch);
				}
			}
			 
			class OutputWriter {
				private final PrintWriter writer;
			 
				public OutputWriter(OutputStream outputStream) {
					writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
				}
			 
				public OutputWriter(Writer writer) {
					this.writer = new PrintWriter(writer);
				}
			 
				public void print(Object...objects) {
					for (int i = 0; i < objects.length; i++) {
						if (i != 0)
							writer.print(' ');
						writer.print(objects[i]);
					}
				}
			 
				public void printLine(Object...objects) {
					print(objects);
					writer.println();
				}
			 
				public void close() {
					writer.close();
				}
			 
				public void flush() {
					writer.flush();
				}
			 
				}
			 
				class IOUtils {
			 
				public static int[] readIntArray(InputReader in, int size) {
					int[] array = new int[size];
					for (int i = 0; i < size; i++)
						array[i] = in.Int();
					return array;
				}
			 
				}  