Problem:
 Score : 300 points    Problem Statement The commonly used bills in Japan are 10000 -yen, 5000 -yen and 1000 -yen bills. Below, the word "bill" refers to only these.  According to Aohashi, he received an otoshidama (New Year money gift) envelope from his grandfather that contained N bills for a total of Y yen, but he may be lying. Determine whether such a situation is possible, and if it is, find a possible set of bills contained in the envelope. Assume that his grandfather is rich enough, and the envelope was large enough.      Constraints  1 ≤ N ≤ 2000  1000 ≤ Y ≤ 2 × 10^7  N is an integer.  Y is a multiple of 1000 .         Input Input is given from Standard Input in the following format:  N  Y       Output If the total value of N bills cannot be Y yen, print -1 -1 -1 .  If the total value of N bills can be Y yen, let one such set of bills be " x  10000 -yen bills, y  5000 -yen bills and z  1000 -yen bills", and print x , y , z with spaces in between. If there are multiple possibilities, any of them may be printed.        Sample Input 1 9 45000      Sample Output 1 4 0 5  If the envelope contained 4  10000 -yen bills and 5  1000 -yen bills, he had 9 bills and 45000 yen in total. It is also possible that the envelope contained 9  5000 -yen bills, so the output 0 9 0 is also correct.       Sample Input 2 20 196000      Sample Output 2 -1 -1 -1  When the envelope contained 20 bills in total, the total value would be 200000 yen if all the bills were 10000 -yen bills, and would be at most 195000 yen otherwise, so it would never be 196000 yen.       Sample Input 3 1000 1234000      Sample Output 3 14 27 959  There are also many other possibilities.       Sample Input 4 2000 20000000      Sample Output 4 2000 0 0

Solution (Python):
N, Y = list(map(int, input().split()))

z = Y//1000 - N
result = [-1, -1, -1]

for m in range(z//9 + 1):
    if (z - 9*m)%4 == 0:
        g = (z - 9*m)//4
        if m + g <= N:
            result = [m, g, N-m-g]
            break

print(' '.join(map(str, result)))

Solution (Python):
N, Y = list(map(int, input().split()))

z = Y//1000 - N
flag = False

for m in range(z//9 + 1):
    if (z - 9*m)%4 == 0:
        g = (z - 9*m)//4
        if m + g <= N:
            result = [m, g, N-m-g]
            flag = True
            break
    else:
        pass

if not flag:
    result = [-1, -1, -1]

print(' '.join(map(str, result)))

Solution (Python):
import math
def calc_10000_5000_comb(n2,y2):
    max_10000 = min(math.floor(y2 / 10000), n2)
    for n_10000 in range(max_10000 + 1)[::-1]:
        y5000 = y2 - 10000 * n_10000
        n_5000 = math.floor(y5000 / 5000)
        if n_5000 + n_10000 == n2:
            return [n_10000, n_5000]
        if n2 < n_5000 + n_10000:
            break
    return []
ny = input()
n, y = [int(x) for x in ny.split(" ")]
min_y_1000 = y % 5000
min_n_1000 = math.floor(min_y_1000 / 1000)
max_n_1000 = n
match = [-1,-1,-1]
if y % 1000 == 0:
    for n_1000 in range(min_n_1000,max_n_1000 + 1, 5):
        y_2 = y - 1000 * n_1000
        n_2 = n - n_1000
        n_10000_n_5000_comb = calc_10000_5000_comb(n_2,y_2)
        if n_10000_n_5000_comb:
            match = n_10000_n_5000_comb + [n_1000]
            break
print(" ".join(map(str,match)))

Solution (Python):
N, Y = map(int,input().split())


for x in range(Y//10000 + 1):
    for y in range((Y - x*10000)//5000+1):
        z = N-(x+y)
        zz = (Y-x*10000-y*5000)//1000
        if z==zz:
            print(x, y, z)
            exit()

else:
    print('-1 -1 -1')

Solution (Python):
n,y=map(int,input().split())
A,B,C=[-1,-1,-1]
f=True
for a in range(n+1):
	for b in range(n+1):
		if 10000*a+5000*b+1000*(n-a-b)==y and 0<=n-a-b<=n:
			A,B,C=[a,b,n-a-b]
			f=False
			break
	if f==False:
		break
print(A,B,C)

Solution (Python):
n,y=map(int,input().split())
A,B,C=[-1,-1,-1]
f=True
for a in range(n+1):
	for b in range(n+1):
		if 10000*a+5000*b+1000*(n-a-b)==y and 0<=n-a-b<=n:
			A,B,C=[a,b,n-a-b]
			f=False
			break
	if f==False:
		break
print(A,B,C)

Solution (Python):
n, y = map(int, input().split())

ans = [-1, -1, -1]

for i in range(n + 1):
    for j in range(n - i + 1):
        if 10000 * i + 5000 * j + 1000 * (n - i - j) == y:
            ans = [i, j, n - i - j]

print(*ans)

Solution (Python):
n,y=map(int,input().split())
f=True
for i in range(n+1):
  for j in range(n-i+1):
    if 10000*i+5000*j+1000*(n-i-j)==y:
      print(i,j,n-i-j)
      f=False
      break
  if not f:break
if f:print(-1,-1,-1)

Solution (Python):
def resolve():
    n, y = map(int, input().split())
    for i in range(n+1):
        for j in range(n+1):
            if 10000*i+5000*j+1000*(n-i-j) == y and n-i-j >= 0:
                print('{} {} {}'.format(i, j, n-i-j))
                return
    print('-1 -1 -1')
resolve()

Solution (Python):
def check():
    N, Y = [int(i) for i in input().split(' ')]
    if Y % 1000 != 0:
        return '-1 -1 -1'
    else:
        sen = Y // 1000
        sub = sen - N
        count9 = sub // 9
        for num9 in range(count9+1):
            sub1 = sub - num9*9
            if sub1 % 4 == 0 and num9+sub1//4 <= N:
                return '{} {} {}'.format(num9, sub1//4, sen-num9*10-sub1*5//4)
        return '-1 -1 -1'
print(check())

Solution (Python):
N,Y = map(int,input().split())

list = [-1,-1,-1]

for x in range(N+1):
  for y in range(N+1-x):
    z = N - x - y
    if (x*10000) + (y*5000) + (z*1000) == Y and z <= Y:
      list[0] = x
      list[1] = y
      list[2] = z

ans = ""
for i in list:
  ans += str(i) + " "
print(ans.rstrip())

Solution (Python):
def q62(N, Y):
    k = Y - 1000*N
    is_true = False
    for i in range(0, N + 1):
        for j in range(0, N - i + 1):
            if 9000*i + 4000*j == k:
                print('{} {} {}'.format(i, j, N - i - j))
                return True
    return False

N, Y = [int(i) for i in input().split()]

if q62(N, Y) == False:
    print('-1 -1 -1')

Solution (Python):
import sys
 
N, Y = map(int, input().split())
 
if N * 10000 >= Y:
  for a in range(Y // 10000 + 1):
    if a * 10000 + (N - a) * 5000 >= Y:
      for b in range((Y - a * 10000) // 5000 + 1):
        c = (Y - a * 10000 - b * 5000) // 1000
        if a + b + c == N:
          print(a, b, c)
          sys.exit()
print(-1, -1, -1)

Solution (Python):
N,Y = map(int,input().split())
for a in range(N+1):
    for b in range(N+1):
        if Y== 10000*a+5000*b+1000*(N-a-b) and N-a-b>=0:
            print(str(a)+' '+str(b)+' '+str(N-a-b))
            exit()            
print('-1 -1 -1')

Solution (Python):
N, Y = [int(n) for n in input().split()]
A = 10000
B = 5000
C = 1000

ar = -1
br = -1
cr = -1

if Y % C == 0 and Y / C >= N:
  for an in range(N+1):
    for bn in range(N+1):
      cn = N - an - bn 
      if cn < 0:
        break
      if Y == A * an + B * bn + C * cn:
        ar = an
        br = bn
        cr = cn

print(ar, br, cr)

Solution (Python):
N,Y = map(int,input().split())
for a in range(N+1):
    for b in range(N+1):
        if Y== 10000*a+5000*b+1000*(N-a-b) and N-a-b>=0:
            print(str(a)+' '+str(b)+' '+str(N-a-b))
            break
    else:
            continue
    break
else:
    print('-1 -1 -1')

Solution (Python):


n,y = map(int,input().split())

for i in range(n+1):
    for j in range(n+1):
        if 10000*i+5000*j+1000*(n-i-j) == y and n-i-j >= 0:
            print(str(i) + " " + str(j) + " " + str(n-i-j))
            break
    else:
        continue
    break
else:
    print("-1 -1 -1")

Solution (Python):
n,y = map(int, input().split())
ans = "-1 -1 -1"
a = []
for i in range(n+1):
    for j in range(n+1):
        m = n-i-j
        if m>=0 and 10000*i+5000*j+1000*m==y:
            a.append(i)
            a.append(j)
            a.append(m)
            ans = "Yes"
            results = map(str, a)
            answer = " ".join(results)
            print(answer)
            exit()
print(ans)

Solution (Python):
N, Y = map(int, input().split())

def main():
    for num_10000 in range(Y//10000+1):
        for num_5000 in range(N+1-num_10000):
            num_1000 = N - num_10000 - num_5000
            if num_10000*10000 + num_5000*5000 + num_1000*1000 == Y:
                print(num_10000, num_5000, num_1000)
                return
    print('-1 -1 -1')

if __name__ == "__main__":
    main()

Solution (Python):
N, Y = map(int, input().split())

def main():
    for num_10000 in range(N+1):
        for num_5000 in range(N+1-num_10000):
            num_1000 = N - num_10000 - num_5000
            if num_10000*10000 + num_5000*5000 + num_1000*1000 == Y:
                print(num_10000, num_5000, num_1000)
                return
    print('-1 -1 -1')

if __name__ == "__main__":
    main()

Solution (Python):
N, Y = map(int, input().split())
for x in range(N + 1):
    for y in range(N + 1 - x):
        if x * 10000 + y * 5000 + (N - x - y) * 1000 == Y:
            print(x, y, N - x - y)
            break
    else:
        continue
    break
else:
    print("-1 -1 -1")

Solution (Python):
n,y=map(int,input().split());l=[(i,j,n-i-j)for i in range(n+1)for j in range(n+1-i)if y//1000==n+i*9+j*4];l+=[(-1,-1,-1)];print(*l[0])

Solution (Python):
import sys
N, Y = input().split()
N, Y = int(N), int(Y)


for m in range(N + 1):
    
    for f in range(N + 1 - m):
        money = m*10000 + f*5000
        diff = Y - money
        
        if diff%1000 == 0 and m+f+int(diff/1000) == N:
            print(m, f, int(diff/1000))
            sys.exit()
            
print(-1, -1, -1)

Solution (Python):
N, Y = map(int, input().split())
X = (Y - 1000*N)



f = False

xm = X//9000 + 1
for i in range(xm):
  y = (X - 9000*i)//4000
  if (X - 9000*i)%4000 == 0 and (X - 9000*i)//4000 >= 0 and (N-i-y) >= 0:
    x = i
    f = True
    break

if f:
  print(x, y, N-x-y)
else:
  print(-1, -1, -1)

Solution (Python):
N,Y = map(int,input().split())
flag = False
if 10000*N < Y:print('-1 -1 -1')
else:
  for i in range(N+1):
    if flag == True:break
    if 10000*i + 5000*(N-i) < Y:
      pass
    else:
      for j in range(N-i+1):
        k = N - i - j
        if k < 0:print(k)
        if 10000*i + 5000*j + 1000*k == Y:
          flag = True
          print(str(i)+' '+str(j)+' '+str(k))
          break
  if flag == False:
    print('-1 -1 -1')

Solution (Python):
n,y=map(int,input().split())
flag=False

for i in range(n+1):
    for j in range(n-i+1):
        k=n-i-j
        if y==1000*i+5000*j+10000*k:
            print(k,j,i)
            flag=True
            break
    if flag==True:
        break
else:
    print(-1,-1,-1)

Solution (Python):
n,y = map(int,input().split())

b = [0,0,0]
total = b[0] * 10000 + b[1] * 5000 + b[2] * 1000

for i in range(n + 1):
    b[0] = i
    for j in range(n - i + 1):
        b[1] = j
        b[2] = n - i - j
        total = b[0] * 10000 + b[1] * 5000 + b[2] * 1000
        
        if sum(b) == n and total == y:
            print(*b)
            exit()

print(-1,-1,-1)

Solution (Python):
N, sum = [int(i) for i in input().split()]

for x in range(N+1):
	for y in range(N+1 - x):
		z = N - x - y
		if 10000*x + 5000*y + 1000*z == sum:
			print(x, y, N - x - y)
			exit()
print(-1, -1, -1)

Solution (Python):
import sys
N, Y = [int(v) for v in input().split()]
Y //= 1000

for m in range(N + 1):
    for g in range(N + 1):
        s = N - (m + g)
        if s < 0:
            continue
        if m * 10 + g * 5 + s == Y:
            print(m, g, s)            
            sys.exit(0)
print(-1, -1, -1)

Solution (Python):
N,Y=map(int,input().split())

for x in range(N+1):
    for y in range(N-x+1):
        if x * 10000 + y * 5000 + (N-x-y) * 1000 == Y:
            print(x,y,N-x-y)
            exit()
print("-1 -1 -1")

Solution (Python):
import sys
n, y = map(int, input().split())

flag = bool(0)
for i in range(n + 1):
    for j in range(n + 1):
        k = n - i - j
        if k >= 0 and i * 10000 + j * 5000 + k * 1000 == y:
            print(i, j, k)
            sys.exit()

print(-1, -1, -1)

Solution (Python):
N, Y = [int(i) for i in input().split()]

def ans():
    for i in range(N+1):
        for j in range(N-i+1):
            if i*10000 + j*5000 + (N-i-j)*1000 == Y:
                print(i, j, N-i-j)
                exit()
    print(-1, -1, -1)

ans()

Solution (Python):
import sys

N,Y = map(int ,input().split())

for x in range(N+1):
	for y in range(N+1-x):
		if (Y - 10000*x - 5000*y)//1000 == N-x-y:
			z = N-x-y
			for i in [x,y,z]:
				print(i,end = " ")
			sys.exit()

print("-1 -1 -1")

Solution (Python):
n, y = map(int, input().split())
for i in range(n + 1):
    for j in range(n - i + 1):
        if i * 10000 + j * 5000 + (n - i - j) * 1000 == y:
            print(i, j, n - i - j)
            exit()
print(-1, -1, -1)

Solution (Python):
from sys import exit
n, y = map(int, input().split())
for i in range(n + 1):
  for j in range(n + 1 - i):
    k = n - i - j
    if 10000 * i + 5000 * j + 1000 * k == y:
      print('%d %d %d' % (i, j, k))
      exit()
print('-1 -1 -1')

Solution (Python):
N, Yen_target = map(int, input().split(" "))

flag = False
for i in range(N+1):
    for j in range(N+1-i):
            if Yen_target == i*10000 + j*5000 + (N-i-j)*1000:
                print(i, j, N-i-j)
                flag = True
            else:
                continue
            if flag:
                break
    if flag:
        break
if flag == False:
    print(-1, -1, -1)

Solution (Python):
N, Y = map(int, input().split())

count = 0

for x in range(N+1):
    for y in range(N+1):
        z = N - x - y
        
        if 10000*x + 5000*y + 1000*z == Y and z>=0:
            count += 1
            if count == 1:
                print(x,y,z)

if count == 0 :
    print(-1,-1,-1)

Solution (Python):

import sys
import math
from collections import defaultdict


sys.setrecursionlimit(10**7)
def input():
    return sys.stdin.readline()[:-1]


mod = 10**9 + 7


def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
    read_all = [tuple(map(int, input().split())) for _ in range(N)]
    return map(list,zip(*read_all))



N,Y = II()

for i in range(N+1):
    for j in range(N-i+1):
        y = Y-10000*i-5000*j
        if y == 1000*(N-i-j):
            print(i,j,N-i-j)
            exit()

print('-1 -1 -1')

Solution (Python):
n,y=map(int,input().split())
c=0
for i in range(0,n+1):
    for j in range(0,n-i+1):
        a=y-1000*i-5000*j
        if a%10000==0 and i+j+a//10000==n:
            print(a//10000,j,i)
            exit()
print(-1,-1,-1)

Solution (Python):
inputs = list(map(lambda n: int(n), input().split()))
N, Y = inputs[0], inputs[1]
truth = False

for a in range(N+1):
    if truth:
        break
    for b in range(N+1-a):
        if truth:
            break
        c = N-(a+b)
        if (10000*a + 5000*b + 1000*c) == Y:
            print(a, b, c)
            truth = True

if not truth:
    print('-1 -1 -1')

Solution (Python):
N,Y = map(int,input().split())

res = [-1,-1,-1]
for i in range(N+1):
    for j in range(N+1-i):
        total = i*10000+j*5000+(N-i-j)*1000
        if total == Y:
            res = [i,j,N-i-j]
print(*res)

Solution (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'H4sIADLMaF0C/+19e3wU1dn/bDaX5ZYNiBguStAVgkjIkgCJ14SwMCsbiCQganHYJBsS3GTz7s5iUKzQJNZ1jaWttba1lV5eX21r5dOqBasQRAnYV0RUGkUFKZdZIherYvDCvs9zzpnNmdmZCOrn9/n94So5+3znOec5z3Oe85zL7My5y+WZnWKxCOonRbhGQGrc6BJClzC8pSbBAliRMAD+jhXGCOlAp3F8JUKJJu1lRaupjfFZ4V8q/CtKoXRRSokmHcP41NTCpWkC/ynRpFctEDSpIOQk8mFdu5dQtHvJUk1KKgOfrAxtvhSWr5fl62X8aiqkCJpU1S+V/atieBXTS01nMb5Zgka8UHFIrsXv3R5WT0+JJl3F+Fbp8l0P+dKFs/9ksXSBKs/ELrms/mqqtsMUf0P19MIp/trJ/oamcMvklqLpk6cX5oUCeVNJnbIY75x5CzV2zGZ1Hs58AK//9en5O9dsnn3e7072Pn/saOELP9/6YAVem8HyYZO0N2XVp44bkGIRCoXVUDReuwL+XQv//vpOwZsD16yVfl3z/Ev3N8a339NeM+KNynWt991Y8uHkD6VbMnNW5Oe63vR0Hh3fOfyhwWW/GdO8YaX71mf6s89BqMAwA/z1FGN8isUY/6tgjGclPEz7GWuCv5pmXM6dJvg/TeR2mPBnpBvjFSb4D1ON8QaT8seblFNkYs+nTfCRJuUUmNhtmUk5/zHBx5qUP9+k/J+a2DnNxB+qTOQ+a8I/xKQ+S034RRP+Uyb+PM6knEdN2nejCf6sSfnfN7FPg4k9C0zqv9LEbsNN+P9iolejST1LTcr5wKT+xSblvGdiH9kEf9mknsdN+tEEEzvsNil/p0k9rzDR93kTuZdAOeOEUcLaajouZDN8GMN31SzVjCsT0ii+n+GLGT4oleFeiq9m+H+rckeWaOTOYfbZpcPngtyhUE5n7VJutBaE21Mpvp/h6nj1loXKXVqt5bcze67P1pZfkUbLWV2tLedqVn4nw7PYhTlMr5JanV7M/ktHacsXYPwMybU1kybhmDldkKRljYEmKSR7g7IkCdJ1K6QFvmUNIdkXLPN7QyFfSJDcVeVSrS/I4KryMn+gyVflrfb76DXjK1KzXB/0eWulW30rpRr4JiNY0+KV6oI+n+RrqfE1yw2BJkG6aV5lqBDENjvzJZQUkoOBla4Fcyu97hoXuRwohgsNTSFfUHb7Xa4FlYEqCS/MrZSn1cgrm33A6CwAntsaan1NwNkgu1YAQ6XsnCFJUI/AbVI1VMXr9wdqVtCcIWdBXUNTrVTXEAzJUqDOVTG3prGRiptW5w+H6tUipvNF1HhDMikBLhQEw01yQyMoEwwGgrOcXIYAKOHzNqqVrgHUWVPvDUpy0Nsgh6C+oAWUUO0NNdSo3O4qqSpfclVOlyrmVhZIfmYvIpyUXAxWbmxoAlPSKoTKnGinEKl3VRUUWNxXYEPTMlasgXRiW2pcuaghEALdQr5CNxiOqQH4dDCW1+/rA3QKM+GJmoAB+UZDqFGDyKx2IM/QItNq/D5v0AVXpkpuqBP8k4nbgOpT89VWCISxuaSgt2mZD0SqrTmdtCb4rCw1BbQNipdncI2tu17lhprx/oiATlfWFNXg6k3gA3JNPee3ULdKydfYLK+EvtAMnSkQ9C7zuZiHOqdRrWmTVIfrzNujAHjQ2NKylhap2RcMBZq8/gYodkU+M2CimrOmslYJgbHKJTDcrRKUWKui073Nzb6mWqIkILX+ihXQFHIx6E6sKKOei86pdqQdCmvA/sl5wc1M8mK2ptsaSeYZTDpnu2IwHY0OrsZGjbMk3JKqSuxPOjDw6sJHoKA5LLtqmJeeWx8AL8XWJg43H0zWGKj1Ef3mQTgCoS3e6oYVTnS/UINUgzFRwogDPbsu4OKDlxM0Yf3Tz5ROsjgwzwj6ICSsAHWNel8Z62xz+bYuvK3eK+sblnU9bFgM6o00nsO3ZTXQIkg5BWlh023o9gt8oXCjDy/WULa6AJQhgGnkgF+o8wXqhLplPjmEiB8uMGPLvpYGWWj0NdY0NpOkeaVQV+MPhHxINQZWYETHQtn40ehtaBLmlJVJBXn5whyPe2aZNDXPWZj4OjVvmlC2eHHpTLfkzCug8OLFwF2Y53RqyGKeous4/M8qqN9T4V8a/JdCUvpX0KT0u5VdTYFVYArbNUA8neVLZ1czWGrjuJP/S4fx2CLsT+tbR1WMXzkIV4rV6eo6NUX4kl3Ph38P/PjBdFydL0+nWHhUwwCsQzjBn0rGeHX+8vqTt6bhinUN4/f2/jwFV673MTpy18QUXMH+itHyxJ/YUN/HWXm9Ep0HpOv2K9R5Txpbvybm89V9+LUcvprDSzl8LYfP4PBODp/J4er8DPEivj4cXszvqtT24WV8+Rx+NV8Oh1/D4dlLKZ7BzaHI/IvDUzg8l8OtHJ7P4an8+pHDeTuXcHgGvz7icBs/3+PwARy+mMMH8u3F4YM4vJ7DB3N4M4cP4fAWDs/k253D7Rx+D4dn8f7A4UM5/CEO5+f16zicn5k+xuHDOXw9h5/P4Rs4fATvJxyezeHbOfxK3j85fCSHd3P4KN7fOHw0hyscPobDT3L4hRzey+EX8fNzbx8+loNtHM6vX7M4fBzv/xx+Me//HH4J7/8c7uD9n8Ov4v2fw8fz/s/hE3j/5/Bc3v85fCLv/xx+Ge//HD6J938Ov5z3fw6fzPs/h8/i/Z/D83j/5/ApvP9zeD7v/xzu5P2fw6fy/s/hBbz/c3gh7/8cPo33fw6fztu/9QObGE27U8wRxPZOOU25mYAv2rbS6/FpQbgUv1SGv/axJfAN6Xq8FNsfh8+ly5HGUBrbRehqpDGExjoJfRPSGDpj6wm9AGkMmbF1hL4OaQyVsbWEnok0DlOx1YS+AmmsdqyZ0FORxlAZW0roy5DGEBmrIPTFSGNojJUQehTSGBJj+YQehjSGwlgOoQcijSEwlkXoFKQx9MUEQn82B2gMebGTZ5D+D9JZRH9CH0V6KNGf0AeQHkb0J/TbSJ9H9Cf0bqSHE/0J/TLS5xP9Cf0C0iOI/oR+FukLiP6E/ivS2UR/Qv8R6ZFEf0L/DulRRH9C/xLp0UR/Qv8E6TFEf0Lfi/SFRH9C/wDpi4j+hL4d6bFE/y+RDiKdQ/Qn9HKkxxH9CV2N9MVEf0LfhPQlRH9CL0DaQfQn9HVIX0r0J/RMpMcT/Ql9BdITiP6Enop0LtGf0JchPZHoT+iLkb6M6E/oUUhPIvoTehjSlxP9CT0Q6clEf0KnIJ1H9Cf0Z7OBnkL0/4K0P9L5RH9CH0XaSfQn9AGkpxL9Cf020gVEf0LvRrqQ6E/ol5GeRvQHumLzQZi5KOeD6M24B7QJyWd3Qe9Vrgds8VbnMXfktVvEyAGx9eDJiip3V+dqd4kgdm3JIklX1pgSQTkFJX1sHwsBbMM+yLpQnNwNidjamylGDt2WsmTrBtL3ocN/vGQzXorvt48lW0Qbujn+Lb1W4BcjL4hbjl4rWnaJr/WGIfOzNPNuyCxGttH8B1j+1VePcoNzhIcuhJzK90HBJdvSMgCyfLQV44fYerVtJjDIFyWqMHzh5pNLQFrkUHzXktgdkMU+VoiFaFqhYFd2dt60tY7os7D0htJFpQtLqyrFNR88Btc2Y1fYhNM9JQe0FiNbXc5TYvteOVfseMCxFi8+gJaJ7FOwPcSuMhsGK0jJdMUdeY8r4b3PsYSXxPZj8tWY/SG8csF1mP2EsoZkd5FsYtcsBwmCYsTvaAHUhhEPQBLre0b1XYcvLSRgWyJw1XnME3nKgZYqbz8lp7rjs22eiOwo4upw0+dMi2OoxWSx4z7HOryItX52IBG5T/nZ50aqvOuJ/NlxD3z1RO8kNct13TuDKzr+WTzujrzIIcc+Iwo796LKU0vtz2xr7V0YtrrjXaj+Y0TaCU/kjNJGBLqYQGaESI8Y9TuKRJQWLVCaSfGpDqz3QDE+12ZvWwiB3Q0mIPnwC8noidQ66t2tVzkEe9vTEBq3zXI0W6JgnrZOMfo9R274EswdvlCMWsWOFmUjTvLF4lft7X+1U/W3nYbaQI0dYrzcFr5IjLoELePvM0nNlV8D4+pVjmYQtBsEidFVjpZNz4E/OHdvxBZTHkYDtPbG7W1Thmuc6XXI6dyB/gmNKXRjwV0lTP0Spv4WMeJx5Lic8R67fWwbGS/da7oE9JMNcfq5y92RmiFeHYcBcBMuFErtnk/RaPVidCHU+TlHDlRDeZTo02lv6xA0lZh3mvgCGLR0E9m1nwTaix1PkVzYQidhIFSU04Z+jcrmeCKnlIeg7dDdCtzxebbwZHc0XWusDRZskk+V5l4oB+tWV5en6oNtqywDI0Ht2olULFWMZniizQoU+jwRZp93vLWlV2gZJEY+Vwagq0St7g5PXvzeMTZOnbt61e6lqmPf9DpxbGgrdPReVGdjb7KruSPHuXJm9KpmIeLl3E0ppI/uQ5Pgckl5szfZJGLkXXf0GjF6g+KJ+oTyDr9DcV9Z5VDCoz2Rw0rNaaLjA1t7Mus4/WnPyCZ+NmwDmsxd/FK4GH2r9FNq1rHErCN1Zg1fgya9EHja9trbDkHsjr2PirS+2JuIfA3ES06W2rekOiJtjj9A747SpOdGsbWzdyNl3CHXbySM9i22yH2UjSY9izRs1WZsFaXRVEeHGC+NDHaAkj+6Gtg8aPKnHOvgurICqhnLBTBq67g+Hslq30F5EgwLkWGSlmHHlxxDITL8HUetvmZae4o0Ew1kJBzbBmAgo22lOD81bCOugPmnWCg8mCghiy/hxCkjx39HdVGxtUWBjr8e0WihQ4zOU5y7leW0UAyPNrH1c+j5IyzMrT3Ra92WfSqv2PUCmlMZ+QmGtZe4ev2dINucx6D57W1Xku5zTOxwWUqfJ4GieKu9zQ7oBlKxid2i5SWsezbUHcYmcJ26T0gdPB23ZoutX1rs7S/hdsq9GaX3uIRYFxtWbGg4qN5e0g1ngUrxEht0n9jLBNCFxtYBNDT+6WPsfd+D+GocdsGS9rbVGPUwQLevwG/RK0EQzP2fJKbZpyyDMmLf+0zTmFsBwwp1yvNM4+FLPVM9ZLgQI0eVYdC8GzqZOdrHg5OUR/LcXbNZnWazKn1S3n7QA8a3yZe64x4HRHM3+KpWN+sA5DyivPoRVCk3UaX8j1mIhuiAo2i+PM5+Q6d9aF+NukqyWQ1zuIi91LnX0/EHRw6UutYdnYFtDX1VjLyt3P8xCVDYlYsXK/Yf3G3FTDFx4lsgHkIp8hz9RGOXP32kxiK5QITem0PawSp20a/UUFoX3YAgDhmzsB0pn3NvOZoNR1ON6nIKjuZ+x9Ly6J228ivvzJIvLMe2ckfGOve6W7ts5ZE7bbGBwEXnR+5oI5iqV5yo4OwNBvuNKNljn/W+2/Ki/Sed4kY2MI0VIy97ig/Yf7LFtsVjdx2AZthAg2li7BrrLn7R/sNfQNnXdVx1iOxmvAsGQhFYG2znicfFyIdi6/u9omWLnCZGRoJpi7+0t/2crCK39YpbjlvF+DbZTtkspAWOymPQj+xitBxMZYMYT4eajoU2sUMEF5/lyBVbz6QEZ9WtxbA2RIymiBGL2JVC2WYCy04o3SZnidHbgVgJZcy00eVspw2vuIu7UGLkhfAmd8ecXiwyC62b3XMLLb6j3hb7I83QFz9HmsXPjETYu+uaRMgr/U883jOljnwS44UnGiZTuwlkUBinHxTW4qBg+5AMcGz9/RJU9kS4S4x6oIqTPI5sYs4oqaTfkgWWhkJlhw2bHWweV3acxC4L190RF4S7Rtt1Han74XuW6tTgi2ReVh75VB5LZlIjdeEiXI/dfDUW1PolBPElFhSRb28/BnOXWOfXsIv9R4v44eBSUDE2C5FzLqeaH3fehSqSdT0ECk8EosTmVIj9Sh3CNV/Q6Uo+9n2bkgLNEavEcfZQBp1eX0La4MKk+c6BVDrfWX0CB/A48s0nfBlaPoXwxZXFJzRhZyOQMOdDF/6KeOOOdGGli7C1lorRXJgzkel+vqf4E3vbndi1ocnWDiSdV51vwVQ2mq1O9HFmMvEkGX/E4ocJq70Nf8vjjt5gc195Q5Z8ES7ErJ7IZWLrCzZ35AZb7A2BK688OkGM7PJM3E/DwTY1HHzotmzThYOdnuJTajg4Bfb7BwkHl/HhYJv9hxgHIBx8QsLBzpMk+IEQrI9n4gF35F/uLXFYNe4SW/dDUOjGquWikQcxbe4A683rWPU5+PNB9Ocjyulj1J+LxEi2J9ICSnSBR3/kjszJIl6p2oh2leP29u4z0MjXWnBAOYNT6HycE2ADKHlYHxUZCZ7yLG4MKJ8eRwnEsNA3wlMx6CKLGC1RgD0Vv0efSq2ApHWnRamHKvbkQuHKX+BbLDNOR8XS432FizC9jryg/AagbW2OR6B2ExKXwHcRwF9QCcoq4NhM6vbCcTr5hctFhO05Ry5OVS8DGX+zIJw7gC5aWsAgzr2b8JbKs/g7E8Q+htyxjDPoCV1YfcLLe2vb0MHaXmtvOzJIEEx6XGz3IMy/yrFU+Ww0GsIP04v+FlQ4wmA9PB/gAACzf2i/HfZ7fkpCXomtvOE1BcZKZ7wcvAGCc0PXyW7otJbOFhlXwIvpWL9dnNgrdm2Jk/78nifyOvTqlmJN/BTbT7VMEIvfk+vEjush6lc5FovxLWL8FXHN1mzs8Gu2tUAVxOLtd73hju90r3kBUfearSjPXXxa7LjLctdqlCmiGPxCtgHFDtBN7KhylIhdXWRaN3MUBJ7hOChU4MXFeLFCuXwUxo64PBpiQnb4fHf0Wjo1qurBOscVTw+WtcpRr1TDHEBc8yLuQdxc+r3SJaW3lEpLtmpbwG0xb4FCi769ruqHe0IS95R+uEclcV/cD/eQJO7z++EWkrht/XB/JOi5PxfMuQ/jJoq6Eph0b1pTYY5wz6xJ2bEtn2iWHud9wo0RG49C17BoGYSTHMNDyHD8hIbhCb6E25DhV9oS9p7mGBYhw47TGoYDPMM0ZNilZXjlC45hODL84wsNw9QTHMNHMWDIQSTSpZwaSabGZMSDDh97IpUMJrH/hjR2m4UQPbmIfEEJMjJB/4yVa+h9ypijZJFqb3sdL8B4aG/fQYYP7ZjY9uekVv1BP63aSKWI0bQ/T80BOWo4HfI0khhVI/eRqIrTYIx2J3E7EcLW6qSwtS3JQR7ux0F+KNBgRcd8rAIuZ+7HaTpZzrRZk5dGbcusehFXW81F5Fq1FnxbgYb5mUBGGzT7NX1zwSF97a9grKG6VmBGiO7NGN3fidFB4x4knlTojgEEl3kkuFxDg8unhzG4fKqcOEyDy1LFNwJq8nOoiZGw7Ucoeyeyt8K6FeYEe6yJRaIIduhKkFGNveVrz3nC2ye34ggOoyAvVgPF01HtgyNkKYy64zqbLHfISNuswDx8OKqOuOI4TO2AxKYyHJnxlojyxKE+WITBvkjpUTTLK89hMvkpbz9mb385ja6XkNnlPBY7kqbWou4IXYR1WZd6SujQmq7OCUYpVARBHnGDZLz5ofz7MO18+el0LM6BVPnNEY3wVw8R5bD/tD/LhCOfy3kqtichPHZYL3xthir810eocIJsRuEXkPoy4Q9lUOH3QKqM0wpfwAl/nAlHPhT+UhrGh9PE/3eIkX9C+1tIF8i2t/8v2c24kmwd4AaE8ouD4MB/UXssNZ+2g7w9SN9BLumng2SauKXzEJ0nTTyoevEjuOUKswqJzCpu1M8qvpEzbkUpMCH5x79pJ7AJ8nL0eBt2gLBEv36Lzl95kDq/TXH/m85Xc3AF4EVx0Prhxbqw842EHf43NeV7B9TZxsd2uhZZRbyiLzpdhY0rk4vQe7iRQLkYrwy0a4YHZQiAhMCJt4Acxwdow10PiI5dSKa8fhJhE1dewys/PkNHqKrz6Ij0e/Q2oGedp44Iv7ycjgjY32BE+P3lfSMCgSBSYJ9TR4SWdL03hpOGorn9DEXTE0PROCYY+xoIvowTTCAQjP1NFbw/Qy/42nOeB3GD+YM2OvUn7Tce2i3WZuuzLIbrHx/A6H/Q3lYOi1Sy12Vvn4lf9ftdbSNt+oqcyDCvyNsZxv3xt+/TvedFvbSneLFS7l5uCsIxy+/TAQybRh3A8C68MvrfNIKtRuI4cMXW20z6PysCjawWsQsDW/cBWoSCxJ+wiEZbXyTHXQx++HCzrX832/onu2Va+1yU1FAf9zNn2Cf0RW53JJ3szKWrsrTbkQaycpJknepH1vtCX6BmsvDrWcqamSQrux8HtFqM2+HxfeBTXenqYIS7OXQwynofnW0J7g/Z2z0WWlOy2cPWwfgd1sH7BboOXrqfrbOxoz+Saiztyn0YDdP+kKvp9U/knmuv/58k3e/sR/d6E92feI/UZkSuJhSMzT3XUHBBir42x/qpTbeF7r2PfY86OrEp3SFY9R4d6bcLdKTHPVZlxj7NSF//rnpbzN7+CyttFuSDKc7frWp0K5tAVaLtNcQzoU8lAoFKKENVCZ8D0aq0IUml+1PMVcLnm4wM7HnXJE589B4XJ7a9q9kx++E79C5zJ04GysmemStxa28zbtwqbZgdIwHZAC7PwrF1sCeSn7hNDiDuFLP9NRfbzwf9y2xkfbPVqq5vNloN1jcPJ60Bgv1McZaYTHHmvWMS4j55lwtx29/RaB/Z+5Xa3/3uN9ReSGh/KsVA+7eS2v7Jftr+l3Cth7rdnQJdoSx8m80bcCDZvpetKR9NUaU+bCT1uSSpP+lH6p0mHvf229Tm6N2qzXHsVda8Q22ORlGq9tI1kX8v7qbhcqFNICvecrQJuQOo29Jq605aef6ln8j+C6GvY4psyNqgrnh0d6sNQvvupPD2WD8B5acm4W3nW6jlEWVbN0Tm9E+Mh/LHCdMJ5bfdOP7jHuunig+M6InSH4cQ4zRYVeNI1mTjfKPJ60Qmf1w3bbh72E8NY5+YtHBvN227k//CDNZOGLg2rZ4La6UKkd7n/RRK7Ck2yvo8y/o0zboWs+Z7uKzPvUW3TOHr9W/RSfWNkMYe/Zjgsd98bGzEWlbw96Dgni1GHDO7yVDzp3GauPzUuHOLy9/I0pv/ZdI16t7iukZxtyYcfbaH3pXvxFuWc0k4sqp3Jmk0wvbAW5gkGM2lwUiM5GL4ShXjLgQhGJWxYFTGglG3OwJxCn2LTLiIb72p3tHQ9IW/J3W8DvOO13MHCUTsDvUrbybi0D6l5F/kV0D2NivutBGBpz9nO/0agY8lBaLv9xOIGkzc9Po9dB7tfpPMr7S+hr5S8S+6asrlV02/wlzRh8lvvtDiy8kNudpvc7W44U3q2OvfoO6gPuuJPwNoQZnLiEzvtylzFpN51Rt0k71FFYg/MMDbCHPJbQTWbIv2UO5Mxk1+Gkd/8BVeTu91Jlbtud/mqv3Xb9BVe67y09fpPkGRIIv0bhNKvJp+1Umco5E4zkyiHRfkPW8aB5BLmOQiZeTr9NbBljdJyHHujS05bZznxOvUw47shgiVB0x1a0sXVYqtH2S7I2fc0Vty0LaTiG0vTfoByB/ZTwP/uBvdcza9ARm9Jbu/PD9neVbQPNksT1Z/edpYnpk0D/3RTfQizHIxyTIm0ezSG7TZLyCs6fR+94vZN5feorlPIi/ss7DHkRqFfz1uDcP1PMNgYBjc49IwzOMZhgPD8J6Z3OL8IO5adBQ6lA607J4zmm34z8/Q20M2JYBXP9BeHcpuHmUp1+PVFCD5+1XQPhXuyB4x8pEY6d2MTzuJkW1K+mvx+LZZjvQczJlOYHo7sHE3ekUBQZT9uwhXBuHK4LjmoL2i0ynXs7vIOPP70WxgiT60vmYpCSXXrL4DvDnt3rKynhFo5l2E07qJ3TuOV+TbN52khfhep9s2F6L81hdt2ARKBfD3/Z4W1DhTHr2mHPcN8YefeAPM3v4b0rpj3dGATSzukVeUPoeO0FOksf55ye3H9cYJxPLngUl6xqz1RCfB/EO+GOce4THqvMNTfCT8BM4Zjr1KxnHqKVtB5LvhV0A8amtDFV95lfall17lPcrG3YDT/R6jUox8ntiZvcOmDKY3c2+Olb1Gfl+sv/7BGeqyjtcY382vYoOblvcc4/94F+Of1D//fYz/RZX/853An2BfW6FcB5KVS3dh7WaBf91QGomXLnJHTpUudEfeLK3ydFy6fniOsFDsmLwB0krPxEPOveKWL634JIcyeSf9YexFid+jRI56IqdmQRnx4e+ASS3QiuGjxGZLVKNt5er70Vb2TAh7BASfW5xS61sxJSTXNjQJ7inzcwLNvqAXHz/Ngf/JU5+1OXUNfp8QnCTMhjRnHLI05dQFgjn4oH9D0zKBf5b4iivw0d5AE1DhGjmnKez35zQF5JwVXn9DrZAzUMccClfDV6GhiVzP8TfIIN5PSvcHmpblTsy5rUGuz8EnZXOc+VdMEMoCYX9t0wSZ1QJr1Pe8yzznVGmOZ/7MUo8kzZOcRc0r5fpAU0PNNHx2N+TMX+T1h30ufLLbdTb8BZWyt6kWH69mWfrnL3apj+66zq4+BTNBLT7TSfZ85MnrSjTPUSaeK2N0J7ueM7fE8Ppadr3E5PpSdn2p7nr/9Z3hns/Z7iz0m+5qWtEQDDQ1+ppkXU5tfXbNNa6Pen0dw7M8JYbvT1LtgHM18vwXS/Xv90g83+bR8q/7Cv7VuvJ36fgto61XrmLPVG54OR7HKXsudNYKXDhDik8aFEHowHWkCGkJpEW98XgLpN0wE3gI0oc+i8fxjk4LTHJPIg0pPnewHVL8aXYvpPj+oiKYDuMTWI9Bup49zKo+O2m5fYFgacmyjB6cYVtrycgazp5LfPyVeJx/ns6Ynz4DSO6f7YjHmzFOZ2bNzsy+zj7oNttq4dpRV15W4LiYz2/V5Vfloe7k+dXSzCz+vWrW2ys8JEeGFV9RYlXzFarPH0K+47CYSf3D/BLMOzMze2ZmzszM3JmZ+aWZRXMy95/fmnFfekfa/ak/st6dQsq9D21+Kh5/AAfXmZlZpZnZszLzW624/4XX/yxQW+N6jV0vzcyh11Hu/+IyH66/xuqrk1maWaIRmbBfKshbDW13IcvXmsL0B/wewC/V4fiLkHUGOG7VbjDAawHf9c94fBxnR3xm8TnAtwO/j+nzoxRXZvb9VldmTkeqKzP3vjQxM//udDGzqDWjPLPEjxqAHrlEJ9AM9LPR+oOck1BOis7X49aftgvWe9MmsWdvU/Hps+WMGInEh+zp2HX4HFcDVAdv9hbglbIU+jywx8HeuodzzjqUNslKn0TOQN5HrPRx6MFIvMrYhiMxIpXKcSCBN2WRWIhFf8GI5Uhcm06fj24DwnJrOn1o+QEkNqRTtiexgq8Aca/6HPgNNto/DwwDthZGHMVH+b4/gD7NbcWK9g6ijy5/hn/sg2nRl+AThR1DaK3vQLafAdGSeG1WJhWagrW+GIjZkN6LxPJMmodcuSuTPrVJrjyVyT3avCOTWuc+VK47k3YGC0ouyqJPtg7EO8u1QMxVnzt/8nz6rOdVeOXQ+dyD/I4RVIXT+Fze9BG0gIex6OoRHNtvGVshCvsbYzsf7bYPiPnq+/3yLqRsYXT0W+HPLWDRj/ARwt1jaSuQ5wN35VBiORJvAzFEfaD+CFSjXHUKFHaZ2iS3XErzfIS+f/94KodsZqBrzUvRvY3xu893n+8+332++3z3+e7z3ee7z3ef7z7/P3z2s/e3CyztHK3dR7GYpHvStPR+Hf0lo9V3WzVfQMtV32nV5qa0+g4n9T3i6jua1HdWqe9yUth1dT9CfSfXJ2fiAUwfSqHlqWuslgGUTrzr3Epp9d1cT7ML6ju51HdPna+zT+LdYuz9T+rKJitNux+jvjvsApV9WIkGXzy0RFNvGzPUAJ38M3Gqz4Ysyh9ntFqPk4zOyyr5f+oniffY6z6PsnZ9hqXbWLqHpYdZeoql6ez9uSNYOp6l01k6m6WLWFrH0hUsvZulD7L0UZY+w9JtLN3D0sMsPcXSdLbvN4Kl41k6naWzWbqIpXUsXcHSu1n6IEsfZekzLN3G0j0sPczSUyxNZ+/3HcHS8SydztLZLF3E0jqWrmDp3Sx9kKWPsvQZlm5j6R6WHmbpqVHG/jKnrOyKnNyF1eEmOZxTmFeUVzh5aphQzu87C/PyC/MKJ1JcYEw1fm/TspwVvmAIbzUU5E3Ly59cSLNM/b4cDIfklVNzcmXvstCUBS6Pq7TSJRVMy59Sh6/ZnJiTi/cDavEOhcezqJxmnwjuHFrZKHurIZWDNK1XvzU0yb5gs5DXFJB9eaUz3ZOhaEYtawrnVYcb/LWTG2oFQtV7Q/VCXu3KJiiPpnKQXmEV1hASXAv6/F5kZN+a/TKKbIC/sq8F/kK9G+BaoNYre4U8X71UF/Q2+qT62mAfBYXW1LBXnEoyeZ0yKUPyBoPelbQM9fvymiCpmLexoQbyBWTyh8qlMqpDISGvJtCIe+/fuN+OZjFZjVt952cImngqmOzYXCJo373Ydz4F27/X8afqaKcuv8zyywxwfEV+3Dc9BTFPza/G+YcYUMvwNN24oH7msRifohsH1IDawsaBdKa7TRePFzHWFN240jJAO46Y2e8WFsPV/GrczmMD3L26+uuOCRFuZWOCSqvjwgaWf53QV3+rgf63M5um6MahxUO145Defqr+bbr86ri2dJh2HExjY70+//1C35kq/Dyg+QLt+G7W/hFd/rUs/1qWv9mq5c/SpQ/o8guJ+Q5NfpBnnF/9/FKXX523tLm147dZ/dfp+t9aln8tyy9a+5f/mC5/3zkvlF71FfKf0eVfXM7av5zSHt1NBL3/dOry4+0dmgqafmgmf7dAt+utunmeeo6MXl+9/PcEuo9v1c0DlSXG/Hr6KKt/Yv7E8p88y/wnuL7Fz4PUc35Uw6Tr8qt69erkq+/77ZX6l6+mX+ryq/NQgSXbLf3nT7do829n75vc7j07+w+2UEzNr76XuJvlt+n8Vz8eDGXy83W4mv9uk/FHTYcK2vf7JuJqNYsflv7jL++7/KfoVtY/2ct08a6I2yB+DTCR372SptOy+pff38cK3Op4rMVTEuOsFrcmxk8tnpoYF7V4Wt94p8HTE+OYFs8wXFdYwSobDPEBifFEiw9MjBNafFAi/mvxwYm4rsWH9MVrDZ6ZiMNa3J6Ir1o8KxE3tfjQRDzU4sMScU6Ln9d3DpgGH56IS1r8/ES80eIjDNdTVlg9qvFBi2f39XsNPjLRn7V437kpWnx0EmYhMfvDuB6n77RNtoOL9Ke+dlHfYbyE4etnlyTGDfw8QmSMEg7pzlnZyfjV32NcyvA4w5t1eIGF4urvONR3My9jeJaL4g8wAT9m+DpdOZsY3jyH4q8xfFgKxXPGUPw4e+mxM4XW/6Cu/iUEtyd+X6LGi2aG5+jw3zN8qQ7fw3D19zEqPthK8XwdXsTwEl05dQxXfx+kvlP5QYarv0tS34W8g+FrdfgXDFd/16O+83hqKsXV3/Oo74S+heHq75rU36rcx/D1Hi3/cwyv0OEnGL5ah49OM/bP8WnIn9y/CtKYn+jihsjw1Tr8Zobr973+K422+/u6dl9N8OT+/j+snP26cv5G+JPjhpleuwn/UGGdrt/tN9FXMOm/HxD+5LiRQiYq5yXV/zyG6+uJ57FZDOLVlHQc65Pjj9l5UTea4O0Eh3ZhcVsdq3/G8HE6ez6cbnwu1F6T8nHxaYTnZhifKzbDBJ9rUo5kgq8ywZ8gePL49TcT/m4TvMcEH2gzxqeb4DeY4P9lgv/SBH8J8ItTYFxgeqn7qu/YjM/TGjvAuJypA4zP2bphgHG7hAbgHLFv3FfXHz8wKf+3JvhOE/yAidwvBuDcOdn/Bww0LmfaQONzy24y4W8daHyu2OMDjc9X+1/kTxkpdOvq021Sfu9A4/PJ7IOM+S8fRMvfpSu/2IS/fBDtv1msXXzqPMGE/1kT/NVBxufGHTPhx999ZQG/3g6jB5v0i8HG58/dasIfNcHXm+CvmeD/GWzsVxlDjM+xmzzE5DxCE/xeE/xhE/ypIdRuSq3WbhtN+M+Y4MMyjc+382Qa8wczjc/n+60J/+ZM2u/07bst0/j8vCMm5VxtNznH1AT3m+BtJvjv7MbnCz5nwv+mCd5rgg/KMsYvy2L9boz2ftcUghusv6YEAwF5SvNKr1wTqPUFpzQHA9V+X2NoSsjb2Oz3TfFW1+QXTZPKpuBhUXk1zc3kwCh+r9spJH5JHgpXS24pwSndZPYzc6dTknDnXm5okqRpzcGGJtntv87vd7lcKxbMrZJmNcPffOlsS/AUzgs00QPczvo5gln59ISuc/mh/9fKM/Us8hTi4xBnxan+lP+rqhKWG/ygb6jeG/TVSkFfnbtSnr7CVyMHgu55lfkSLY0cYFfpdVdOk8D0agXmOgslCUsKeptIa07DP1Nr/OzARE+RJDUEyF0SPHzvXJ7dOAt+/bMVZ5NF97jHWWQxeMLhq3P1PUfx1bzFWhUqz9FKledupcpzt1Ll17JS5TlYqfKcrLToHK206NyttOhsK18TlENyuK4ur0aQpOvKFkged2WVJAl9R6tKcqNUg0eohgQDSJJqA9Iyf6Da65dqoduFJG+4RagJYFiVfbV504uLphozSX03DCUwfHClQG861oYbG1dCFo6S+u4zMlZJmr2gtNwluebNwgNiSc3Zd6b1/NmzK11VUlXpTI8LOTRF1GoBclCgIM26cV5pubtMwDuUKqY/tbKkhD8DsP9TPnW89FDCmlCYaC4kJJzjgZf6GhieBZtUTcPTajVcecVnde4uOdsxuXjuBEkDE/VzIK62Dk4YZ6l1jE+h1JZNDoxkEDvJMenoR93lfo/41Nc86bBMfYv2HUiZLMbkYNrk5jM9RDZJGv4oAdrX75cSR+5+vSN2dWbEUzYNFEg+gldXo37PYJ4vkac2pXDIV5t89K5hPzI7DlfLTI8D1dW3nyOf9d3Z9FRnI8dNOu/UsOJGhzYb9BGDI1n1XAan/OrdANRTY13SGcfJ3kWOxk2GuUOb9eXXhgJSPYyhYDx6FqthD8M4xiZH3+Lh0vqIxE501Tun9nBkvXbJxwrrVawOhTiPSJysndQYZ3XcbkkJd3xs8iHBhjEj6cTg5EK0pyoblaI9slxbguFB5ybng2vLpifrGoSDr3dOti7U+AJ1endKnCau1YCM0l/vrGqdTPKYeJILnfVR0QYDrsH57Wbd3eQYbqP25M7x1pmC/GbK6ADuZLf5Fg6aNhgGDbRLnPKuu6Y53RmusZOX9Ye3J1tVPYfbYO5CT9I2qIT+mPFkV25e2dfyzsLk06p1OfCwaBrX/g9pqXiEDYoAAA=='
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''


def main2():
    stdin = open('/dev/stdin')
    N, Y = map(int, stdin.readline().split())
    for i in range(N + 1):
        a = Y - 10000*i
        if a < 0:
            break
        for j in range(N - i + 1):
            b = a - 5000*j
            if b < 0:
                break
            if (N - i - j) * 1000 == b:
                print(i, j, N - i - j)
                return 0
    print(-1, -1, -1)
'''

Solution (Python):
N , Y = map(int , input().split())
for k1 in range(N + 1):
    for k5 in range(N + 1 - k1):
        k10 = N - k1 - k5
        if k1 + k5 + k10 == N and 1000 * k1 + 5000 * k5 + 10000 * k10 == Y and k10 >= 0:
            print(k10 , k5 , k1)
            exit(0)
print("-1 -1 -1 ")

Solution (Python):
import sys
N, Y = map(int, input().split())

for i in range((Y // 10000) + 1):
    for j in range((Y // 5000) + 1):
        tmp = N - i - j
        if tmp >= 0:
            ans = (i * 10000) + (j * 5000) + ((N - i - j) * 1000)
            if ans == Y:
                print(i, j, tmp)
                sys.exit()
print(-1, -1, -1)