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 \leq n \leq 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

Difficulty: EASY

Solutions:
num = int(input())
if num % 3 == 0:
	print(1, 1, num - 2)
elif num % 3 == 1:
	print(1, 1, num - 2)
elif num % 3 == 2:
	print(1, 2, num - 3)


def main():
	n = int(input())
	if n % 3 == 0 or n % 3 == 1:
		print(1, 1, n - 2)
	else:
		print(1, 2, n - 3)

def __starting_point():
	main()
__starting_point()


n = int(input())
print(1, 1 if (n - 2) % 3 != 0 else 2, n - 2 if (n - 2) % 3 != 0 else n - 3)


n = int(input())
a = n % 3
if a == 0 or a == 1:
	print('1 1', n - 2)
else:
	print('1 2', n - 3)


n = int(input())
flag = 0
i = 1
j = 1
k = n - 2
if k % 3 != 0:
	print(i, j, k)
else:
	print(i, j + 1, k - 1)


def solve(n):
	if (n - 2) % 3 != 0:
		return (1, 1, n - 2)
	if (n - 3) % 3 != 0:
		return (1, 2, n - 3)

def main():
	n = int(input())
	print(*solve(n))
main()


n = int(input())
if (n - 2) % 3 != 0:
	a = [1, 1, n - 2]
elif (n - 2) % 3 == 0:
	a = [1, 2, n - 3]
print(*a)


a = int(input())
if a % 3 == 0 or a % 3 == 1:
	print(1, 1, a - 2)
elif a % 3 == 2:
	print(1, 2, a - 3)


import sys
input = sys.stdin.readline
ins = lambda : input().rstrip()
ini = lambda : int(input().rstrip())
inm = lambda : map(int, input().rstrip().split())
inl = lambda : list(map(int, input().split()))
out = lambda x, s='\n': print(s.join(map(str, x)))
n = ini()
if (n - 2) % 3 != 0:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


n = int(input())
if not (n - 2) % 3:
	print(1, 2, n - 3)
else:
	print(1, 1, n - 2)


N = int(input())
print(1, (N % 3 > 1) + 1, N - 2 - (N % 3 > 1))


import sys
for line in sys.stdin:
	n = int(line.rstrip())
	a = 1
	b = 1
	c = n - a - b
	if c % 3 == 0:
		b = 2
		c -= 1
	print(a, b, c)


num = int(input())
a = 1
b = 1
c = num - 2
if c % 3 == 0:
	c = c - 1
	b = 2
ans = []
ans.append(a)
ans.append(b)
ans.append(c)
for i in ans:
	print(i, end=' ')


n = int(input())
if n % 3 == 2:
	print('1 2 ' + str(n - 3))
else:
	print('1 1 ' + str(n - 2))


a = int(input())
if (a - 5) % 3 == 0:
	print(1, 2, a - 3, sep=' ')
else:
	print(1, 1, a - 2, sep=' ')


try:
	n = int(input())
	if (n - 2) % 3 != 0:
		a = 1
		b = 1
		c = n - 2
	else:
		a = 1
		b = 2
		c = n - 3
	print(a, b, c)
except EOFError:
	pass


from sys import stdin, stdout, exit

def sin():
	return stdin.readline().rstrip()

def listInput():
	return list(map(int, sin().split()))

def printBS(li):
	if not li:
		return
	for i in range(len(li) - 1):
		stdout.write('%d ' % li[i])
	stdout.write('%d\n' % li[-1])
n = int(sin())
if n % 3 == 0 or n % 3 == 1:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


n = int(input())
a1 = 1
a2 = 1
a3 = n - 2
if a3 % 3 == 0:
	a3 -= 1
	a2 += 1
print(str(a1) + ' ' + str(a2) + ' ' + str(a3))


a = int(input())
b = a - 2
if b % 3 == 0:
	print('1 2 ' + str(b - 1))
else:
	print('1 1 ' + str(b))


def output(n):
	if n == 3:
		return [1, 1, 1]
	elif n % 3 == 0 or n % 3 == 1:
		return [1, 1, n - 2]
	if n % 3 == 2:
		return [1, 2, n - 3]
n = int(input())
print(' '.join((str(i) for i in output(n))))


from sys import stdin
A = int(stdin.readline())
if A % 3 == 2:
	print(1, 2, A - 3)
else:
	print(1, 1, A - 2)


n = int(input())
i = n % 3
if i < 2:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


n = int(input())
t = n // 3
r = n % 3
if r == 0:
	print(1, 1, n - 2)
elif r == 1:
	print(1, 1, n - 2)
elif r == 2:
	print(1, 2, n - 3)


n = int(input())
if n == 3:
	print('1 1 1')
	exit()
if n % 2 == 0:
	if (n - 2) % 3 == 0:
		print('1 2', n - 3)
	else:
		print('1 1', n - 2)
elif (n - 2) % 3 == 0:
	print('1 2', n - 3)
else:
	print('1 1', n - 2)


n = int(input())
a = 1
b = 1
c = n - 2
if c % 3 == 0:
	while True:
		b += 1
		c -= 1
		if b % 3 != 0:
			if c % 3 != 0:
				print(a, b, c)
				break
else:
	print(a, b, c)


n = int(input())
for i in range(1, n):
	for j in range(1, n):
		if i % 3 != 0 and j % 3 != 0 and ((n - i - j) % 3 != 0):
			print(i, j, n - i - j)
			b = 1
			break
	if b == 1:
		break


n = int(input())
x = n % 3 or 1
print(1, x, n - x - 1)


def int_lst_input():
	return [int(val) for val in input().split(' ')]

def int_input():
	return int(input())

def print_lst(lst):
	print(' '.join([str(val) for val in lst]))

def solve():
	n = int_input()
	for a in range(n):
		if a % 3 != 0:
			for b in range(n):
				if b % 3 != 0:
					if (n - a - b) % 3 != 0:
						print(f'{a} {b} {n - a - b}')
						return
solve()


n = int(input())
k = n % 3
if k == 0 or k == 1:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


def jujk(n):
	for i in range(1, n // 2 + 2):
		if i % 3 == 0:
			continue
		for j in range(1, n // 2 + 2 - i):
			if j % 3 == 0 or (n - i - j) % 3 == 0:
				continue
			else:
				print(i, j, n - i - j)
				return
	else:
		print(-1)
n = int(input())
jujk(n)


target = int(input())
target -= 1
if (target - 1) % 3 == 0:
	print(1, 2, target - 2)
else:
	print(1, 1, target - 1)


import math
from collections import *
import sys
from functools import reduce

def get_ints():
	return map(int, input().strip().split())

def get_list():
	return list(get_ints())

def get_string():
	return list(input().strip().split())

def printxsp(*args):
	return print(*args, end='')

def printsp(*args):
	return print(*args, end=' ')
DIRECTIONS = [[0, 1], [0, -1], [1, 0], [1, -1]]
NEIGHBOURS = [(i, j) for i in range(-1, 2) for j in range(-1, 2) if i != 0 or j != 0]
OrdUnicode_a = ord('a')
OrdUnicode_A = ord('A')
CAPS_ALPHABETS = {chr(i + OrdUnicode_A): i for i in range(26)}
SMOL_ALPHABETS = {chr(i + OrdUnicode_a): i for i in range(26)}
UGLYMOD = int(1000000000.0) + 7
SEXYMOD = 998244353
MAXN = int(100000.0) + 1
INFINITY = float('inf')
n = int(input())
if (n - 2) % 3 == 0:
	print(1, 2, n - 3)
else:
	print(1, 1, n - 2)


n = int(input())
x = 2 if (n + 1) % 3 == 0 else 1
print(f'1 {x} {n - x - 1}')


z = input
n = int(z())
x = n % 3 or 1
p = n - 2 * x
print(1, x, n - 1 - x)


x = int(input())
if (x - 2) % 3 == 0:
	print(1, 2, x - 3)
else:
	print(1, 1, x - 2)


import sys

class MyReader:

	def __init__(self):
		filename = 'file.in'
		if self.isLocal():
			self.file = open(filename)
		self.str = ['']
		self.ind = 1

	def isLocal(self):
		return len(sys.argv) > 1 and sys.argv[1] == 'SCHULLZ'

	def nextString(self):
		if self.isLocal():
			return self.file.read()
		else:
			return input()

	def nextInt(self):
		return int(self.nextToken())

	def nextToken(self):
		if self.ind >= len(self.str):
			self.ind = 0
			self.str = self.nextString().split()
		self.ind += 1
		return self.str[self.ind - 1]

def Solve():
	a = -1
	try:
		a = rdr.nextInt()
	except Exception:
		return False
	if (a - 2) % 3 == 0:
		print(1, 2, a - 3)
	else:
		print(1, 1, a - 2)
	return True
rdr = MyReader()
if not rdr.isLocal():
	Solve()
else:
	while Solve():
		fgh = 1


def like_three(n):
	if n % 3 == 0:
		return (1, 1, n - 2)
	elif n % 3 == 1:
		return (1, 1, n - 2)
	return (1, 2, n - 3)
print(*like_three(int(input())))


n = int(input())
if n % 3 == 0 or n % 3 == 1:
	print('1 ' + '1 ' + str(n - 2))
else:
	print('1 ' + '2 ' + str(n - 3))


n = int(input())
b = 1 + (n % 3 > 1)
print(1, b, n - b - 1)


def print_triplet(number):
	a = 1
	if number % 3 == 2:
		b = 2
	else:
		b = 1
	print(str(a) + ' ' + str(b) + ' ' + str(number - a - b))
print_triplet(int(input()))


number = int(input())
if number % 3 <= 1:
	print(1, 1, number - 2)
else:
	print(1, 2, number - 3)


n = int(input())
print(1, 1 + (n % 3 == 2), n - 2 - (n % 3 == 2))


g = int(input())
a = 1
if g % 3 != 0:
	b = g % 3
else:
	b = 1
print(a, b, g - b - a)


def division(n):
	for a in range(1, n):
		for b in range(1, n):
			for cp in range(1, n):
				c = n - cp
				if a + b + c == n:
					if a % 3 > 0 and b % 3 > 0 and (c % 3 > 0):
						return '{} {} {}'.format(a, b, c)
				elif a + b + c < n:
					break
n = input()
print(division(int(n)))


n = int(input())
if (n - 2) % 3:
	print('1 1 {}'.format(n - 2))
else:
	print('1 2 {}'.format(n - 3))


n = int(input())
if n % 3 != 2:
	print(1, 1, n - 2, sep=' ')
elif n % 3 == 2:
	print(1, 2, n - 3, sep=' ')


q = int(input(''))
c = q - 1
print('1', end=' ')
for i in range(1, c):
	if i % 3 != 0 and (c - i) % 3 != 0:
		print(i, c - i, end=' ')
		break


t = int(input().strip())
opt1 = [1, 2, t - 3]
opt2 = [1, 1, t - 2]
if (t - 2) % 3 == 0:
	print(1, 2, t - 3)
else:
	print(1, 1, t - 2)


n = int(input())
if n == 1:
	print('1 1 1')
elif (n - 2) % 3 == 0:
	print(1, 2, n - 3, end=' ')
else:
	print(1, 1, n - 2, end=' ')


import math
import sys
DEBUG = False

def inp():
	return sys.stdin.readline().rstrip()

def dprint(*value, sep=' ', end='\n'):
	if DEBUG:
		print(*value, sep=sep, end=end)

def solve(N):
	if N % 3 < 2:
		return (1, 1, N - 2)
	return (1, 2, N - 3)

def main():
	print(*solve(int(inp())))
main()


from sys import stdin, stdout
n = int(stdin.readline())
if (n - 2) % 3 == 0:
	stdout.write('1 2 ' + str(n - 3))
else:
	stdout.write('1 1 ' + str(n - 2))


n = int(input())
abc = [1, 1, n - 2]
if abc[2] % 3 == 0:
	abc[1] += 1
	abc[2] += -1
	print(' '.join(list(map(str, abc))))
else:
	print(' '.join(list(map(str, abc))))


n = int(input())
l = [[1, 1], [1, 1], [1, 2]]
r = l[n % 3]
r.append(n - sum(r))
print(*r)


check = int(input())
print(f'{1} {1 + ((check - 2) % 3 == 0)} {check - 2 - ((check - 2) % 3 == 0)}')


n = int(input())
q = n % 3
if q == 0:
	print(1, 1, n - 2)
if q == 1:
	print(1, 1, n - 2)
if q == 2:
	print(1, 2, n - 3)


a = int(input())
if a % 3 == 0:
	b = int(1)
	c = int(1)
	d = int(a - 2)
if a % 3 == 1:
	b = 1
	c = 1
	d = a - 2
if a % 3 == 2:
	b = 1
	c = 2
	d = a - 3
print(b, c, d)


from sys import stdin
n = int(stdin.readline())
x1 = 2
x2 = 5
ans = 1
if n == 3:
	print(1, 1, 1)
	exit()
elif n == 4:
	print(1, 1, 2)
	exit()
elif n == 5:
	print(1, 2, 2)
	exit()
n -= 2
while True:
	if ans % 3 != 0 and n % 3 != 0:
		break
	if ans > n or n == 0:
		break
	ans += 1
	n -= 1
print(1, ans, n)


a = int(input())
if a % 3 != 2:
	print('1 1', a - 2, sep=' ')
else:
	print('1 2', a - 3, sep=' ')


n = int(input())
print(1, end=' ')
i = 1
while True:
	if i % 3 != 0 and (n - (i + 1)) % 3 != 0:
		print(i, n - (i + 1))
		break
	else:
		i = i + 1


T_ON = 0
DEBUG_ON = 0
MOD = 998244353

def solve():
	n = read_int()
	if n % 3 == 2:
		print(1, 2, n - 3)
	else:
		print(1, 1, n - 2)

def main():
	T = read_int() if T_ON else 1
	for i in range(T):
		solve()

def debug(*xargs):
	if DEBUG_ON:
		print(*xargs)
from collections import *
import math
import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def read_int():
	return int(input())

def read_ints():
	return list(map(int, input().split()))

def print_nums(nums):
	print(' '.join(map(str, nums)))

def YES():
	print('YES')

def Yes():
	print('Yes')

def NO():
	print('NO')

def No():
	print('No')

def First():
	print('First')

def Second():
	print('Second')

def fib(n):
	(a, b) = (0, 1)
	for _ in range(n):
		(a, b) = (b, a + b)
	return a

def fib_ns(n):
	assert n >= 1
	f = [0 for _ in range(n + 1)]
	f[0] = 0
	f[1] = 1
	for i in range(2, n + 1):
		f[i] = f[i - 1] + f[i - 2]
	return f

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def xgcd(a, b):
	(x0, x1, y0, y1) = (0, 1, 1, 0)
	while a != 0:
		((q, a), b) = (divmod(b, a), a)
		(y0, y1) = (y1, y0 - q * y1)
		(x0, x1) = (x1, x0 - q * x1)
	return (b, x0, y0)

def lcm(a, b):
	d = gcd(a, b)
	return a * b // d

def modinv(a, m):
	(g, x, _) = xgcd(a, m)
	if g != 1:
		raise Exception('gcd(a, m) != 1')
	return x % m

def mod_add(x, y):
	x += y
	while x >= MOD:
		x -= MOD
	while x < 0:
		x += MOD
	return x

def mod_mul(x, y):
	return x * y % MOD

def mod_pow(x, y):
	if y == 0:
		return 1
	if y % 2:
		return mod_mul(x, mod_pow(x, y - 1))
	p = mod_pow(x, y // 2)
	return mod_mul(p, p)

def mod_inv(y):
	return mod_pow(y, MOD - 2)

def mod_div(x, y):
	return mod_mul(x, mod_inv(y))

def is_prime(n):
	if n == 1:
		return False
	for i in range(2, int(n ** 0.5) + 1):
		if n % i:
			return False
	return True

def gen_primes(n):
	P = [True for _ in range(n + 1)]
	P[0] = P[1] = False
	for i in range(int(n ** 0.5) + 1):
		if P[i]:
			for j in range(2 * i, n + 1, i):
				P[j] = False
	return P
main()


from decimal import Decimal, localcontext
import math
z = int(input())
if math.fmod(z - 2, 3) != 0:
	print(1, 1, z - 2)
elif math.fmod(z - 3, 3) != 0:
	print(1, 2, z - 3)


x = int(input())
if x % 3 == 2:
	print('1 2 ' + str(x - 3))
else:
	print('1 1 ' + str(x - 2))


import sys
input = sys.stdin.readline
n = int(input())
if n % 3 == 2:
	print(1, 2, n - 3)
else:
	print(1, 1, n - 2)


n = int(input())
a = 1 + (n % 3 > 1)
print(1, a, n - a - 1)


MOD = 10 ** 9 + 7
I = lambda : list(map(int, input().split()))
(n,) = I()
if (n - 2) % 3 == 0:
	print(1, 2, n - 3)
	exit()
print(1, 1, n - 2)


n = int(input())
flag = False
for i in range(1, 3):
	if flag:
		break
	for j in range(1, 3):
		if (n - i - j) % 3 != 0:
			print(i, j, n - i - j)
			flag = True
			break


n = int(input())
a = 1
for b in [1, 2]:
	c = n - a - b
	if c % 3:
		print('%d %d %d' % (a, b, c))
		break


def divi(n):
	if (n - 2) % 3 != 0:
		print(1, 1, n - 2)
	else:
		print(1, 2, n - 3)
n = int(input())
divi(n)


a = int(input())
e = 2
d = a - e
l = []
if d % 3 == 0:
	e = 3
if e == 3:
	l = [1, 2, a - 3]
else:
	l = [1, 1, a - 2]
print(*l)


n = int(input())
i1 = 1
i2 = 1
i3 = n - 2
if i3 % 3 == 0:
	i2 = 2
	i3 = i3 - 1
print('{} {} {}'.format(i1, i2, i3))


from collections import Counter
for _ in range(1):
	n = int(input())
	if n % 3 == 0:
		print(1, 1, n - 2)
	elif n % 3 == 1:
		print(1, 1, n - 2)
	else:
		print(1, 2, n - 3)


n = int(input())
if n % 3 == 0 or n % 3 == 1:
	print(1, 1, n - 2)
elif n % 3 == 2:
	print(1, 2, n - 3)


n = int(input())
(x1, x2) = (1, 1)
x3 = n - x1 - x2
if x3 % 3 == 0:
	x2 = 2
	x3 -= 1
print(x1, x2, x3)


n = int(input())
a = 1
b = 1
c = n - 2
if c % 3 == 0:
	b = b + 1
	c = c - 1
else:
	pass
print('%d %d %d' % (a, b, c))


from sys import stdin, stdout

def main():
	a = int(input())
	for i in range(1, a):
		for j in range(1, a):
			k = a - i - j
			if i % 3 and j % 3 and k % 3:
				print(i, j, k)
				exit()
main()


n = int(input())
if n == 3:
	print('1 1 1')
elif n == 4:
	print('1 1 2')
elif n % 3 == 1:
	print('1 1', str(n - 2))
elif n % 3 == 2:
	print('1 2', str(n - 3))
else:
	print('1 1', str(n - 2))


x = int(input())
a = b = c = 0
if x % 3 == 0:
	a = 1
	b = 1
	c = x - (a + b)
elif x % 3 == 1:
	a = 1
	b = 1
	c = x - (a + b)
elif x % 3 == 2:
	a = 1
	b = 2
	c = x - 3
print('{} {} {}'.format(a, b, c))


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
if (n - 2) % 3 != 0:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


n = int(input())
n = n - 2
x = 1
if n % 3 == 0:
	x += 1
	n -= 1
print('1', x, n)


n = int(input())
for i in range(1, 3):
	for j in range(1, 3):
		if (n - i - j) % 3 != 0:
			print(i, j, n - i - j)
			exit(0)


num = int(input())
(a, b) = (1, 1)
c = num - a - b
while a % 3 == 0 or b % 3 == 0 or c % 3 == 0:
	if a == b and a % 3 != 2:
		(b, c) = (b + 1, c - 1)
	elif a != b and a % 3 != 2:
		(a, c) = (a + 1, c - 1)
	elif a == b and a % 3 == 2:
		(a, b, c) = (a + 2, b + 2, c - 4)
print(str(a) + ' ' + str(b) + ' ' + str(c))


from sys import stdin
input = lambda : stdin.readline()

def main():
	N = int(input())
	a = 1
	if (N - 2) % 3:
		(b, c) = (1, N - 2)
	else:
		(b, c) = (2, N - 3)
	print(a, b, c)
main()


n = int(input())
for a in range(1, 3):
	for b in range(1, 3):
		if (n - a - b) % 3 != 0 and n - a - b > 0:
			print(a, b, n - a - b)
			exit(0)


n = int(input())
b = n % 3
while b % 3 == 0:
	b = b + 1
print(1, b, n - b - 1)


t = int(input())
if (t - 2) % 3 != 0:
	print(1, 1, t - 2)
elif (t - 3) % 3 != 0:
	print(1, 2, t - 3)
else:
	print(2, 2, t - 4)


n = int(input())
a = 1
b = 1
c = n - 2
while c % 3 == 0:
	b += 1
	c = n - 1 - b
print(a, b, c)


n = int(input())
(a, b, c) = (1, max(1, n % 3), n - 1 - max(1, n % 3))
print(a, b, c)


from math import *
from collections import *

def inp():
	return map(int, input().split())

def inp_arr():
	return list(map(int, input().split()))
n = int(input())
res = []
if (n - 2) % 3:
	res.extend([1, 1, n - 2])
else:
	res.extend([1, 2, n - 3])
print(*res)


n = int(input())
if n % 3 == 2:
	print(f'1 2 {n - 3}')
else:
	print(f'1 1 {n - 2}')


n = int(input())
(w, e) = divmod(n, 3)
if e == 0 or e == 1:
	print(1, 1, n - 2)
else:
	print(1, 2, n - 3)


import sys
number = int(sys.stdin.readline())
result = [1, 1, 0]
result[2] = number - result[0] - result[1]
if result[2] % 3 == 0:
	result[1] += 1
	result[2] -= 1
print(*sorted(result))


s = int(input())
a = b = 1
c = s - 2
if c % 3 == 0:
	b = 2
	c = c - 1
print(a, b, c)


def getThreeNum(nNum):
	nAddNum1 = 1
	nAddNum2 = 1
	nAddNum3 = nNum - nAddNum1 - nAddNum2
	if nAddNum3 % 3 == 0:
		del nAddNum2
		nAddNum2 = 2
		nAddNum3 -= 1
	print(nAddNum1, nAddNum2, nAddNum3)
nNum = int(input())
getThreeNum(nNum)


from sys import stdin
from collections import deque
mod = 10 ** 9 + 7
from bisect import bisect_right
from bisect import bisect_left
from collections import defaultdict
from math import sqrt, factorial, gcd, log2, inf, ceil
n = int(input())
a = 1
b = 1
c = n - 2
if c % 3 != 0:
	print(a, b, c)
else:
	print(1, 2, n - 3)


val = int(input())
if (val - 2) % 3:
	print(1, 1, val - 2)
else:
	print(1, 2, val - 3)


import random
n = int(input())
x = 1
y = 1
z = n - 2
if z % 3 == 0:
	z = n - 3
	y = 2
print(x, y, z)


n = int(input())
if n % 3 == 2:
	b = 2
else:
	b = 1
print(1, b, n - b - 1)


from sys import exit

def f(a, b, n):
	n -= a + b
	if n > 0 and n % 3 != 0:
		print(a, b, n)
		exit(0)
n = int(input())
f(1, 1, n)
f(1, 2, n)


def prog():
	n = int(input())
	if (n - 2) % 3 == 0:
		print(1, 2, n - 3)
	else:
		print(1, 1, n - 2)
prog()


n = int(input())

def solve(n):
	(a, b) = (1, 1)
	if (n - 2) % 3 != 0:
		return str(a) + ' ' + str(b) + ' ' + str(n - 2)
	else:
		c = 2
		while (n - c) % 3 == 0:
			if b % 3 == 0:
				continue
			else:
				c += 1
				b += 1
				n = n - c
		return str(a) + ' ' + str(b) + ' ' + str(n)
print(solve(n))


a = int(input())
i = 1
j = 1
k = a - 2
if k % 3 != 0:
	print(i, j, k)
else:
	j = j + 1
	k = k - 1
	print(i, j, k)


a = int(input())
if (a - 2) % 3 != 0:
	p = q = 1
	r = a - 2
elif (a - 2) % 3 == 0:
	p = 1
	q = 2
	r = a - 3
print(int(p), int(q), int(r))


import os
import sys
n = int(sys.stdin.readline())
if n % 3 != 2:
	sys.stdout.write('{0} {1} {2}'.format(1, 1, n - 2))
else:
	sys.stdout.write('{0} {1} {2}'.format(1, 2, n - 3))


num = [1, 1, 1]
num[2] = int(input()) - 2
rem = num[2] % 3
if rem == 0:
	num[2] -= 1
	num[1] += 1
print(*num, sep=' ')


num = input()
num = int(num)
if num % 3 != 2:
	print(1, 1, num - 2)
else:
	print(1, 2, num - 3)


import math, sys
from itertools import permutations

def mp():
	return list(map(int, input().split()))
debug = 0
if debug:
	file = open('input.txt', 'r')
	input = file.readline
else:
	input = sys.stdin.readline

def main():
	n = int(input())
	if n % 3 != 2:
		print(1, 1, n - 2)
	else:
		print(1, 2, n - 3)
main()


n = int(input())
print(1, end=' ')
for i in range(1, n - 1):
	if (n - i - 1) % 3 != 0 and i % 3 != 0:
		print(i, n - i - 1)
		break


def f(n):
	for i in range(1, 10 ** 9 + 1):
		if i % 3 != 0:
			for j in range(1, 10 ** 9 + 1):
				if j % 3 != 0:
					z = n - (i + j)
					if z % 3 != 0:
						return [i, j, z]
n = int(input())
print(*f(n))


import sys
input = sys.stdin.readline
n = int(input())
(a, b, c) = (1, 1, 1)
if (c + n - 3) % 3 == 0:
	c += n - 4
	b += 1
else:
	c += n - 3
print(a, b, c)


import sys
from math import sqrt, floor, factorial
from collections import deque, Counter
inp = sys.stdin.readline
read = lambda : list(map(int, inp().strip().split()))

def solve():
	n = int(inp())
	print(*[[1, 2, n - 3], [1, 1, n - 2]][not n % 3 == 2])
solve()


n = int(input())
if n % 3 == 0 or n % 3 == 1:
	print(1, 1, n - 2, end='')
else:
	print(1, 2, n - 3, end='')


N = int(input())
if (N - 2) % 3 != 0:
	print(1, 1, N - 2)
elif (N - 3) % 3 != 0:
	print(1, 2, N - 3)


inp = int(input())
if inp % 3 == 0 or inp % 3 == 1:
	print(1, 1, inp - 2)
else:
	print(1, 2, inp - 3)


n = int(input())
m = n % 3 or 1
print(1, m, n - 1 - m)


N = int(input())
print(1, 1, N - 2) if N % 3 < 2 else print(1, 2, N - 3)


from sys import stdin, stdout
from collections import Counter

def ai():
	return list(map(int, stdin.readline().split()))

def ei():
	return map(int, stdin.readline().split())

def ip():
	return int(stdin.readline().strip())

def op(ans):
	return stdout.write(str(ans) + '\n')
n = ip()
if n == 3:
	print(1, 1, 1)
else:
	x = [1, 1, n - 2]
	if x[2] % 3 == 0:
		x[1] += 1
		x[2] -= 1
	print(*x)


def find_ans(n):
	for x in range(1, n + 1):
		if x % 3 != 0:
			num1 = x
			for y in range(1, n - num1):
				if y % 3 != 0:
					num2 = y
					if (n - num1 - num2) % 3 != 0:
						return [num1, num2, n - num1 - num2]
n = int(input())
a = find_ans(n)
print(a[0], a[1], a[2])


n = int(input())
if n == 3:
	print(' '.join(['1'] * 3))
elif (n - 2) % 3 == 0:
	print('1 2 ' + str(n - 3))
else:
	print('1 1 ' + str(n - 2))


def main():
	d = int(input())
	if d % 2 == 0:
		a = 1
		b = 1
		c = d - a - b
		if c % 3 != 0:
			print(a, b, c)
		else:
			print(a, 2, c - 1)
	else:
		a = 1
		b = 1
		c = d - a - b
		if c % 3 != 0:
			print(a, b, c)
		else:
			print(a, 2, c - 1)
main()


import math
import itertools
from sys import stdin
from functools import reduce
from collections import deque
from sys import setrecursionlimit
from collections import defaultdict
setrecursionlimit(10 ** 5)
input = stdin.readline

def I():
	return int(input())

def IN():
	return map(int, input().split())

def LI():
	return list(map(int, input().split()))

def LIN(N):
	return [list(map(int, input().split())) for _ in range(N)]

def solve():
	n = I()
	if (n - 2) % 3 != 0:
		print(1, 1, n - 2)
	else:
		print(1, 2, n - 3)

def main():
	t = 1
	while t:
		t -= 1
		solve()
main()


c = int(input())
a1 = 1
a2 = 1
b = c - 2
a3 = b
if b % 3 == 0:
	a2 = a2 + 1
	a3 = b - 1
print(a1, a2, a3)


n = int(input())
f = False
for i in range(1, n + 1):
	if f:
		break
	for j in range(1, n - i):
		c = n - i - j
		if i % 3 != 0 and j % 3 != 0 and (c % 3 != 0):
			print(i, j, c)
			f = True
			break


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	if (n - 2) % 3 == 0:
		return str(1) + ' ' + str(2) + ' ' + str(n - 3)
	return str(1) + ' ' + str(1) + ' ' + str(n - 2)
print(main())


number = int(input())
a = 1
b = 1
c = number - 2
if c % 3 == 0:
	b = 2
	c = c - 1
print(a, b, c)


n = int(input())
x = max(n % 3, 1)
p = n - x - 1
print(1, x, p)


n = int(input())
c = 1
d = 1
n = n - (c + d)
count = 0
if n % 3 == 0:
	n = n - 1
	c += 1
print(d, c, n)


import math
n = int(input())
a = 1
b = 1
c = n - 2
if c % 3 == 0:
	b = 2
	c = n - 3
print('{} {} {}'.format(a, b, c))


from collections import deque
import math
import os
import random
import re
import sys

def main():
	t = int(input())
	if (t - 2) % 3:
		print('1 1', t - 2)
	else:
		print('1 2', t - 3)
main()


import math as ma
import sys
from sys import exit
from decimal import Decimal as dec
from itertools import permutations

def li():
	return list(map(int, input().split()))

def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x

def num():
	return map(int, input().split())

def nu():
	return int(input())

def find_gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
n = nu()
x = n - 2
y = n - 3
if x % 3 != 0:
	print(1, 1, x)
else:
	print(1, 2, y)


n = int(input())
li = []
for i in range(1, 4):
	if i == 3:
		if (n - 2) % 3 != 0:
			li.append(n - 2)
		else:
			li.append(n - 3)
			li[-2] = li[-2] + 1
	else:
		li.append(1)
print(*li)


n = int(input())
if n % 3 == 2:
	print('1 2 %d' % (n - 3))
else:
	print('1 1 %d' % (n - 2))


def go():
	n = int(input())
	a = 1
	b = 1
	c = n - 2
	while a % 3 == 0 or b % 3 == 0 or c % 3 == 0:
		if c % 3 == 0:
			c -= 1
			b += 1
		elif b % 3 == 0:
			b -= 1
			a += 1
		else:
			a -= 1
			if (c + 1) % 3 == 0:
				b += 1
			else:
				c += 1
	return '{} {} {}'.format(a, b, c)
print(go())


def solve(n):
	for i in range(1, n + 1):
		for j in range(i, n + 1):
			if i + j > n:
				break
			c = n - (i + j)
			if i + j + c == n and i % 3 != 0 and (j % 3 != 0) and (c % 3 != 0) and (c > 0):
				return (i, j, n - (i + j))

def main():
	n = int(input())
	print(*solve(n))
main()


def main():
	n = int(input())
	if n % 3 == 2:
		print(1, 2, n - 3)
	else:
		print(1, 1, n - 2)
main()


x = int(input())
if (x - 2) % 3 != 0:
	print(1, 1, x - 2)
elif (x - 3) % 3 != 0:
	print(1, 2, x - 3)


def f(n):
	if n % 3 in [0, 1]:
		ans = [1, 1, n - 2]
	else:
		ans = [1, 2, n - 3]
	return ans
n = int(input())
print(*f(n))


a = int(input())
for i in range(1, a - 1):
	for j in range(1, a - i):
		if i % 3 != 0 and j % 3 != 0 and ((a - i - j) % 3 != 0):
			print(i, j, a - i - j)
			exit()


def main():
	n = int(input())
	first_value = 1
	second_value = 1
	third_value = n - first_value - second_value
	while third_value % 3 == 0 or second_value % 3 == 0:
		second_value = second_value + 1
		third_value = third_value - 1
	print(str(first_value) + ' ' + str(second_value) + ' ' + str(third_value))
	return
main()


n = int(input())
if n == 3:
	print(1, 1, 1)
else:
	A = 1
	B = 1
	C = n - (A + B)
	if C % 3 == 0:
		C = C - 1
		B += 1
	print(A, B, C)


def sum_of_digits(n):
	ans = 0
	while n != 0:
		ans += n % 10
		n = n // 10
	return ans
n = int(input())
(a, b, c) = (1, 1, n - 2)
if sum_of_digits(c) % 3 == 0:
	(b, c) = (2, n - 3)
print(a, b, c)


read_numbers = lambda : list(map(int, input().split()))
INF = 1 << 64
n = int(input())
for i in range(1, 3):
	for j in range(1, 3):
		m = n - i - j
		if m % 3 != 0:
			print(i, j, m)
			exit(0)


n = int(input())
flag = 0
for i in range(1, n):
	if i % 3 == 0:
		continue
	for j in range(i, n - i):
		if j % 3 == 0:
			continue
		if i % 3 != 0 and j % 3 != 0 and ((n - i - j) % 3 != 0):
			print(i, j, n - i - j)
			flag = 1
		if flag == 1:
			break
	if flag == 1:
		break


n = int(input())
if n % 3 == 0:
	print(f'1 1 {n - 2}')
elif n % 3 == 1:
	print(f'1 1 {n - 2}')
else:
	print(f'1 2 {n - 3}')