Problem:
 Score : 300 points    Problem Statement You are given an integer N .  Find a triple of positive integers h , n and w such that 4/N = 1/h + 1/n + 1/w .  If there are multiple solutions, any of them will be accepted.      Constraints  It is guaranteed that, for the given integer N , there exists a solution such that h,n,w \leq 3500 .         Inputs Input is given from Standard Input in the following format:  N       Outputs Print a triple of positive integers h , n and w that satisfies the condition, in the following format:  h  n  w         Sample Input 1 2      Sample Output 1 1 2 2  4/2 = 1/1 + 1/2 + 1/2 .       Sample Input 2 3485      Sample Output 2 872 1012974 1539173474040  It is allowed to use an integer exceeding 3500 in a solution.       Sample Input 3 4664      Sample Output 3 3498 3498 3498

Solution (Python):
n = int(input())

for i in range(1,3501):
    for j in range(1,3501):
        if (4*i*j-n*i-n*j) != 0:
            w = i*j*n/(4*i*j-n*i-n*j)
            if w%1 == 0 and w > 0:
                print(i,j,int(w))
                exit()

Solution (Python):
N = int(input())
for h in range(1,3501):
  for n in range(1,3501):
    bs = 4*h*n - N*n -N*h
    if bs > 0 and (N*h*n)%bs == 0:
      print(h,n,N*h*n//bs)
      exit()

Solution (Python):
N = int(input())
for h in range(1, 3501):
  for n in range(1, 3501):
    div = 4*h*n-N*(h+n)
    if div > 0 and N*h*n%div == 0:
      print(h, n, N*h*n//div)
      exit()

Solution (Python):
import sys
N = int(input())
for h in range(1,3501):
    for w in range(1,3501):
        if 4*h*w - N*(w+h) > 0:
            if N*h*w / (4*h*w - N*(w+h)) % 1 == 0:
                print(h,w,int(N*h*w / (4*h*w - N*(w+h))))
                sys.exit()

Solution (Python):
import sys

def cal():
    N = int(input())

    for i in range(1, 3501):
        for j in range(1, 3501):
            num0 = 4*i*j-N*(i+j) 
            if num0 != 0:
                num = N*i*j/num0
                if num.is_integer() and 0 < num <= 3500:
                    print(i, int(num), j)
                    sys.exit()

cal()

Solution (Python):
N = int(input())
for h in range(1, 3501):
    for n in range(1, 3501):
        numera = 4 * h * n - n * N - h * N
        denomi = h * n * N
        if numera <= 0:
            continue
        elif denomi % numera != 0:
            continue
        w = denomi // numera
        print(h, n, w)
        exit()

Solution (Python):
import sys



def input():
    return sys.stdin.readline().strip()


def input_int():
    return int(input())


def input_int_list():
    return [int(i) for i in input().split()]


def main():
    n = input_int()
    for a in range(1, 3501):
        for b in range(1, 3501):
            if 4 * a * b - n * b - n * a == 0:
                continue
            c = (n * a * b) // (4 * a * b - n * b - n * a)
            if c < 1:
                continue
            if 4 * a * b * c == n * (a * b + b * c + c * a):
                print(a, b, c)
                return
    return


if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())

ans = None
for h in range(1, 3501):
  for n in range(1, 3501):
    if 4*h*n - n*N - h*N != 0:
      w = (N * h * n) / (4*h*n - n*N - h*N)
      if w > 0 and w.is_integer() and 4/N == 1/h + 1/n + 1/w:
        ans = [h, n, int(w)]
        break
  if ans:
    break
print(" ".join(map(str, ans)))

Solution (Python):
N = int(input())

for h in range(1, 3501):
    for n in range(h, 3501):
        a = N*h*n
        b = 4*h*n - N*n - N*h
        if not b:
            continue
        if a%b == 0 and a//b > 0:
            print(h, n, a//b)
            exit()

Solution (Python):
N = int(input())
for m in range(int(N/4+1), 3501):
  for n in range(m, 3501):
    if 4 * m * n - N * n - N * m == 0:
      h = -10**10
    else:
      h = m * N * n / (4 * m * n - N * n - N * m)
    if h == int(h) and 0 <= h <= 3500:
      print(int(h),m,n)
      exit()

Solution (Python):






N = int(input())





for h in range(1,3500+1):
    for n in range(h,3500+1):
        tmp = 4*h*n - N*n - N*h
        if tmp > 0 and (N*h*n)%tmp == 0:
            w = (N*h*n)//tmp
            print(h,n,w)
            break
    else:
        continue
    break

Solution (Python):
def main():
    N = int(input())
    for n in range(1, 3501):
        for h in range(1, 3501):
            denom = 4*n*h - N*n - N*h
            if denom == 0:
                continue
            w = (N*h*n) / denom
            if w == int(w) and w > 0:
                print(int(n), int(h), int(w))
                return
    
if __name__ == "__main__":
    main()

Solution (Python):
N = int(input())
A,B,C = 0,0,0
for TA in range(1,3501):
    for TB in range(1,3501):
        Numer = TA*TB*N
        Denom = 4*TA*TB-(TA+TB)*N
        if Denom>0 and Numer>0 and Numer%Denom==0:
            A = TA
            B = TB
            C = Numer//Denom
print('{} {} {}'.format(A,B,C))

Solution (Python):
n=int(input())
for i in range(3500):
    for j in range(3500):
        if 4*i*j-n*(i+j)>0 and n*i*j%(4*i*j-n*(i+j))==0:
            print(i,j,n*i*j//(4*i*j-n*(i+j)))
            exit()

Solution (Python):
n=int(input())
for i in range(3500):
    for j in range(3500):
        if 4*i*j-n*(i+j)>0 and n*i*j%(4*i*j-n*(i+j))==0:
            print(i,j,n*i*j//(4*i*j-n*(i+j)))
            exit()

Solution (Python):
n=int(input())
for i in range(3500):
    for j in range(3500):
        if 4*i*j-n*(i+j)>0 and n*i*j%(4*i*j-n*(i+j))==0:
            print(i,j,n*i*j//(4*i*j-n*(i+j)))
            exit()

Solution (Python):

def resolve():
    nnn = int(input())
    for h in range(1, 3501):
        for w in range(1, 3501):
            div = 4 * h * w - nnn * h - nnn * w
            if div == 0:
                continue
            n = nnn * h * w / div
            if int(n) == n and 0 < n:
                print(h, w, int(n))
                return

if __name__ == "__main__":
    resolve()

Solution (Python):
N = int(input())
for h in range(1,3500):
    for n in range(1,3500):
        flg = False
        try:
            w = (N*h*n)/(4*h*n-N*n-N*h)
            if w >= 0 and w.is_integer():
                flg = True
        except:
            pass
        if flg:
            print(h,n,int(w))
            exit(0)

Solution (Python):
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq

N = ni()
mx = 3501
for w in range(1,mx):
    for h in range(1,mx):
        t1=N*w*h
        t2=4*w*h-N*h-N*w
        if t2<=0:continue
        if t1%t2==0:
            print(h,w,t1//t2)
            exit()

Solution (Python):
N=int(input())
ans=next([x,y,N*x*y//(4*x*y-N*(x+y))]for x in range(1,3501)for y in range(1,3501)if 4*x*y>N*(x+y) and (N*x*y)%(4*x*y-N*(x+y))==0)
print(*ans)

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N = int(readline())

    for h in range(1, 3501):
        for n in range(1, 3501):
            denom = 4 * h * n - N * n - N * h
            numer = N * h * n
            if denom > 0 and numer % denom == 0:
                print(h, n, numer // denom)
                return

    return


if __name__ == '__main__':
    main()

Solution (Python):
import sys
from sys import exit
from collections import deque
from copy import deepcopy
from bisect import bisect_left, bisect_right, insort_left, insort_right
from heapq import heapify, heappop, heappush
from itertools import product, permutations, combinations, combinations_with_replacement
from functools import reduce
from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians

sys.setrecursionlimit(10**6)
INF = 10**20
eps = 1.0e-20
MOD = 10**9+7

def lcm(x,y):
    return x*y//gcd(x,y)
def lgcd(l):
    return reduce(gcd,l)
def llcm(l):
    return reduce(lcm,l)
def powmod(n,i,mod=MOD):
    return pow(n,mod-1+i,mod) if i<0 else pow(n,i,mod)
def div2(x):
    return x.bit_length()
def div10(x):
    return len(str(x))-(x==0)
def intput():
    return int(input())
def mint():
    return map(int,input().split())
def lint():
    return list(map(int,input().split()))
def ilint():
    return int(input()), list(map(int,input().split()))
def judge(x, l=['Yes', 'No']):
    print(l[0] if x else l[1])
def lprint(l, sep='\n'):
    for x in l:
        print(x, end=sep)
def ston(c, c0='a'):
    return ord(c)-ord(c0)
def ntos(x, c0='a'):
    return chr(x+ord(c0))
class counter(dict):
    def __init__(self, *args):
        super().__init__(args)
    def add(self,x,d=1):
        self.setdefault(x,0)
        self[x] += d
    def list(self):
        l = []
        for k in self:
            l.extend([k]*self[k])
        return l
class comb():
    def __init__(self, n, mod=None):
        self.l = [1]
        self.n = n
        self.mod = mod
    def get(self,k):
        l,n,mod = self.l, self.n, self.mod
        k = n-k if k>n//2 else k
        while len(l)<=k:
            i = len(l)
            l.append(l[i-1]*(n+1-i)//i if mod==None else (l[i-1]*(n+1-i)*powmod(i,-1,mod))%mod)
        return l[k]
def pf(x,mode='counter'):
    C = counter()
    p = 2
    while x>1:
        k = 0
        while x%p==0:
            x //= p
            k += 1
        if k>0:
            C.add(p,k)
        p = p+2-(p==2) if p*p<x else x
    if mode=='counter':
        return C
    S = set([1])
    for k in C:
        T = deepcopy(S)
        for x in T:
            for i in range(1,C[k]+1):
                S.add(x*(k**i))
    if mode=='set':
        return S
    if mode=='list':
        return sorted(list(S))



N=intput()
for h,n in product(range(1,3501),repeat=2):
    if 4*h*n-N*(h+n)==0:
        continue
    w=N*h*n//(4*h*n-N*(h+n))
    if 0<w<=3500 and (4*h*n-N*(h+n))*w==N*h*n:
        print(h,n,w)
        exit()

Solution (Python):

import sys

sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


sys.setrecursionlimit(10**7)
import math








INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7


def run():
    N = int(input())
    for h in range(1, 3501):
        if 4 * h - N <= 0:
            continue
        s = math.ceil(N * h / (4 * h - N))
        for n in range(s, 3501):
            v = N * h * n
            a = 4 * h * n - N * n - N * h
            if a <= 0:continue
            if not v % a:
                w = v // a
                print(f'{h} {n} {w}')
                return

if __name__ == "__main__":
    run()

Solution (Python):

import sys

sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read


sys.setrecursionlimit(10**7)
import math








INF = 1 << 50
EPS = 1e-8
mod = 10 ** 9 + 7


def run():
    N = int(input())
    for h in range(1, 3501):
        for n in range(1, 3501):
            v = N * h * n
            a = 4 * h * n - N * n - N * h
            if a <= 0:continue
            if not v % a:
                w = v // a
                print(f'{h} {n} {w}')
                return

if __name__ == "__main__":
    run()

Solution (Python):
import math
n=int(input())
def s_bunkai(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])
    if temp!=1:
        arr.append([temp, 1])
    if arr==[]:
        arr.append([n, 1])
    return arr
if n%2==0:
    print(n,n,n//2)
else:
    num=s_bunkai(n)
    num2=num[0][0]
    if (num2+1)%4==0:
        num3=(num2*2+2)//4
        num4=n*num3
        print(num4//2,num4//num2,num4//num2)
    else:
        yn=0
        for i in range(len(num)):
            if num[i][0]%4==3:
                num2=num[i][0]
                yn=1
                break
        if yn==1:
            num3=(num2*2+2)//4
            num4=n*num3
            print(num4//2,num4//num2,num4//num2)
        else:
            yn=0
            for i in range(n//4,3501):
                for j in range(i,3501):
                    num5=(i*j)//math.gcd(i,j)
                    if num5%n==0:
                        num6=(num5//n)*4
                        num7=num6-(num5//i)-(num5//j)
                        if num5%num7==0 and num7>0:
                            print(i,j,num5//num7)
                            yn=1
                            break
                if yn==1:
                    break

Solution (Python):
N = int(input())

L = 3500 + 1

for h in range(1, L):
    for n in range(1, h + 1):
        x = N * h * n
        y = 4 * h * n - N * (n + h)
        if y <= 0:
            continue
        if x % y == 0:
            w = x // y
            print(h, n, w)
            exit(0)

Solution (Python):



import sys

N = int(input())

for h in range(1, 3501):
    for n in range(1, 3501):
        divisor = (4*h*n - N*h - N*n)
        if divisor <= 0:
            continue
        if (N*h*n) % divisor == 0:
            m = (N * h * n) // divisor
            print(h, n, m)
            sys.exit(0)

Solution (Python):
N=int(input())

for h in range(1,3501):
    for n in range(1,3501):
        if 4*n*h>N*(h+n) and N*n*h%(4*n*h-N*(h+n))==0:
            w=N*n*h//(4*n*h-N*(h+n))
            print('{} {} {}'.format(h,n,w))
            exit(0)

Solution (Python):
N = int(input())

if N % 2 == 0:
  print(N//2, N, N)
else:
  for i in range(1, N):
    if N < 4*i:
      n = 4*i - N
      break
  if n == 1:
    j, k = 2*N*i, 2*N*i
  else:
    if i % 3 == 0:
      j, k = 2*N*i//3, 2*N*i//3
    else:
      for x in range(100):
        flag = False
        for y in range(1, n//2+1):
          if ((N*i)%y==0) and ((N*i)%(n-y)==0):
            j = (N*i) // y
            k = (N*i) // (n-y)
            flag = True
            break
        if flag:
          break
        else:
          i += 1
          n += 4
  print(i, j, k)

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from numba import njit

def main():
    N = int(input())
    @njit
    def solve(N):
        for h in range(1, 3501):
            for n in range(1, 3501):
                shisu = h * N * n
                bosu = n * (h * 4 - N) - h * N
                if bosu >= 1 and not (shisu / bosu) % 1:
                    return h, n , int((h * N * n) / (n * (h * 4 - N) - h * N))
    r = solve(N)
    print(*r , sep=' ')

if __name__ == '__main__':
    main()

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from numba import njit

def main():
    N = int(input())
    @njit
    def solve(N):
        for h in range(1, 3501):
            for n in range(1, 3501):
                shisu = h * N * n
                bosu = n * (h * 4 - N) - h * N
                if bosu >= 1:
                    if not (shisu / bosu) % 1:
                        return h, n , int((h * N * n) / (n * (h * 4 - N) - h * N))
    r = solve(N)
    print(*r , sep=' ')

if __name__ == '__main__':
    main()

Solution (Python):
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines

def main():
    N = int(input())
    for h in range(1, 3501):
        for n in range(1, 3501):
            shisu = h * N * n
            bosu = n * (h * 4 - N) - h * N
            if bosu >= 1:
                if not (shisu / bosu) % 1:
                    print(h, n , int((h * N * n) / (n * (h * 4 - N) - h * N)))
                    sys.exit()

if __name__ == '__main__':
    main()

Solution (Python):
N=int(input())
for h in range(1,3501):
  for n in range(1,3501):
    if 4*h*n-N*n-N*h!=0:
      w=(N*n*h)/(4*h*n-N*n-N*h)
      if int(w)==w and w>0:
        print(h,n,int(w))
        exit()

Solution (Python):
N = int(input())
mx = 3503
found = False
for i in range(1, mx):
    for j in range(1, mx):
        if i*j*4 % N != 0:
            continue
        den = ((i*j*4)//N) - i - j
        num = i*j
        if den == 0:
            continue
        if num%den == 0 and num//den > 0 and num//den < mx:
            print(i,j,num//den)
            found = True
            break
    if found:
        break

Solution (Python):
import sys, math
from functools import lru_cache
from collections import defaultdict
from decimal import Decimal
sys.setrecursionlimit(10**9)
MOD = 10**9+7

def input():
    return sys.stdin.readline()[:-1]

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

def ii():
    return int(input())

def i2(n):
    tmp = [list(mi()) for i in range(n)]
    return [list(i) for i in zip(*tmp)]

def main():
    N = ii()
    for h in range(1, 3501):
        for n in range(1, 3501):
            if (4*h*n) - N*n - N*h == 0:
                continue
            w = N*h*n/((4*h*n) - N*n - N*h)
            if w.is_integer() and w > 0:
                print(h, n, int(w))
                return

if __name__ == '__main__':
    main()

Solution (Python):
def main():
    N = int(input())
    for h in range(1, 3501):
        denominator = 4*h - N
        numerator = N*h
        if denominator > 0:
            n = (numerator//denominator) + 1
            denominator = 4*h*n - N*(h+n)
            numerator = N*h*n
            if denominator > 0 and numerator % denominator == 0:
                print(h, n, numerator//denominator)
                exit()


if __name__ == "__main__":
    main()

Solution (Python):
def main():
    N = int(input())
    for h in range(1, 3501):
        for n in range(1, 3501):
            denominator = 4*h*n - N*n - N*h
            if denominator <= 0:
                continue
            w = (N*h*n)/denominator
            if w % 1 == 0:
                print(h, n, int(w))
                exit()


if __name__ == "__main__":
    main()

Solution (Python):
n = int(input())

for i in range(1,3501):
  for j in range(1,3501):
    a = 4*i*j-n*j-n*i 
    if a>0 and (n*i*j)%a==0:
      print(i,j,(n*i*j)//a)
      exit()

Solution (Python):
n = int(input())
ans_a = 0
ans_b = 0
ans_c = 0
for b in range(1, 3501):
    for c in range(1, 3501):
        sita = 4 * b * c - (n * (b + c))
        if sita <= 0:
            continue
        ue = n * b * c
        if ue % sita == 0:
            ans_a, ans_b, ans_c = ue // sita, b, c
            break
print(ans_a, ans_b, ans_c)

Solution (Python):
n = int(input())
import sys
for i in range(1, 3501):
    for j in range(1, 3501):
        w_t = n*i*j
        w_u = 4*i*j - i*n -j*n
        if w_u > 0:
            w = w_t/w_u
            if w.is_integer():
                print("%s %s %s" % (i, j, int(w)))
                sys.exit()

Solution (Python):
N=int(input())
    
for i in range(1,3500):
    for j in range(1,3500):
        a=N*i*j
        b=4*i*j-N*j-N*i
        if b>0:
            if (a/b).is_integer()==True:
                print(i,j,int(a/b))
                exit()

Solution (Python):
N=int(input())

for h in range(1,3501):
  for n in range(1,3501):
    if (4*h*n-N*n-N*h) and (4*h*n-N*n-N*h) > 0 and (N*h*n) % (4*h*n-N*n-N*h)==0:
      print(h,n,(N*h*n) // (4*h*n-N*n-N*h))
      exit()

Solution (Python):

import math
n=int(input())
flg=False
for i in range(1, 3501):
    for j in range(1, 3501):
        a=i
        b=j
        if 4*a*b-n*(a+b)!=0:
            c=n*a*b/(4*a*b-n*(a+b))
            if c==int(c) and c>0:
                c=int(c)
                flg=True
                break
    if flg:
        break
print(a,b,c)

Solution (Python):
import sys
N=int(input())

for h in range(1,3501):
  for n in range(1,3501):
    bb=(4*h*n-N*n-N*h)
    bs=(N*h*n)
    if bb==0:
      continue

    if bs%bb==0 and 1<=bs//bb:
      print(h,n,bs//bb)
      sys.exit()

Solution (Python):
import sys
N = int(input())
for h in range(1, 3501):
    Nh = N*h
    for n in range(1, 3501):
        Nn = N * n
        left = 4*h*n - Nn - Nh
        Nhn = N * n * h
        if left > 0 and Nhn % left == 0:
            print(h, n, Nhn // left)
            sys.exit()

Solution (Python):
N=int(input())
for i in range(1,3501):
   for j in range(1,3501):
         a=N*i*j
         b=4*i*j-N*j-N*i
         if b>0:
            if (a/b).is_integer() == True:
               print(i,j,int((N*i*j)/(4*i*j-N*j-N*i)))
               exit()

Solution (Python):
from numba import njit, i8
import numpy as np


@njit(i8[:](i8))
def solve(N):
    
    for i in range(3501):
        for j in range(3501):
            num = N * i * j
            den = 4 * i * j - N * (i + j)
            if den <= 0:
                continue
            if num % den == 0:
                return np.array((i, j, num // den), dtype=np.int64)
    return np.zeros(3, dtype=np.int64)


print(*solve(int(input())))

Solution (Python):
N = int(input())
flag = 0

for h in range(1,3500):
    for n in range(1,3500):
        x = 4*h*n
        y = N*(h+n)
        if x<=y:
            continue
        tmp = (N*h*n)/(x-y)
        if tmp.is_integer():
            print(h,n,int(tmp))
            flag = 1
            break
    if flag == 1:
        break

Solution (Python):
N=int(input())
for h in range(1,3501):
    for w in range(1,3501):
        if (4*h*w-N*(h+w))>0 and N*h*w%(4*h*w-N*(h+w))==0  :print(h,w,N*h*w//(4*h*w-N*(h+w)));exit()

Solution (Python):
n = int(input())
for h in range(max(1, int(n / 4)), min(3500, int(3*n / 4)) + 1):
    for w in range(max(1, int(3*n / 4)), 3501):
        num = n * h * w
        den = 4 * h * w - n * (h + w)
        if den != 0 and num % den == 0 and h <= num // den <= w:
            print(h, num // den, w)
            exit()

Solution (Python):
import sys
N = int(input())
for i in range(1,3501):
  for j in range(max(i-1,1),3501):
    if (4*i*j - N*i -N*j) != 0:
      w = (N*i*j)/(4*i*j - N*i -N*j)
      if w > 0 and w.is_integer():
        print(i,j,int(w))
        sys.exit()

Solution (Python):



from fractions import gcd
from itertools import combinations,permutations,accumulate, product 

from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect














import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7


from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
  return int(readline())
N = I()
for n in range(1,3501):
    for h in range(1,3501):
        if 4*n*h - N*(h+n) != 0:
            ans = n*h*N / (4*n*h-N*(h+n))
            if ans < 1:
                continue
            if int(ans) == ans:
                print(h,n,int(ans))
                exit()

Solution (Python):
N = int(input())
flag = 0
for h in range(1,3501):
    for w in range(1,3501):
        if 4*h*w-N*w-N*h>0 and (N*h*w)%(4*h*w-N*w-N*h)==0:
            x = h
            y = w
            z = (N*h*w)//(4*h*w-N*w-N*h)
            flag = 1
            break
    if flag==1:break
print(x,y,z)

Solution (Python):
N = int(input())

for i in range(3501):
    for j in range(3501):
        num = N * i * j
        den = 4 * i * j - N * (i + j)
        if den <= 0:
            continue
        if num % den == 0:
            print(i, j, num // den)
            exit()

Solution (Python):
N=int(input())
for h in range(1,3501):
  for n in range(1,3500):
    u=N*h*n
    s=4*h*n-N*n-N*h
    if s==0:continue
    if u%s==0:
      if u//s>0:
        print(h,n,u//s)
        exit()

Solution (Python):
import sys
def I(): return int(sys.stdin.readline().rstrip())

N = I()
for h in range(1,3501):
    for n in range(h,3501):
        if 4*h*n-N*n-N*h > 0 and (N*h*n) % (4*h*n-N*n-N*h) == 0:
            print(h,n,(N*h*n)//(4*h*n-N*n-N*h))
            exit()

Solution (Python):
N = int(input())
flag = 0
for h in range(1,3500):
    for n in range(1,3500):
        a = 4*h*n-N*(h+n)
        if a>0 and (N*h*n)%a==0:
            w = (N*h*n)//a
            flag = 1
            break
    if flag==1:break
if flag==1:
    print(h,n,w)
else:
    print()

Solution (Python):
import sys
 
N = int(sys.stdin.readline())
 



 
for h in range(1, 3501):
    for n in range(1, 3501):
        a = N*h*n
        b = (4*h*n - N*n - N*h) 
        
        if b > 0 and a % b == 0:
            w = a // b
            
            print(h, n, w)
            sys.exit()

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  

N = I()
for h in range(1,3501):
    for n in range(h,3501):
        if 4*h*n-N*n-N*h > 0 and (N*h*n) % (4*h*n-N*n-N*h) == 0:
            print(h,n,(N*h*n)//(4*h*n-N*n-N*h))
            exit()

Solution (Python):
import sys

n = int(input())

for i in range(1, 3500):
    for j in range(1, 3500):
        rest = 4 * i * j - (i + j) * n
        if rest > 0:
            ans = n * i * j / rest
            if ans.is_integer():
                print(i, j, int(ans))
                sys.exit()

Solution (Python):
import sys

n = int(input())

for i in range(1, 3500):
    for j in range(1, 3500):
        rest = 4 * i * j - (i + j) * n
        if rest > 0:
            ans = n * i * j / rest
            if ans.is_integer():
                print(i, j, int(ans))
                sys.exit()

Solution (Python):
N = int(input())
for h in range(1, 3501):
    for n in range(1, 3501):
        if (4*h*n-N*(h+n)) != 0:
            w = N*h*n/(4*h*n-N*(h+n))
            if float.is_integer(w) and w > 0:
                print(h, n, int(w))
                exit()

Solution (Python):
N = int(input())

for a in range(1,3501):
    for b in range(1,3501):
        x = a*b*N
        y = 4*a*b - b*N - a*N
        if y != 0 and x/y > 0:
            c = x//y
            if 4*a*b*c == b*c*N + a*c*N + a*b*N:
                print(a,b,c)
                exit()

Solution (Python):
import sys
N=int(input())
for h in range(1,3501):
  for n in range(h,3501):
    if 4*h*n-N*n-h*N>0 and (N*h*n)%(4*h*n-N*n-h*N)==0:
      ans=[]
      ans.append(str(h))
      ans.append(str(n))
      ans.append(str((N*h*n)//(4*h*n-N*n-h*N)))
      print(' '.join(ans))
      sys.exit()

Solution (Python):
N = int(input())
MAX = 3501
for i in range(1,MAX):
  for j in range(1,MAX):
    chi = N*i*j
    mom = 4*i*j - N*i - N*j
    if mom <= 0:
      continue
    if chi%mom == 0:
      ans = [i,j,chi//mom]
      print(*ans)
      exit()

Solution (Python):
N = int(input())    

for h in range(1,3501):
    for n in range(h,3501):
        top = N*h*n
        bottom = 4*h*n-N*n-N*h
        if bottom > 0 and top%bottom == 0:
            print(h,n,top//bottom)
            exit()

Solution (Python):
N=int(input())
for h in range(1,3501):
    for n in range(1,3501):
        if 4*h*n-(n+h)*N>0 and (h*n*N)%(4*h*n-(n+h)*N)==0:
            print(n,h,(h*n*N)//(4*h*n-(n+h)*N))
            exit()

Solution (Python):
N=int(input())

for h in range(1,3500+1):
    for n in range(1,3500+1):
        try:
            if (N*h*n)%(4*h*n-N*(h+n))==0 and (4*h*n-N*(h+n))>0:
                A,B,C=h,n,(N*h*n)//(4*h*n-N*(h+n))
        except:
            pass
print(A,B,C)

Solution (Python):
n=int(input())
for i in range(1,3501):
  for j in range(1,3501):
    if 4*i*j-n*j-n*i>0 and i*j*n/(4*i*j-n*j-n*i)%1==0:
      print(i,j,int(i*j*n/(4*i*j-n*j-n*i)))
      exit()

Solution (Python):
import sys
N = int(input())
for h in range(1,3501):
    for n in range(1,3501):
        if 4*h*n-N*n-N*h != 0:
            w,r = divmod(N*h*n,4*h*n-N*n-N*h)
            if r == 0 and w > 0:
                print(h,n,w)
                sys.exit()

Solution (Python):
N = int(input())
ans = []
for h in range(1,3500):
  for n in range(1,3500):
    if (4*h*n - N*(h+n))>0 and (N*h*n)%(4*h*n - N*(h+n))==0:
        print(h,n,(N*h*n)//(4*h*n - N*(h+n)))
        exit()

Solution (Python):
import sys

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    n = int(readline())

    for a in range(1, 3501):
        for b in range(1, 3501):
            nu = n * a * b
            dn = 4 * a * b - n * (a + b)
            if dn > 0 and nu % dn == 0:
                return print(a, b, nu // dn)


if __name__ == '__main__':
    main()

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    N = int(input())

    for h in range(1, 3501):
        for n in range(1, 3501):
            a = h * n * N
            b = 4 * h * n - (n + h) * N
            if b > 0 and a % b == 0:
                w = a // b
                print(h, n, w)
                exit()


if __name__ == "__main__":
    main()

Solution (Python):
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
from math import floor, ceil,pi,factorial
from operator import itemgetter
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def LI2(): return [int(input()) for i in range(n)]
def MXI(): return [[LI()]for i in range(n)]
def SI(): return input().rstrip()
def printns(x): print('\n'.join(x))
def printni(x): print('\n'.join(list(map(str,x))))
inf = 10**17
mod = 10**9 + 7

n=I()
for i in range(1,3500+1):
    for j in range(1,3500+1):
        divided=n*i*j
        divider=4*i*j-n*(i+j)
        if divider>0 and divided%divider==0:
            print(i,j,divided//divider)
            sys.exit()

Solution (Python):
N=int(input())

for h in range(1,3501):
    for n in range(1,3501):
        if 4*h*n-N*n-N*h==0:
            continue
        if N*h*n%(4*h*n-N*n-N*h)==0:
            w=N*h*n//(4*h*n-N*n-N*h)
        else:
            continue
        if 4*h*n*w==N*(n*w+h*w+h*n) and w>0:
            print(h,n,w)
            exit()

Solution (Python):
import sys

n = int(input())
for i in range(3500):
    for j in range(3500):
        temp = 4 * (i + 1) * (j + 1) - n * (i + j + 2)
        if temp != 0:
            if (n * (i + 1) * (j + 1)) % temp == 0:
                if (n * (i + 1) * (j + 1)) // temp > 0:
                    print(i + 1, j + 1, (n * (i + 1) * (j + 1)) // temp)
                    sys.exit()

Solution (Python):
N = int(input())
for i in range(1, 3501):
    for j in range(1, 3501):
        tmp = 4 * i * j - N * j - N * i
        if tmp != 0 and (N * i * j) % tmp == 0:
            k = (N * i * j) // (4 * i * j - N * j - N * i)
            if k>0:
                print(i, j, k)
                exit()

Solution (Python):

def main():
	N = int(input())
	for n in range(1, 3502):
		for h in range(1,3502):
			t = n*h*N
			p = 4*n*h-(n*N+h*N)
			if p>0 and t%p==0:
				w = t//p
				print(n , h, w)
				exit()


if __name__=="__main__":
	main()

Solution (Python):

def main():
	N = int(input())
	for n in range(1, 3502):
		for h in range(1,3502):
			t = n*h*N
			p = 4*n*h-(n*N+h*N)
			if p>0 and t%p==0:
				w = t//p
				print(n , h, w)
				exit()


if __name__=="__main__":
	main()

Solution (Python):
N=int(input())
flag=0
for h in range(1,3501):
    for n in range(1,3501):
        if 4*h*n-n*N-h*N!=0:
            w = N*h*n/(4*h*n-n*N-h*N)
            if int(w)==w and 1<=w<=3500:
                print(h,n,int(w))
                flag = 1
                break
    if flag==1:
        break

Solution (Python):
N = int(input())
for i in range(1, 3501):
    for j in range(1, 3501):
        if 4 * i * j - N * i - N * j <= 0:
            continue
        k = (N * i * j) / (4 * i * j - N * i - N * j)
        if k == round(k):
            print(i, j, int(k))
            exit()