ZS the Coder has recently found an interesting concept called the Birthday Paradox. It states that given a random set of 23 people, there is around 50% chance that some two of them share the same birthday. ZS the Coder finds this very interesting, and decides to test this with the inhabitants of Udayland.

In Udayland, there are 2^{n} days in a year. ZS the Coder wants to interview k people from Udayland, each of them has birthday in one of 2^{n} days (each day with equal probability). He is interested in the probability of at least two of them have the birthday at the same day. 

ZS the Coder knows that the answer can be written as an irreducible fraction $\frac{A}{B}$. He wants to find the values of A and B (he does not like to deal with floating point numbers). Can you help him?


-----Input-----

The first and only line of the input contains two integers n and k (1 ≤ n ≤ 10^18, 2 ≤ k ≤ 10^18), meaning that there are 2^{n} days in a year and that ZS the Coder wants to interview exactly k people.


-----Output-----

If the probability of at least two k people having the same birthday in 2^{n} days long year equals $\frac{A}{B}$ (A ≥ 0, B ≥ 1, $\operatorname{gcd}(A, B) = 1$), print the A and B in a single line.

Since these numbers may be too large, print them modulo 10^6 + 3. Note that A and B must be coprime before their remainders modulo 10^6 + 3 are taken.


-----Examples-----
Input
3 2

Output
1 8
Input
1 3

Output
1 1
Input
4 3

Output
23 128


-----Note-----

In the first sample case, there are 2^3 = 8 days in Udayland. The probability that 2 people have the same birthday among 2 people is clearly $\frac{1}{8}$, so A = 1, B = 8.

In the second sample case, there are only 2^1 = 2 days in Udayland, but there are 3 people, so it is guaranteed that two of them have the same birthday. Thus, the probability is 1 and A = B = 1.

Difficulty: interview

Starter code:

Solutions:
m = 10** 6 + 3

n, k = list(map(int, input().split()))
p = 1
for i in range(n):
    p *= 2
    if p > k:
        break
if p < k:
    print('1 1')
    return

gcd = tmp = k - 1
while tmp:
    gcd -= tmp % 2
    tmp //= 2
b = pow(2, (k - 1) * n - gcd, m)
a = 1
mem = [-1]*100
for i in range(1, k):
    cnt = 0
    while i % 2 == 0:
        i //= 2
        cnt += 1
    if mem[cnt] == -1:
        mem[cnt] = pow(2, n - cnt, m)
    a = a * (mem[cnt] - i + m) % m
    if a == 0:
        break
print((b - a + m) % m, b)


import sys
mod = 10 ** 6 + 3

n, k = list(map(int, input().split()))

if n < 100:
    if 2 ** n < k:
        print(1, 1)
        return

def factor(n, p):
    if n < p: return 0
    return n // p + factor(n // p, p)

def inv(n):
    return pow(n, mod - 2, mod)

# 2^nk - P(2^n,k) / 2^nk

two = inv(pow(2, n + factor(k - 1, 2), mod))

v = 1

if k >= mod:
    v = 0
else:
    N = pow(2, n, mod)
    for i in range(k):
        v = v * (N - i) % mod

A = (pow(2, n * k, mod) - v) * two % mod
B = pow(2, n * k, mod) * two % mod

print(A, B)


#!/usr/bin/env python3
import os
MOD = 1000003
inv2 = pow(2, MOD - 2, MOD)

def logm(n, m):
    # log = 3.3
    # return (3, False)
    ans = 0
    whole = True
    while n >= m:
        whole = whole and (n % m == 0)
        ans += 1
        n //= m
    if n == 1:
        return (ans, whole)
    return (ans, False)



def fact_exp(n, k):
    ans = 0
    while n != 0:
        n //= k
        ans += n
    return ans


def main():
    n, k = list(map(int, input().split()))
    e2 = n + fact_exp(k - 1, 2)
    div = pow(2, n * k - e2, MOD)

    (e, w) = logm(k, 2)
    if e > n or (e == n and not w):
        print(1, 1)
        return

    num = 1
    Nr = pow(2, n, MOD)
    # N * (N-1) * ... * (N - k + 1)
    # (-0) * (-1) * 
    for t in range(1, k):
        i = (Nr - t) % MOD
        if i == 0:
            num = 0
            break

        p = 0
        while t % 2 == 0:
            p += 1
            t //= 2

        num = num * i * pow(inv2, p, MOD) % MOD

    print((div - num) % MOD, div)

def __starting_point():
    main()

__starting_point()

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

MOD = 1000003

K = k - 1

max_deg = 0

while K > 0:
    max_deg += K // 2
    K //= 2

den_deg = n * (k-1) - max_deg

kk = 1
for i in range(n):
    kk *= 2
    if kk >= k: break
else:
    print(1, 1)
    return

numerator = 1
two_p_n = pow(2, n, MOD)
for i in range(1, min(k, MOD + 1)):
    numerator *= (two_p_n - i + MOD) % MOD
    if numerator == 0: break
    numerator %= MOD

rev = (MOD + 1) // 2
numerator *= pow(rev, max_deg, MOD)
numerator %= MOD

denumerator = pow(2, den_deg, MOD)
numerator = (denumerator + MOD - numerator) % MOD

print(numerator, denumerator)

import math

def euclid_algorithm(a, b):
    t1, t2 = abs(a), abs(b)
    #saving equalities:
    #t1 == x1 * a + y1 * b,
    #t2 == x2 * a + y2 * b. 
    x1, y1, x2, y2 = int(math.copysign(1, a)), 0, 0, int(math.copysign(1, b))
    if t1 < t2:
        t1, t2 = t2, t1
        x1, y1, x2, y2 = x2, y2, x1, y1

    while t2 > 0:
        k = int(t1 // t2)
        t1, t2 = t2, t1 % t2
        #t1 - k * t2 == (x1 - k * x2) * a + (y1 - k * y2) * b
        x1, y1, x2, y2 = x2, y2, x1 - k * x2, y1 - k * y2

    return t1, x1, y1

def opposite_element(x, p):
    gcd, k, l = euclid_algorithm(x, p)
    if gcd != 1:
        return -1
    return k % p

def solve(n, k):
    if n < 70 and k > (1<<n):
        return (1, 1)
    s, l = 0, k-1
    while l > 0:
        l >>= 1
        s += l

    p = 10 ** 6 + 3
    x = pow(2, n, p)
    t = pow(opposite_element(2, p), s, p)
    q = (pow(2, n*(k-1), p) * t) % p
    r = 1
    if k > p:
        r = 0
    else:
        for i in range(1, k):
            r *= (x-i)
            r %= p
        
    return ((q - r*t)%p, q)
    
    
n, k = list(map(int, input().split()))
x, y = solve(n, k)
print(x, y)


m = 10** 6 + 3

n, k = map(int, input().split())
p = 1
for i in range(n):
    p *= 2
    if p > k:
        break
if p < k:
    print('1 1')
    return

gcd = tmp = k - 1
while tmp:
    gcd -= tmp % 2
    tmp //= 2
b = pow(2, (k - 1) * n - gcd, m)
a = 1
mem = [-1]*100
for i in range(1, k):
    cnt = 0
    while i % 2 == 0:
        i //= 2
        cnt += 1
    if mem[cnt] == -1:
        mem[cnt] = pow(2, n - cnt, m)
    a = a * (mem[cnt] - i + m) % m
    if a == 0:
        break
print((b - a + m) % m, b)

m = 10** 6 + 3
n, k = map(int, input().split())
p = 1
for i in range(n):
    p *= 2
    if p > k:
        break
if p < k:
    print('1 1')
    return
gcd = tmp = k - 1
while tmp:
    gcd -= tmp % 2
    tmp //= 2
b = pow(2, (k - 1) * n - gcd, m)
a = 1
mem = [-1]*100
for i in range(1, k):
    cnt = 0
    while i % 2 == 0:
        i //= 2
        cnt += 1
    if mem[cnt] == -1:
        mem[cnt] = pow(2, n - cnt, m)
    a = a * (mem[cnt] - i + m) % m
    if a == 0:
        break
print ((b - a + m) % m, b)

import math
n, k = [int(x) for x in input().split()]
if n<70 and k>2**n:
    print(1,1)
    return
mod = int(1e6)+3

def fastpow(a,b):
    t, ans = a, 1
    while b:
        if(b&1):
            ans = ans*t%mod
        t = t*t %mod
        b>>=1
    return ans

t=k-1
cnt=0
while t:
    cnt += t>>1
    t>>=1

x=0
t=fastpow(2,n)
if k<mod:
    x=1
    for i in range(1,k):
        x = x*(t-i)%mod
y=fastpow(2,n*(k-1))

inv = fastpow(2,mod-2)
inv = fastpow(inv,cnt)

x=(x*inv%mod+mod)%mod
y=(y*inv%mod+mod)%mod

x=(y-x+mod)%mod

print(x,y)

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

mod = 1000003

if n < 70 and 2**n < k:
	print('1 1\n')
	return

def modpow(a, e):
	ret = 1
	while e > 0:
		if e%2 == 1:
			ret = (ret*a)%mod
		a = (a*a)%mod
		e = e//2
	return ret

def pw(a, e):
	ret = 1
	while e > 0:
		if e%2 == 1:
			ret *= a
		a *= a
		e = e//2
	return ret

par = n
for i in range(1, 100):
	par += ((k-1)//pw(2, i))

mul = 1
cur = modpow(2, n)
for i in range(k):
	mul = (cur*mul)%mod
	cur -= 1
	if mul == 0:
		break
if mul != 0:
	mul = (mul*modpow(modpow(2, par), mod-2))%mod

up = (modpow(2, n*k-par)-mul)%mod
if up < 0:
	up += mod

print(up, end=' ')
print(modpow(2, n*k-par))

n, k = list(map(int, input().split()))
if n <= 100 and k > (2 ** n):
    print(1, 1)
    return
MOD = 1000 * 1000 + 3
INV2 = (MOD + 1) // 2
def add(x, y):
    return (x + y) % MOD
def sub(x, y):
    rez = x - y
    rez %= MOD
    rez += MOD
    rez %= MOD
    return rez
def mult(x, y):
    return (x * y) % MOD
def binpow(x, y):
    if x == 1 or y == 0:
        return 1
    if x == 0:
        return 0
    rez = binpow(x, y//2)
    rez = mult(rez, rez)
    if y % 2 == 1:
        rez = mult(rez, x)
    return rez

A = n * k
B = n
temp = k - 1
while temp >= 2:
    B += temp // 2
    temp //= 2
G = min(A, B)
# print('G=', G)
m = binpow(2, n)
# print('m=', m)
P = 1
for i in range(k):
    P = mult(P, sub(m, i))
    if P == 0:
        break
P = mult(P, binpow(INV2, G))
Q = binpow(m, k)
Q = mult(Q, binpow(INV2, G))
P = sub(Q, P)
print(P, Q)