Misha and Vanya have played several table tennis sets. Each set consists of several serves, each serve is won by one of the players, he receives one point and the loser receives nothing. Once one of the players scores exactly *k* points, the score is reset and a new set begins.

Across all the sets Misha scored *a* points in total, and Vanya scored *b* points. Given this information, determine the maximum number of sets they could have played, or that the situation is impossible.

Note that the game consisted of several complete sets.
The first line contains three space-separated integers *k*, *a* and *b* (1 ≤ *k* ≤ 10<sup class="upper-index">9</sup>, 0 ≤ *a*, *b* ≤ 10<sup class="upper-index">9</sup>, *a* + *b* &gt; 0).
Note that the rules of the game in this problem differ from the real table tennis game, for example, the rule of "balance" (the winning player has to be at least two points ahead to win a set) has no power within the present problem.
11 11 5
1
11 2 3
-1
1 5 9
14
2 3 3
2
1 1000000000 1000000000
2000000000
2 3 5
3
1000000000 1000000000 1000000000
2
1 0 1
1
101 99 97
-1
1000000000 0 1
-1
137 137 136
1
255 255 255
2
1 0 1000000000
1000000000
123 456 789
9
666666 6666666 666665
-1
1000000000 999999999 999999999
-1
100000000 100000001 99999999
-1
3 2 1000000000
-1
999999999 1000000000 999999998
-1
12938621 192872393 102739134
21
666666666 1230983 666666666
1
123456789 123456789 123456787
1
5 6 0
-1
11 0 12
-1
2 11 0
-1
2 1 0
-1
10 11 12
2
11 12 5
-1
11 12 3
-1
11 15 4
-1
2 3 1
-1
11 12 0
-1
11 13 2
-1
11 23 22
4
10 21 0
-1
11 23 1
-1
11 10 12
-1
11 1 12
-1
11 5 12
-1
11 8 12
-1
11 12 1
-1
5 4 6
-1
10 1 22
-1
2 3 0
-1
11 23 2
-1
2 1000000000 1000000000
1000000000
11 0 15
-1
11 5 0
-1
11 5 15
-1
10 0 13
-1
4 7 0
-1
10 2 8
-1
11 5 22
2
11 13 0
-1
2 0 3
-1
10 10 0
1
10 11 10
2
3 5 4
2
11 22 3
2
11 12 10
-1
10 2 13
-1
5 6 1
-1
10 21 5
-1
10 11 9
-1
10 17 7
-1
3 4 1
-1
4 5 3
-1
11 3 23
-1
11 3 12
-1
2 5 0
-1
10 21 2
-1
5 1 6
-1
10 11 0
-1
10 9 11
-1
7 10 5
-1
5 7 2
-1
6 5 7
-1
11 16 2
-1
11 1000000000 10
-1
10 2 21
-1
10 15 1
-1
5 2 8
-1
11 10000000 10
-1
10 1 101
-1
20 24 2
-1
11 24 0
-1
11 17 4
-1
11 13 1
-1
10 11 2
-1
11 23 3
-1
10 99 0
-1
6 7 4
-1
11 1 22
2
11 2 13
-1
2 1 3
-1
11 6 18
-1
11 122 4
-1
11 21 10
-1
3 2 4
-1
9 11 2
-1
11 0 7
-1
5 9 4
-1
100 105 5
-1
11 15 0
-1
5 6 4
-1
3 4 2
-1
2 9 0
-1
11 13 11
2
11 15 5
-1
11 4 15
-1
10 1 0
-1
11 16 8
-1
10 43 0
-1
11 13 5
-1
11 22 0
2
5 6 3
-1
2 1 11
-1
4 5 1
-1
11 23 0
-1
11 4 12
-1
12 13 1
-1
10 19 9
-1
3 7 2
-1
12 18 0
-1
11 25 3
-1
11 23 5
-1
2 1 5
-1
2 0 5
-1
11 24 1
-1
10 11 4
-1
2 0 1
-1
10 0 21
-1
3 0 7
-1
18 11 21
-1
3 7 0
-1
5 11 0
-1
11 5 13
-1
11 9 34
-1
11 13 9
-1
10 0 22
-1
5 1 12
-1
11 2 12
-1
11 9 12
-1
11 24 2
-1
11 23 6
-1
11 20 4
-1
2 5 1
-1
120 132 133
2
11 111 4
-1
10 7 11
-1
6 13 0
-1
5 11 1
-1
11 5 27
-1
11 15 3
-1
11 0 13
-1
11 13 10
-1
11 25 5
-1
4 3 5
-1
100 199 100
2
11 2 22
2
10 20 2
2
5 5 0
1
10 11 1
-1
11 12 2
-1
5 16 3
-1
12 14 1
-1
10 22 2
-1
2 4 0
2
11 34 7
-1
6 13 1
-1
11 0 23
-1
20 21 19
-1
11 33 22
5
10 4 41
-1
3 4 0
-1
11 15 7
-1
5 0 6
-1
11 3 22
2
2 6 0
3
10 11 11
2
11 33 0
3
4 6 2
-1
11 76 2
-1
7 9 4
-1
10 43 1
-1
22 25 5
-1
3 5 2
-1
11 1 24
-1
12 25 3
-1
11 0 22
2
4 2 5
-1
11 13 3
-1
11 12 9
-1
11 35 1
-1
5 3 6
-1
5 11 4
-1
12 8 14
-1
10 12 9
-1
11 12 13
2
11 15 2
-1
11 23 4
-1
5 3 11
-1
6 13 2
-1
4 1 0
-1
11 32 10
-1
2 11 1
-1
10 11 7
-1
11 26 0
-1
100 205 5
-1
4 0 2
-1
10 11 8
-1
11 22 5
2
4 0 5
-1
11 87 22
9
4 8 0
2
9 8 17
-1
10 20 0
2
10 9 19
-1
12 2 13
-1
11 24 5
-1
10 1 11
-1
4 0 9
-1
3 0 1
-1
11 12 4
-1
3 8 2
-1
11 17 10
-1
6 1 13
-1
11 25 0
-1
12 0 13
-1
10 5 20
2
11 89 2
-1
2 4 1
2
10 31 0
-1
11 34 1
-1
999 6693 8331
14
10 55 1
-1
11 12 8
-1
1 9 22
31
7572 9186 895
-1
3 2 11
-1
2 1 4
2
11 10 19
-1
100 199 99
-1
2537 8926 1523
-1
11 0 5
-1
5 1 11
-1
12 13 5
-1
10 12 0
-1
5 4 7
-1
12 25 1
-1
7 9 0
-1
4 15 0
-1
5 11 2
-1
11 58 3
-1
10 11 5
-1
10 3 1003
-1
11 14 0
-1
11 8 23
-1
11 22 4
2
5 2 0
-1
11 1 35
-1
12 25 5
-1
11 37 4
-1
20 42 3
-1
10 12 2
-1
4 1 5
-1
5 16 0
-1
11 13 7
-1
5 0 3
-1
11 2 11
1
3 2 2000
-1
3 0 4241
-1
2 12 11
11
10 2 82
-1
11 0 11
1
11 20 20
2
5 0 10
2
11 1 0
-1
11 13 13
2
#include <bits/stdc++.h>
using namespace std;

using ll = long long;
using ld = long double;
using pll = pair<ll,ll>;
using vll = vector<ll>;
using vpll = vector<pll>; 
 
#define tcT template<class T
#define tcTU tcT, class U
 
#define f first
#define s second
#define all(x) begin(x), end(x)

// loops
#define FOR(i,a,b) for (ll i = (a); i < (b); ++i)
#define ROF(i,a,b) for (ll i = (b)-1; i >= (a); --i)
#define trav(a,x) for (auto& a: x)

//min heap
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;		

 
const ll MOD = 1e9+7; // 998244353;
const ll MX = 2e5+5;
const ll INF = 1e18; // not too close to LLONG_MAX
const ld PI = acos((ld)-1);
const ll dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1}; // for every grid problem!!
map<pll,char> dirFromDiff = {{{1,0},'R'},{{0,1},'U'},{{-1,0},'L'} , {{0,-1},'D'}};
map<char,pll> diffFromDir = {{'R',{1,0}} , {'U',{0,1}}, {'L',{-1,0}},{'D',{0,-1}}};

mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count()); 
vll dijkstra(ll x, vector<vpll>& v){	ll n = v.size();	vll dis(n,INF),vis(n);	dis[x] = 0;	pqg<pll> q;	q.push({0,x});
	while(!q.empty()){	pll a = q.top();	q.pop();	ll ind = a.s;	if(vis[ind] == 1)	continue;	vis[ind] = 1;
	for(auto i:v[ind]){	if(vis[i.s]==1)	continue;	dis[i.s] = min(dis[i.s],dis[ind]+i.f);	q.push({dis[i.s],i.s});}} return dis;
}	
vll ZFUN(string& s){	ll n = s.length();	vll z(n);
	for(ll i = 1,l=0,r=0;i<n;i++){	
		if(i<=r)	
			z[i] = min(z[i-l],r-i+1);
		while(i+z[i]<n && s[z[i]]==s[i+z[i]])	
		z[i]++;	
		ll newr = i+z[i]-1;
		if(newr>r){	l = i;	r = newr;}
	}
	return z;
}

vll KMP(string& s){	ll n = s.length();	vll p(n);
	for(ll i = 1;i<n;i++){	
		ll k = p[i-1];	
		while(k>0 && s[i] != s[k])	
			k = p[k-1];
		if(s[i]==s[k])	
			k++;	
		p[i] = k;}	
	return p;
}

// helper funcs
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { return 31-__builtin_clz(x); } // floor(log2(x)) 
ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down
 
 
tcTU> T fstTrue(T lo, T hi, U f) {hi ++; assert(lo <= hi); while (lo < hi) {T mid = lo+(hi-lo)/2;
		f(mid) ? hi = mid : lo = mid+1; } return lo;}
tcTU> T lstTrue(T lo, T hi, U f) {lo --; assert(lo <= hi);while (lo < hi) {T mid = lo+(hi-lo+1)/2;	
		f(mid) ? lo = mid : hi = mid-1;} return lo;}

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template<class T> 
using oset = tree<T, null_type, less<T>, rb_tree_tag,tree_order_statistics_node_update>;
struct Lnode{
	ll sum,cnt,inc;
	Lnode(): sum(0),cnt(0),inc(0){;}
};

tcT> class SEGL{
public:
	vector<Lnode> t;	ll n;
	ll defaultReturn = 0;
	
	void proc(ll ind , Lnode b){
		t[ind].inc += b.inc;
		t[ind].sum += b.inc*t[ind].cnt;
	}
	void push(ll ind){
		proc(2*ind,t[ind]);	proc(2*ind+1,t[ind]);
		t[ind].inc = 0;
	}
	Lnode combine(const Lnode& a, const Lnode& b){
		Lnode c;
		c.sum = a.sum+b.sum;
		c.cnt = a.cnt+b.cnt;
		return c;
	}
	SEGL(vector<T>& v){	n = v.size();	t.resize(4*n);	build(1,0,n-1,v);}
	void build(ll ind , ll tl ,ll tr ,vector<T>& v){	
		if(tl==tr){	
			t[ind].sum = v[tl];	
			t[ind].cnt = 1;
			return;
		}
		ll tm = (tl+tr)/2;	build(2*ind,tl,tm,v);	build(2*ind+1,tm+1,tr,v);	
		t[ind] = combine(t[2*ind],t[2*ind+1]);}
	void update(ll ind ,ll tl , ll tr ,ll l, ll r, Lnode val){	if(l>r){return;}
		if(tl==l && tr==r){	proc(ind,val);return;}	push(ind);	ll tm = (tl+tr)/2;	
		update(2*ind,tl,tm,l,min(tm,r),val);	update(2*ind+1,tm+1,tr,max(l,tm+1),r,val);
		t[ind] = combine(t[2*ind],t[2*ind+1]);}
	T query(ll ind ,ll tl ,ll tr , ll l , ll r){if(l>r){return defaultReturn;}
		if(tl==l && tr==r){	return t[ind].sum;}
		push(ind);	ll tm = (tl+tr)/2;	
		T a = query(2*ind,tl,tm,l,min(tm,r));	T b = query(2*ind+1,tm+1,tr,max(l,tm+1),r);
		return a+b;}
};
class SEG{
public:
	vll t;ll n,defaultReturn = -INF;
	ll combine(const ll & a , const ll & b){	return max(a,b);	}
	SEG(const vll& v){n = v.size();	t.resize(v.size()*4);	build(1,0,n-1,v);}
	void build(ll ind , ll tl ,ll tr ,const vll& v){if(tl==tr)	{	t[ind] = v[tl];	return;}
		ll tm = (tl+tr)/2;	build(2*ind,tl,tm,v);	build(2*ind+1,tm+1,tr,v);	t[ind] = combine(t[2*ind],t[2*ind+1]);}
	void update(ll ind ,ll tl , ll tr ,ll pos, ll val){	if(tl==tr){	t[ind] = val;return;}
		ll tm = (tl+tr)/2;	if(pos<=tm)		update(2*ind,tl,tm,pos,val);	else update(2*ind+1,tm+1,tr,pos,val);
		t[ind] = combine(t[2*ind],t[2*ind+1]);}
	ll query(ll ind ,ll tl ,ll tr , ll l , ll r){if(l>r){return defaultReturn;}
		if(tl==l && tr==r){	return t[ind];}
		ll tm = (tl+tr)/2;	ll a = query(2*ind,tl,tm,l,min(tm,r));	ll b = query(2*ind+1,tm+1,tr,max(l,tm+1),r);return combine(a,b);}
};


ll binpow(ll x,ll n){if(n==0)	return 1;ll temp = binpow(x,n/2);temp  =(temp*temp)%MOD;
			if(n&1) {temp = (temp*x)%MOD;}return temp;}

void solve(){
	;
}

int main(){
	cin.sync_with_stdio(0);     cin.tie(0);     cout.tie(0);
	ll t;	cin>>t;
	while(t--)	solve();
}











