#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

inline bool compare(const int &a,const int &b)
{
	return a >= b;
}

int n,x,a[100050],num[100050];

int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,compare);
		sort(num,num+n);
		for(int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[1000500],num[1000500];

inline bool comp(const int &a, const int &b)
{
	return a <= b;
}
int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(register int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		stable_sort(a,a+n,comp);
		stable_sort(num, num+n);
		for(register int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[100050],num[100050];

int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,[=](int a, int b){return a <= b;});
		sort(num,num+n);
		for(int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[1000500],num[1000500];

int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,[=](int a, int b){return a <= b;});
		sort(num,num+n);
		for(int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[1000500],num[1000500];

inline bool comp(int a, int b)
{
	return a <= b;
}
int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(register int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,comp;
		for(register int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[1000500],num[1000500];

inline bool comp(const int &a, const int &b)
{
	return a <= b;
}
int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(register int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,comp);
		sort(num, num+n);
		for(register int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#pragma GCC optimize(3)
#pragma GCC target("avx")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(2)
#include <bits/stdc++.h>
#define D(x) cout << #x << "=" << x << endl
#define De(...)
using namespace std;

int _;

int n,x,a[1000500],num[1000500];

inline bool comp(int a, int b)
{
	return a <= b;
}
int main()
{
	for(scanf("%d",&_);_;_--)
	{
		int ans=0,cnt=-1;
		scanf("%d%d",&n,&x);
		for(register int i=0;i<n;i++)
		{
			scanf("%d",a+i);
			num[i]=(x-1)/a[i]+1;
		}
		sort(a,a+n,comp);
		for(register int i=0;i<n;i++)
			if(i-cnt >= num[i])
			{
				cnt=i;
				ans++;
			}
		printf("%d\n",ans);
	}
	return 0;
}


#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 1000000007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-9;
const int N = 200 + 5;
const int M = 21;

int cnt = 0, tot = 1;
int n, m;
//-7 1
//2  2
//8  2
int a[N], d[N];
bool check(int x) {
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (x < 1900)
				return false;
		}
		else {
			if (x >= 1900)
				return false;
		}
		x += a[i];
	}
	return true;
}
bool judge(int x,int r){
	int y = 0;
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (r + y < 1900)
				return false;
		}
		else {
			if (x + y >= 1900)
				return false;
		}
		y += a[i];
	}
	return true;
}
int main() {
	cin >> n;
	int s = 0, x, y, lv, suc;

	int t = 0;
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &a[i], &d[i]);
		t += a[i];
	}
	int l = -1e9, r = 1e9;
	if (d[0] == 1) {
		l = 1900;
	}
	else {
		r = 1900;
	}
	int m;
	while (r-l>1) {
		m = (l + r) >> 1;
		if (judge(m, r-1) == true) {
			l = m;
		}
		else {
			r = m;
		}
	}
	if (!check(l)) {
		puts("Impossible");
	}
	else {
		if (r==1e9) {
			puts("Infinity");
		}
		else {
			printf("%d\n", l+t);
		}
	}
}
//int main() {
//	cin >> n;
//	int s = 0;
//	int lv = 0;
//	int x, d;
//	int flag = 0;
//	int y;
//	int t = 0;
//	scanf("%d%d", &y, &d);
//	lv = d;
//	if (lv == 1) {
//		s = 1e9;
//	}
//	else if(lv==2){
//		s = 1899;
//	}
//	int suc = 1;
//	x = y;
//	for (int i = 1; i < n; i++) {
//		scanf("%d%d", &y, &d);
//		s += x;
//		if (flag == 1) {
//			if (s+t+1 >= 1900 && d == 2) {
//				suc = 0;
//			}
//			if (s < 1900 && d == 1) {
//				suc = 0;
//			}
//		}
//		if (d == 2) {
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899;
//					t = x;
//				}
//			}
//		}
//		else if(d==1){
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899 + x;
//					t = x;
//				}
//			}
//		}
//		lv = d;
//		t += x;
//		x = y;
//	}
//	t += x;
//	if (suc == 0) {
//		puts("Impossible");
//		return 0;
//	}
//	if (flag == 0) {
//		if (s >= 2 * 1e8) {
//			puts("Infinity");
//		}
//		else if (s <= 19099) {
//			printf("%d\n", 1899 + t);
//		}
//	}
//	else if (flag == 1) {
//		printf("%d\n", s+t);
//	}
//	return 0;
//}


#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 1000000007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-9;
const int N = 200 + 5;
const int M = 21;

int cnt = 0, tot = 1;
int n, m;
//-7 1
//2  2
//8  2
int a[N], d[N];
bool check(int x) {
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (x < 1900)
				return false;
		}
		else {
			if (x >= 1900)
				return false;
		}
		x += a[i];
	}
	return true;
}
bool judge(int x,int r){
	if (x > r)swap(x, r);
	int y = 0;
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (r + y < 1900)
				return false;
		}
		else {
			if (x + y >= 1900)
				return false;
		}
		y += a[i];
	}
	return true;
}
int main() {
	cin >> n;
	int s = 0, x, y, lv, suc;

	int t = 0;
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &a[i], &d[i]);
		t += a[i];
	}
	int l = -1e9, r = 1e9;
	if (d[0] == 1) {
		l = 1900;
	}
	else {
		r = 1899;
	}
	int m;
	while (l<r) {
		m = (l + r+1) >> 1;
		if (judge(m, r) == true) {
			l = m;
		}
		else {
			r = m-1;
		}
	}
	if (!check(l)) {
		puts("Impossible");
	}
	else {
		if (r==1e9) {
			puts("Infinity");
		}
		else {
			printf("%d\n", l+t);
		}
	}
}
//int main() {
//	cin >> n;
//	int s = 0;
//	int lv = 0;
//	int x, d;
//	int flag = 0;
//	int y;
//	int t = 0;
//	scanf("%d%d", &y, &d);
//	lv = d;
//	if (lv == 1) {
//		s = 1e9;
//	}
//	else if(lv==2){
//		s = 1899;
//	}
//	int suc = 1;
//	x = y;
//	for (int i = 1; i < n; i++) {
//		scanf("%d%d", &y, &d);
//		s += x;
//		if (flag == 1) {
//			if (s+t+1 >= 1900 && d == 2) {
//				suc = 0;
//			}
//			if (s < 1900 && d == 1) {
//				suc = 0;
//			}
//		}
//		if (d == 2) {
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899;
//					t = x;
//				}
//			}
//		}
//		else if(d==1){
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899 + x;
//					t = x;
//				}
//			}
//		}
//		lv = d;
//		t += x;
//		x = y;
//	}
//	t += x;
//	if (suc == 0) {
//		puts("Impossible");
//		return 0;
//	}
//	if (flag == 0) {
//		if (s >= 2 * 1e8) {
//			puts("Infinity");
//		}
//		else if (s <= 19099) {
//			printf("%d\n", 1899 + t);
//		}
//	}
//	else if (flag == 1) {
//		printf("%d\n", s+t);
//	}
//	return 0;
//}


#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 1000000007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-9;
const int N = 200 + 5;
const int M = 21;

int cnt = 0, tot = 1;
int n, m;
//-7 1
//2  2
//8  2
int main() {
	cin >> n;
	int s = 0, x, y, d, lv, suc;

	int time = 0;
	suc = 1;
	int t = 0;
	int value = 0;
	int from = -1e9;
	int to = 1e9;
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &y, &d);
		if (d == 1) {
			from = max(from,1900-t);
		}
		else {
			to = min(to, 1899 - t);
		}
		t += y;
	}
	if (from>to) {
		puts("Imposible");
	}
	else {
		if (to==1e9) {
			puts("Infinity");
		}
		else {
			printf("%d\n", to+t);
		}
	}
}


#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 1000000007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-9;
const int N = 200 + 5;
const int M = 21;

int cnt = 0, tot = 1;
int n, m;
//-7 1
//2  2
//8  2
int a[N], d[N];
bool check(int x) {
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (x < 1900)
				return false;
		}
		else {
			if (x >= 1900)
				return false;
		}
		x += a[i];
	}
	return true;
}
bool judge(int x,int r){
	int y = 0;
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (r + y < 1900)
				return false;
		}
		else {
			if (x + y >= 1900)
				return false;
		}
		y += a[i];
	}
	return true;
}
int main() {
	cin >> n;
	int s = 0, x, y, lv, suc;

	int t = 0;
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &a[i], &d[i]);
		t += a[i];
	}
	int l = -1e9, r = 1e9;
	if (d[0] == 1) {
		l = 1900;
	}
	else {
		r = 1900;
	}
	int m;
	while (r-l>1) {
		m = (l + r) >> 1;
		if (judge(m, r) == true) {
			l = m;
		}
		else {
			r = m;
		}
	}
	if (!check(l)) {
		puts("Impossible");
	}
	else {
		if (r==1e9) {
			puts("Infinity");
		}
		else {
			printf("%d\n", l+t);
		}
	}
}
//int main() {
//	cin >> n;
//	int s = 0;
//	int lv = 0;
//	int x, d;
//	int flag = 0;
//	int y;
//	int t = 0;
//	scanf("%d%d", &y, &d);
//	lv = d;
//	if (lv == 1) {
//		s = 1e9;
//	}
//	else if(lv==2){
//		s = 1899;
//	}
//	int suc = 1;
//	x = y;
//	for (int i = 1; i < n; i++) {
//		scanf("%d%d", &y, &d);
//		s += x;
//		if (flag == 1) {
//			if (s+t+1 >= 1900 && d == 2) {
//				suc = 0;
//			}
//			if (s < 1900 && d == 1) {
//				suc = 0;
//			}
//		}
//		if (d == 2) {
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899;
//					t = x;
//				}
//			}
//		}
//		else if(d==1){
//			if (d == lv) {
//				;
//			}
//			else {
//				if (flag == 0) {
//					flag = 1;
//					s = 1899 + x;
//					t = x;
//				}
//			}
//		}
//		lv = d;
//		t += x;
//		x = y;
//	}
//	t += x;
//	if (suc == 0) {
//		puts("Impossible");
//		return 0;
//	}
//	if (flag == 0) {
//		if (s >= 2 * 1e8) {
//			puts("Infinity");
//		}
//		else if (s <= 19099) {
//			printf("%d\n", 1899 + t);
//		}
//	}
//	else if (flag == 1) {
//		printf("%d\n", s+t);
//	}
//	return 0;
//}


#include <cstdio>
#include <memory>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <vector>
#include <cassert>
#include <string>
#include <ctime>
#include <map>
#include <queue>
#include <algorithm>
#include <iostream>
#include <cassert>
using namespace std;
#define REP(i,n) for(int i=0;i<n;i++)
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define req(i,a,b) for(int i=a;i>=b;i--)
#define rp(i,a) for(int i=head[a];i+1;i=edge[i].next)
#define cl(a,b) memset(a,b,sizeof a);
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define mod 1000000007
const int inf = ~0u >> 2;
const ll INF = (1LL << 62) - 1;
double eps = 1e-9;
const int N = 200000 + 5;
const int M = 21;

int cnt = 0, tot = 1;
int n, m;
//-7 1
//2  2
//8  2
int a[N], d[N];
bool check(int x) {
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (x < 1900)
				return false;
		}
		else {
			if (x >= 1900)
				return false;
		}
		x += a[i];
	}
	return true;
}
bool judge(int x,int r){
	int y = 0;
	for (int i = 0; i < n; i++) {
		if (d[i] == 1) {
			if (r + y < 1900)
				return false;
		}
		else {
			if (x + y >= 1900)
				return false;
		}
		y += a[i];
	}
	return true;
}
int main() {
	cin >> n;
	int s = 0, x, y, lv, suc;

	int t = 0;
	for (int i = 0; i < n; i++) {
		scanf("%d%d", &a[i], &d[i]);
		t += a[i];
	}
	int l = -1e9, r = 1e9;
	if (d[0] == 1) {
		l = 1900;
	}
	else {
		r = 1900;
	}
	int m;
	while (r-l>1) {
		m = (l + r) >> 1;
		if (judge(m, r) == true) {
			l = m;
		}
		else {
			r = m;
		}
	}
	if (!check(l)) {
		puts("Impossible");
	}
	else {
		if (r==1e9) {
			puts("Infinity");
		}
		else {
			printf("%d\n", l+t);
		}
	}
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia - TO JEST DO NICZEGO !!!!!

            licznik++;
    }
    wartosc=0;
    suma=0;
int minimum=wart[0]; ///podniesienie z gory
    if (d=1)
    {
        for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];
           if(suma<minimum) minimum=suma;
        }
 //       cout<<"minimum"<<minimum<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
  if(minimum>0) minimum=0;
            suma=1900-minimum;
            for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];

        }
    }
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=suma+wart[licznik];
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899) ///wskazuje na wyniki poprzednie po uwzglednieniu wyniku te wyniki sa wyjsciowe
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }
                  else
                        if(liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
    }

for(int i=0;i<n;i++)
{
    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1];

            licznik++;
    }
    wartosc=0;
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=1900+suma;
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

//for(int i=0;i<n;i++)
//{
 //   cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia - TO JEST DO NICZEGO !!!!!

            licznik++;
    }
    wartosc=0;
    suma=0;
int minimum=0;
if(licznik!=0) minimum=wart[0]; ///podniesienie z gory
    if (d=1)
    {
        for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];
           if(suma<minimum) minimum=suma;
        }
 //       cout<<"minimum"<<minimum<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
  if(minimum>0) minimum=0;
            suma=1900-minimum;
            for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];

        }
    }
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=suma+wart[licznik];
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899) ///wskazuje na wyniki poprzednie po uwzglednieniu wyniku te wyniki sa wyjsciowe
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }
                  else
                        if(liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1 && licznik_1<n)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>=0 && licznik_1>0 && d1==2) {cout<<"Impossible"; return 0;} else
     if(suma<0 && licznik_1>0 && d1==2) start=1899; else
     if(d1==2) start=1899+wartosc;

     for(int i=licznik_1+1;i<n;i++)
     {
        cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }
         if(d1==1 && d2==2)
         if(start+wartosc<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        if(d1==2 && d2==1)
        if(start+wartosc>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>0 && d1==2) {cout<<"Impossible"; return 0;}
     if(d1==2 && suma<0) start=1899;

     for(int i=licznik_1+1;i<n;i++)
     {
         cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }
         if(d1==1 && d2==2)
         if(start<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        if(d1==2 && d2==1)
        if(start>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;
int  tab[200000][2];

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wynik=0;
    bool zmiana_dol=false,zmiana_gora=false,zmiana=true;
    cin>>n;
    cin>>tab[0][0];
    cin>>tab[0][1];
    d2=tab[0][1];
    if(tab[0][1]==1) licznik_1++;
     else
        licznik_2++;
    for(int i=1;i<n;i++)
    {
        cin>>tab[i][0];
        cin>>tab[i][1];
        d1=tab[i][1];

        if(tab[i][1]==1) licznik_1++;
         else licznik_2++;

         if((d1>d2 && tab[i-1][0]>=0) || (d1<d2 && tab[i-1][0]<=0))
         {
             cout<<"Impossible";
             return 0;
         }

          if(d1>d2 && zmiana)
            {zmiana_dol=true;
                start=i-1;
                zmiana=false;}
         if(d1<d2 && zmiana)
            {zmiana_gora=true;
                start=i-1;
                zmiana=false;}

         d2=d1;
    }

    if(licznik_1==n) {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
    {
        wynik=1899;
        for(int i=0;i<n;i++)
        {
            wynik=min(1899,wynik+tab[i][0]);
        }
        cout<<wynik;
        return 0;
    }
    if(zmiana_dol) wynik=1899;
    if(zmiana_gora) wynik=1899+tab[start][0];
    for(int i=start+1;i<n;i++)
    {
        if(i==n-1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i-1][1]==1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i-1][1]==2) wynik+=tab[i][0];
        else
        if(tab[i][1]==2 && tab[i-1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i-1][1]==1) wynik=min(1899,wynik+tab[i][0]);

    }
    cout<<wynik;
    return 0;
}


#include <iostream>

using namespace std;

int zmiana[200000];
int liga[200001];
int przejscie[200000];

int main()
{

 int n,licznik_1=0,licznik_2=0, licznik_zmian=0,suma=0,maksi=0,mini=0;
 cin>>n;
 liga[n]=10;
 cin>>zmiana[0];
 cin>>liga[0];
 suma=zmiana[0];
 if(liga[0]==1) licznik_1++; else licznik_2++;
 for(int i=1; i<n; i++)
 {
     cin>>zmiana[i];
     cin>>liga[i];
     suma+=zmiana[i];
     if(liga[i]==1) licznik_1++; else licznik_2++;
     if(liga[i]!=liga[i-1]) {przejscie[i-1]=1; licznik_zmian++;}
 }
  if(licznik_zmian==0 && licznik_1==n ) {cout<<"Infinity";  return 0;}
  if(licznik_zmian==0 && licznik_2==n)
    {  int wynik=1899;
        for(int i=0;i<n;i++)
         {
             wynik=wynik+zmiana[i];
             if (wynik>1899 && i!=n-1) wynik=1899;
         }
        cout<<wynik; return 0;}
 bool pierwszy=true;
  suma=zmiana[0];
  for(int i=1; i<n; i++)
  {
      if(przejscie[i-1]==1 && liga[i-1]==1 && suma>=0) {cout<<"Impossible"; return 0;}
      if(przejscie[i-1]==1 && liga[i-1]==2 && suma<=0) {cout<<"Impossible"; return 0;}

      if(przejscie[i-1]==1 && liga[i-1]==1 && pierwszy)
      {
          maksi=1899;
          mini=1900+zmiana[i-1];
          suma=0;
          pierwszy=false;

      } else
      if(przejscie[i-1]==1 && liga[i-1]==1 && !pierwszy)
      {
          maksi+=zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;

      }

      if(przejscie[i-1]==1 && liga[i-1]==2 && pierwszy)
      {
          maksi=1899+zmiana[i-1];
          mini=1900;
          suma=0;
          pierwszy=false;
      } else
      if(przejscie[i-1]==1 && liga[i-1]==2 && !pierwszy)
      {
          maksi=maksi+zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;
          pierwszy=false;
      }

      if(liga[i+1]==liga[i] && i!=n-1)
      {
          maksi=maksi+zmiana[i];
       if(liga[i]==2 && maksi>1899) maksi=1899;
       if(liga[i]==1 && maksi<1900) maksi=1900;
      }
      if(i==n-1)
        maksi=maksi+zmiana[i];

        suma=suma+zmiana[i];
  }
  //maksi=maksi+zmiana[n-1];
  cout<<maksi;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia

            licznik++;
    }
    wartosc=0;
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=1900+wart[licznik];///bylo suma zmiana 31
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

for(int i=0;i<n;i++)
{
    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int  tab[200000][2];
int suma[200000];
int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wynik=0;
    bool zmiana_dol=false,zmiana_gora=false,zmiana=true;
    cin>>n;
    cin>>tab[0][0];
    cin>>tab[0][1];
    suma[0]=tab[0][0];
    d2=tab[0][1];
    if(tab[0][1]==1) licznik_1++;
     else
        {licznik_2++;
        }
    for(int i=1;i<n;i++)
    {
        cin>>tab[i][0];
        cin>>tab[i][1];
        d1=tab[i][1];
        suma[i]=suma[i-1]+tab[i][0];

        if(tab[i][1]==1) licznik_1++;
         else licznik_2++;

         if((d1>d2 && tab[i-1][0]>=0) || (d1<d2 && tab[i-1][0]<=0))
         {
             cout<<"Impossible";
             return 0;
         }

          if(d1>d2 && zmiana)
            {zmiana_dol=true;
                start=i-1;
                zmiana=false;}
         if(d1<d2 && zmiana)
            {zmiana_gora=true;
                start=i-1;
                zmiana=false;}

         d2=d1;
    }

    if(licznik_1==n) {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
    {
        wynik=1899;
        for(int i=0;i<n;i++)
        {
            if(i==n-1) wynik+=tab[i][0]; else
            wynik=min(1899,wynik+tab[i][0]);
        }
        cout<<wynik;
        return 0;
    }
    if(tab[0][1]==2) wynik=1899;
    if(tab[0][1]==1) wynik=2140000000;
  //  cout<<suma[start]<<"    "<<wynik<<endl<<endl;
    for(int i=1;i<n;i++)
    {
        if(i==n-1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==1) wynik+=tab[i][0];
    //  cout<<wynik<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
    }
    cout<<wynik;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;

    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                wartosc=min(1899,wartosc+wart[i]);
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];
    while(liga[licznik]==liga[licznik+1])
    {
        suma+=wart[licznik+1];
        licznik++;
    }
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wart[licznik];
             }
    if(d==1) {
                mini[licznik]=1900+suma;
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia - TO JEST DO NICZEGO !!!!!

            licznik++;
    }
    wartosc=0;
    suma=0;
int minimum=0;
if(licznik!=0) minimum=wart[0]; ///podniesienie z gory
    if (d=1)
    {
        for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];
           if(suma<minimum) minimum=suma;
        }
 //       cout<<"minimum"<<minimum<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
  if(minimum>0) minimum=0;
            suma=1900-minimum;
            for(int i=0;i<licznik;i++)
        {
           suma+=wart[i];

        }
    }
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=suma+wart[licznik];
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899) ///wskazuje na wyniki poprzednie po uwzglednieniu wyniku te wyniki sa wyjsciowe
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }
                  else
                        if(liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
    }

for(int i=0;i<n;i++)
{
    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1 && licznik_1<n)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>=0 && licznik_1>0 && d1==2) {cout<<"Impossible"; return 0;} else
     if(suma<0 && licznik_1>0 && d1==2) start=1899; else
     if(d1==2) start=1899+wartosc;

     for(int i=licznik_1+1;i<n;i++)
     {
        cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }
         if(d1==1 && d2==2)
         if(start<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        if(d1==2 && d2==1)
        if(start+wartosc>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1 && licznik_1<n)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>=0 && licznik_1>0 && d1==2) {cout<<"Impossible"; return 0;} else
     if(suma<0 && licznik_1>0 && d1==2) start=1899; else
     if(d1==2) start=1899+wartosc;

     for(int i=licznik_1+1;i<n;i++)
     {
        cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }
         if(d1==1 && d2==2)
         if(start<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        if(d1==2 && d2==1)
        if(start>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;

    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];
    while(liga[licznik]==liga[licznik+1])
    {
        suma+=wart[licznik+1];
        licznik++;
    }
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wart[licznik];
             }
    if(d==1) {
                mini[licznik]=1900+suma;
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1 && licznik_1<n)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>=0 && licznik_1>0 && d1==2) {cout<<"Impossible"; return 0;} else
     if(suma<0 && licznik_1>0 && d1==2) start=1899; else
     if(d1==2) start=1899+wartosc;

     for(int i=licznik_1+1;i<n;i++)
     {
        cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }

         if(d1==1 && d2==2)
         if(start<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }

        if(d1==2 && d2==1)
        if(start>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia

            licznik++;
    }
    wartosc=0;
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=1900+wart[licznik];///bylo suma zmiana 31
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

//for(int i=0;i<n;i++)
//{
 //   cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int  tab[200000][2];
int suma[200000];
int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wynik=0;
    bool zmiana_dol=false,zmiana_gora=false,zmiana=true;
    cin>>n;
    cin>>tab[0][0];
    cin>>tab[0][1];
    suma[0]=tab[0][0];
    d2=tab[0][1];
    if(tab[0][1]==1) licznik_1++;
     else
        {licznik_2++;
        }
    for(int i=1;i<n;i++)
    {
        cin>>tab[i][0];
        cin>>tab[i][1];
        d1=tab[i][1];
        suma[i]=suma[i-1]+tab[i][0];

        if(tab[i][1]==1) licznik_1++;
         else licznik_2++;

         if((d1>d2 && tab[i-1][0]>=0) || (d1<d2 && tab[i-1][0]<=0))
         {
             cout<<"Impossible";
             return 0;
         }

          if(d1>d2 && zmiana)
            {zmiana_dol=true;
                start=i-1;
                zmiana=false;}
         if(d1<d2 && zmiana)
            {zmiana_gora=true;
                start=i-1;
                zmiana=false;}

         d2=d1;
    }

    if(licznik_1==n) {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
    {
        wynik=1899;
        for(int i=0;i<n;i++)
        {
            if(i==n-1) wynik+=tab[i][0]; else
            wynik=min(1899,wynik+tab[i][0]);
        }
        cout<<wynik;
        return 0;
    }
    if(tab[0][1]==2 && tab[1][1]==1) wynik=1899+tab[0][0];
    if(tab[0][1]==2 && tab[1][1]==2) wynik=min(1899,1899+tab[0][0]);
    if(tab[0][1]==1 && tab[1][1]==1) wynik=2140000000;
    if(tab[0][1]==1 && tab[1][1]==2) wynik=1899;

    if(tab[0][1]==1) wynik=2140000000;
  //  cout<<suma[start]<<"    "<<wynik<<endl<<endl;
    for(int i=1;i<n;i++)
    {
        if(i==n-1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==1) wynik+=tab[i][0];
    // cout<<wynik<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
    }
    cout<<wynik;
    return 0;
}


#include <iostream>

using namespace std;

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wartosc,suma=0;
    cin>>n;
    cin>>wartosc;
    cin>>d1;
    if (d1==1) {licznik_1++; suma=wartosc;}
        else licznik_2++;
    d2=d1;

    while(d1==1 && licznik_1<n)
    {

        cin>>wartosc;
        cin>>d1;
        if(d1==1) {licznik_1++; suma+=wartosc;}
        d2=d1;
    }
     if(suma>0 && d1==2) {cout<<"Impossible"; return 0;}
     if(d1==2 && suma<0) start=1899;

     for(int i=licznik_1+1;i<n;i++)
     {
         cin>>wartosc;
         cin>>d1;
         if(d1==2 && d2==2)
            {start=min(1899,start);
             start+=wartosc;
            }
         if(d1==1 && d2==1)
         {
             start+=wartosc;
         }
         if(d1==1 && d2==2)
         if(start<1900)
            { cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        if(d1==2 && d2==1)
        if(start>1899)
            {cout<<"Impossible"; return 0;}
            else
            {
                start+=wartosc;
            }
        d2=d1;
     }

    if(licznik_1==n) cout<<"Infinity"; else
        cout<<start;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];
int bedzie[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,suma1=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;
       if(liga[i-1]!=liga[i]) bedzie[i-1]=1;
    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=0;i<n;i++)
            {
                if(i!=n-1)wartosc=min(1899,wartosc+wart[i]);
                else wartosc+=wart[i];
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];

    while(liga[licznik]==liga[licznik+1])
    {
        if (d==1) suma+=wart[licznik+1]; /// okreslenie pulapu zejscia - TO JEST DO NICZEGO !!!!!

            licznik++;
    }
    wartosc=0;
    suma1=0;
int minimum=0;
if(licznik!=0) minimum=wart[0]; ///podniesienie z gory
    if (d==1)
    {
        for(int i=0;i<licznik;i++)
        {
           suma1+=wart[i];
           if(suma1<minimum) minimum=suma1;
        }
 //       cout<<"minimum"<<minimum<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"<<endl;
  if(minimum>0) minimum=0;
            suma1=1900-minimum;
            for(int i=0;i<licznik;i++)
        {
           suma1+=wart[i];

        }
    }
    if(d==2)
    {
        for(int i=0;i<licznik;i++)
        {wartosc+=wart[i];
            if(wartosc>0) wartosc=0;
        }
        wartosc+=wart[licznik];
    }
   // cout<<wartosc<<"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'";
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wartosc;
             }
    if(d==1) {
                mini[licznik]=suma1+wart[licznik];
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899) ///wskazuje na wyniki poprzednie po uwzglednieniu wyniku te wyniki sa wyjsciowe
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }
                  else
                        if(liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<"       "<<bedzie[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int  tab[200000][2];

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wynik=0;
    bool zmiana_dol=false,zmiana_gora=false,zmiana=true;
    cin>>n;
    cin>>tab[0][0];
    cin>>tab[0][1];
    d2=tab[0][1];
    if(tab[0][1]==1) licznik_1++;
     else
        licznik_2++;
    for(int i=1;i<n;i++)
    {
        cin>>tab[i][0];
        cin>>tab[i][1];
        d1=tab[i][1];

        if(tab[i][1]==1) licznik_1++;
         else licznik_2++;

         if((d1>d2 && tab[i-1][0]>=0) || (d1<d2 && tab[i-1][0]<=0))
         {
             cout<<"Impossible";
             return 0;
         }

          if(d1>d2 && zmiana)
            {zmiana_dol=true;
                start=i-1;
                zmiana=false;}
         if(d1<d2 && zmiana)
            {zmiana_gora=true;
                start=i-1;
                zmiana=false;}

         d2=d1;
    }

    if(licznik_1==n) {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
    {
        wynik=1899;
        for(int i=0;i<n;i++)
        {
            wynik=min(1899,wynik+tab[i][0]);
        }
        cout<<wynik;
        return 0;
    }
    if(zmiana_dol) wynik=1899;
    if(zmiana_gora) wynik=1899+tab[start][0];
    for(int i=start+1;i<n;i++)
    {
        if(i==n-1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==2) wynik+=tab[i][0];
        else
        if(tab[i][1]==2 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==1) wynik+=tab[i][0];

    }
    cout<<wynik;
    return 0;
}


#include <iostream>

using namespace std;
int  tab[200000][2];

int main()
{
    int n,licznik_1=0,licznik_2=0,d1,d2,start,wynik=0;
    bool zmiana_dol=false,zmiana_gora=false,zmiana=true;
    cin>>n;
    cin>>tab[0][0];
    cin>>tab[0][1];
    d2=tab[0][1];
    if(tab[0][1]==1) licznik_1++;
     else
        licznik_2++;
    for(int i=1;i<n;i++)
    {
        cin>>tab[i][0];
        cin>>tab[i][1];
        d1=tab[i][1];

        if(tab[i][1]==1) licznik_1++;
         else licznik_2++;

         if((d1>d2 && tab[i-1][0]>=0) || (d1<d2 && tab[i-1][0]<=0))
         {
             cout<<"Impossible";
             return 0;
         }

          if(d1>d2 && zmiana)
            {zmiana_dol=true;
                start=i-1;
                zmiana=false;}
         if(d1<d2 && zmiana)
            {zmiana_gora=true;
                start=i-1;
                zmiana=false;}

         d2=d1;
    }

    if(licznik_1==n) {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
    {
        wynik=1899;
        for(int i=0;i<n;i++)
        {
            if(i==n-1) wynik+=tab[i][0]; else
            wynik=min(1899,wynik+tab[i][0]);
        }
        cout<<wynik;
        return 0;
    }
    if(zmiana_dol) wynik=1899;
    if(zmiana_gora) wynik=1899+tab[start][0];
    for(int i=start+1;i<n;i++)
    {
        if(i==n-1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==1) wynik+=tab[i][0];
        else
        if(tab[i][1]==1 && tab[i+1][1]==2) wynik+=tab[i][0];
        else
        if(tab[i][1]==2 && tab[i+1][1]==2) wynik=min(1899,wynik+tab[i][0]);
        else
        if(tab[i][1]==2 && tab[i+1][1]==1) wynik+=tab[i][0];

    }
    cout<<wynik;
    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;

    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=1;i<n;i++)
            {
                wartosc=min(1899,wartosc+wart[i]);
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];
    while(liga[licznik]==liga[licznik+1])
    {
        suma+=wart[licznik+1];
        licznik++;
    }
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wart[licznik];
             }
    if(d==1) {
                mini[licznik]=1900+wart[licznik];
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;}
                  else
                    maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;}

    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;
int wart[200000];
int liga[200000];
int mini[200000];
int maksi[200000];

int licznik_1=0,licznik_2=0,wartosc,d,suma=0,licznik;
int main()
{
    int n;
    cin>> n;
    for (int i=0;i<n;i++)
    {
        cin>>wart[i];
        cin>>liga[i];
        if(liga[i]==1) licznik_1++;
            else licznik_2++;

    }
    if(licznik_1==n)
        {cout<<"Infinity"; return 0;}
    if(licznik_2==n)
        {wartosc=1899;
            for(int i=1;i<n;i++)
            {
                wartosc=min(1899,wartosc+wart[i]);
            }
            cout<<wartosc;
            return 0;
        }
    licznik=0;
    d=liga[licznik];
    suma=wart[0];
    while(liga[licznik]==liga[licznik+1])
    {
        suma+=wart[licznik+1];
        licznik++;
    }
    if(d==2) {
            mini[licznik]=1900;
            maksi[licznik]=1899+wart[licznik];
             }
    if(d==1) {
                mini[licznik]=1900+suma;
                maksi[licznik]=1899;
             }

    for(int i=licznik+1;i<n;i++)
    {
        mini[i]=mini[i-1]+wart[i];
        maksi[i]=maksi[i-1]+wart[i];
        if(liga[i]==2)
            if(mini[i-1]>1899)
                { cout<<"Impossible";
                  return 0;
                  }
                  else
                    if (liga[i+1]==2) maksi[i]=min(1899,maksi[i]);
        if(liga[i]==1)
            if(maksi[i-1]<1900)
                { cout<<"Impossible";
                    return 0;
                    }

    }

//for(int i=0;i<n;i++)
//{
//    cout<<wart[i]<<"   "<<liga[i]<<"   "<<mini[i]<<"   "<<maksi[i]<<endl;
//}

cout<<maksi[n-2]+wart[n-1];

    return 0;
}


#include <iostream>

using namespace std;

int zmiana[200000];
int liga[200001];
int przejscie[200000];

int main()
{

 int n,licznik_1=0,licznik_2=0, licznik_zmian=0,suma=0,maksi=0,mini=0;
 cin>>n;
 liga[n]=10;
 cin>>zmiana[0];
 cin>>liga[0];
 suma=zmiana[0];
 if(liga[0]==1) licznik_1++; else licznik_2++;
 for(int i=1; i<n; i++)
 {
     cin>>zmiana[i];
     cin>>liga[i];
     suma+=zmiana[i];
     if(liga[i]==1) licznik_1++; else licznik_2++;
     if(liga[i]!=liga[i-1]) {przejscie[i-1]=1; licznik_zmian++;}
 }
  if(licznik_zmian==0 && licznik_1==n ) {cout<<"Infinity";  return 0;}
  if(licznik_zmian==0 && licznik_2==n && suma>=0) {cout<<1899; return 0;}
  if(licznik_zmian==0 && licznik_2==n && suma<0)  {cout<<1899+suma; return 0;}
 bool pierwszy=true;
  suma=zmiana[0];
  for(int i=1; i<n; i++)
  {
      if(przejscie[i-1]==1 && liga[i-1]==1 && suma>=0) {cout<<"Impossible"; return 0;}
      if(przejscie[i-1]==1 && liga[i-1]==2 && suma<=0) {cout<<"Impossible"; return 0;}

      if(przejscie[i-1]==1 && liga[i-1]==1 && pierwszy)
      {
          maksi=1899;
          mini=1900+zmiana[i-1];
          suma=0;
          pierwszy=false;

      } else
      if(przejscie[i-1]==1 && liga[i-1]==1 && !pierwszy)
      {
          maksi+=zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;

      }

      if(przejscie[i-1]==1 && liga[i-1]==2 && pierwszy)
      {
          maksi=1899+zmiana[i-1];
          mini=1900;
          suma=0;
          pierwszy=false;
      } else
      if(przejscie[i-1]==1 && liga[i-1]==2 && !pierwszy)
      {
          maksi=maksi+zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;
          pierwszy=false;
      }

      if(liga[i+1]==liga[i] && i!=n-1)
      {
          maksi=maksi+zmiana[i];
       if(liga[i]==2 && maksi>1899) maksi=1899;
       if(liga[i]==1 && maksi<1900) maksi=1900;
      }
      if(i==n-1)
        maksi=maksi+zmiana[i];

        suma=suma+zmiana[i];
  }
  //maksi=maksi+zmiana[n-1];
  cout<<maksi;
    return 0;
}


#include <iostream>

using namespace std;

int zmiana[200000];
int liga[200001];
int przejscie[200000];

int main()
{

 int n,licznik_1=0,licznik_2=0, licznik_zmian=0,suma=0,maksi=0,mini=0;
 cin>>n;
 liga[n]=10;
 cin>>zmiana[0];
 cin>>liga[0];
 suma=zmiana[0];
 if(liga[0]==1) licznik_1++; else licznik_2++;
 for(int i=1; i<n; i++)
 {
     cin>>zmiana[i];
     cin>>liga[i];
     suma+=zmiana[i];
     if(liga[i]==1) licznik_1++; else licznik_2++;
     if(liga[i]!=liga[i-1]) {przejscie[i-1]=1; licznik_zmian++;}
 }
  if(licznik_zmian==0 && licznik_1==n ) {cout<<"Infinity";  return 0;}
  if(licznik_zmian==0 && licznik_2==n)
    {  int wynik=1899;
        for(int i=0;i<n;i++)
         {
             wynik=wynik+zmiana[i];
             if (wynik>1899) wynik=1899;
         }
        cout<<wynik; return 0;}
 bool pierwszy=true;
  suma=zmiana[0];
  for(int i=1; i<n; i++)
  {
      if(przejscie[i-1]==1 && liga[i-1]==1 && suma>=0) {cout<<"Impossible"; return 0;}
      if(przejscie[i-1]==1 && liga[i-1]==2 && suma<=0) {cout<<"Impossible"; return 0;}

      if(przejscie[i-1]==1 && liga[i-1]==1 && pierwszy)
      {
          maksi=1899;
          mini=1900+zmiana[i-1];
          suma=0;
          pierwszy=false;

      } else
      if(przejscie[i-1]==1 && liga[i-1]==1 && !pierwszy)
      {
          maksi+=zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;

      }

      if(przejscie[i-1]==1 && liga[i-1]==2 && pierwszy)
      {
          maksi=1899+zmiana[i-1];
          mini=1900;
          suma=0;
          pierwszy=false;
      } else
      if(przejscie[i-1]==1 && liga[i-1]==2 && !pierwszy)
      {
          maksi=maksi+zmiana[i-1];
          mini=mini+zmiana[i-1];
          suma=0;
          pierwszy=false;
      }

      if(liga[i+1]==liga[i] && i!=n-1)
      {
          maksi=maksi+zmiana[i];
       if(liga[i]==2 && maksi>1899) maksi=1899;
       if(liga[i]==1 && maksi<1900) maksi=1900;
      }
      if(i==n-1)
        maksi=maksi+zmiana[i];

        suma=suma+zmiana[i];
  }
  //maksi=maksi+zmiana[n-1];
  cout<<maksi;
    return 0;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a, b = 1000000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(a < 1900)
                a = 1900;
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a = -2100000000, b = 2100000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 100000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a = -2100000000, b = 2100000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

    }
    if(a > b) {
            out << "Impossible";
            return 0;
        }
    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a, b = 100000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a, b = 1000000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(a > 1900)
                a = 0;
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a = -2100000000, b = 2100000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<bits/stdc++.h>
#define in cin
#define out cout
using namespace std;

ifstream f ("bb.in");

int n;
int c;
int d;
int val, a = -1000000000, b = 1000000000;

int main() {

    in >> n;
    for(int i = 1; i <= n; i++) {
        in >> c >> d;

        if(d == 1) {
            if(a < 1900)
                a = 1900;
            a = a + c;
            b = b + c;
        }

        if(d == 2) {
            if(b > 1899)
                b = 1899;
            a = a + c;
            b = b + c;
        }

        if(a > b) {
            out << "Impossible";
            return 0;
        }
    }

    if(b > 10000000) {
        out << "Infinity";
        return 0;
    }

    out << b;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const long long int inf=0x3f3f3f3f3f3f3f3f;
long long int c[200005],d[200005];
int main()
{
	long long int n,le,ri,i,tle,tri,flog=1;
	scanf("%lld",&n);
	for(i=0;i<n;i++)
	scanf("%lld %lld",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		le+=c[i];
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}
	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri==inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%lld\n",ri+c[n-1]);
	}
	return 0;
}


#include<stdio.h>
#include<queue>
#include<string.h>
#include<math.h>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
int c[200005],d[200005];
int main()
{
	int le,ri,tle,tri,n,i,flog=0;
	while(~scanf("%d",&n))
	{
		flog=0;
		for(i=0;i<n;i++)
	scanf("%d %d",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=1;break;
			}
			ri=min(ri,tri);
			le=max(le,tle);
		}
		else
		{
			tri=1899-c[i];
			tle=-1*inf;
			if(ri<tle||le>tri)
			{
				flog=1;break;
			}
			ri=min(ri,tri);
			le=max(le,tle);
		}
		if(le!=-1*inf)
		le+=c[i];
		if(ri!=inf)
		ri+=c[i];
	}
	if(flog)
	printf("Impossible\n");
	else if(ri>=inf)
	printf("Infinity\n");
	else
	printf("%d\n",ri+c[n-1]);
	}

	return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const long long int inf=0x3f3f3f3f3f3f3f3f;
long long int c[200005],d[200005];
int main()
{
	long long int n,le,ri,i,tle,tri,flog=1;
	scanf("%lld",&n);
	for(i=0;i<n;i++)
	scanf("%lld %lld",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		le+=c[i];
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}
	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri>=inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%lld\n",ri+c[n-1]);
	}
	return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
int c[200005],d[200005];
int main()
{
	int n,le,ri,i,tle,tri,flog=1;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	scanf("%d %d",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		le+=c[i];
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}
	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri==inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%d\n",ri+c[n-1]);
	}
	return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
int c[200005],d[200005];
int main()
{
	int n,le,ri,i,tle,tri,flog=1;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	scanf("%d %d",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		if(le!=-1*inf)
		le+=c[i];
		if(ri!=inf)
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}
	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri>=inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%d\n",ri+c[n-1]);
	}
	return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const int inf=0x3f3f3f3f;
int c[200005],d[200005];
int main()
{
	int n,le,ri,i,tle,tri,flog=1;
	scanf("%d",&n);
	for(i=0;i<n;i++)
	scanf("%d %d",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		if(le!=-1*inf)
		le+=c[i];
		if(ri!=inf)
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}

	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri>=inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%d\n",ri+c[n-1]);
	}
	return 0;
}


#include<stdio.h>
#include<algorithm>
using namespace std;
const long long int inf=0x3f3f3f3f3f3f3f3f;
long long int c[200005],d[200005];
int main()
{
	long long int n,le,ri,i,tle,tri,flog=1;
	scanf("%lld",&n);
	for(i=0;i<n;i++)
	scanf("%lld %lld",&c[i],&d[i]);
	if(d[0]&1)
	{
		le=1900;
		ri=inf;
	}
	else
	{
		le=-1*inf;
		ri=1899;
	}
	for(i=0;i<n-1;i++)
	{
		if(flog==0)
		break;
		if(d[i+1]&1)
		{
			tle=1900-c[i];
			tri=inf;
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		else
		{
			tle=-1*inf;
			tri=1899-c[i];
			if(ri<tle||le>tri)
			{
				flog=0;
			}
			else
			{
				le=max(le,tle);
				ri=min(ri,tri);
			}
		}
		if(le!=-1*inf)
		le+=c[i];
		if(ri!=inf)
		ri+=c[i];
	//	printf("%d %d %d %d\n",le,ri,tle,tri);
		if(le>ri)
		{
			flog=0;
		}
	}
	if(flog==0)
	{
		printf("Impossible\n");
	}
	else if(ri>=inf)
	{
		printf("Infinity\n");
	}
	else
	{
		printf("%lld\n",ri+c[n-1]);
	}
	return 0;
}


///
///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c,d;
int delta,Max=INT_MAX, Min=-INT_MAX;
int main()
{
 //   freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",c,d);
        if (d==1) Min=max(1900-delta,Min);
        if (d==2) Max=min(1899-delta,Max);
        if (Min>Max) {puts("Impossible"); return 0;}
        delta=delta + c;
    }
    if (Max==INT_MAX) puts("Infinity");
    else cout<<Max;
    return 0;
}
/**
- Quen cuc tieu lai Max, cuc dai lai Min (theo bat phuong trinh)
- Quen dat Min=-INT_MIN; (lam SAI TEST 25)
*/


/// 750C. New Year and Rating (codeforces)
/// Math, Bat phuong trinh
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c,d;
int delta,to=INT_MAX, from=-INT_MAX;
int main()
{
//    freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",&c,&d);
        if (d==1) from=max(1900-delta,from);
        if (d==2) to=min(1899-delta,to);
        if (from>to) { puts("Impossible"); return 0; }
        delta=delta + c;
    }
    if (to == INT_MAX) puts("Infinity");
    else cout<<to + delta;
    return 0;
}
/** Thuan Math, Bat Phuong Trinh !!!
- Ap dung bat phuong trinh x >= 1900 (From) hoac x <= 1899 (To)
- Neu d=1, nghia la  x + delta >= 1900 --> cap nhat lai From (max)
- Neu d=2, nghia la x + delta <= 1899 --> cap nhat lai To (min)
- Truong hop From > To --> Impossible
- Truong hop To ko thay doi (nghia la x >= from ) --> Infinity

*** Sai sot:
- Quen cuc tieu lai TO, cuc dai lai FROM (theo nguyen tac cua bat phuong trinh)
- Quen dat from=-INT_from; (lam SAI TEST 25)
- Khong can dung mang
*/


///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c[maxn],d[maxn];
int delta,mark=0,smark;
int main()
{
//   freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
        scanf("%d %d",&c[i],&d[i]);
    for (int i=1; i<=n; i++)
    {
        if (d[i]==1 && d[i+1]==2 && c[i]>=0) {cout<<"Impossible"; return 0;}
        if (d[i]==2 && d[i+1]==1 && c[i]<=0) {cout<<"Impossible"; return 0;}
        delta+=c[i];
        if (d[i]!=d[i+1] && mark==0 )
        {
            mark=i;
            smark=delta;
   //         cout<<delta<<smark<<endl;
        }
    }
    if (d[1]==1 && mark==n) {cout<<"Infinity"; return 0;}
    if (d[1]==2)
    {
        for (int i=1899; i>=1900-smark; i--)
        {
            if (i+delta-c[n]>=1900 && d[n]==1) {cout<<i+delta; return 0;}
            if (i+delta-c[n]<1900 && d[n]==2) {cout<<i+delta; return 0;}
        }
    }
    if (d[1]==1)
    {
//        cout<<delta<<smark<<endl;
        for (int i=1900-smark; i>=1900; i--)
        {
            if (i+delta-c[n]>=1900 && d[n]==1) {cout<<i+delta; return 0;}
            if (i+delta-c[n]<1900 && d[n]==2) {cout<<i+delta; return 0;}
        }
    }
//
    cout<<"het";
    return 0;
}


///
///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c,d;
int delta,Max=INT_MAX, Min=-INT_MAX;
int main()
{
//    freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",&c,&d);
        if (d==1) Min=max(1900-delta,Min);
        if (d==2) Max=min(1899-delta,Max);
        if (Min>Max) {puts("Impossible"); return 0;}
        delta=delta + c;
    }
    if (Max==INT_MAX) puts("Infinity");
    else cout<<Max+delta;
    return 0;
}


///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c[maxn],d[maxn];
int delta,Max=INT_MAX, Min;
int main()
{
 //   freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",c+i,d+i);
        delta=delta + c[i-1];
        if (d[i]==1) Min=max(1900-delta,Min);
        if (d[i]==2) Max=min(1899-delta,Max);
        if (Min>Max) {puts("Impossible"); return 0;}
    }
    if (Max==INT_MAX) puts("Infinity");
    else cout<<Max+delta+c[n];
    return 0;
}


///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c[maxn],d[maxn];
int delta,mark=0,smark;
int main()
{
//    freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
        scanf("%d %d",&c[i],&d[i]);
    for (int i=1; i<=n; i++)
    {
        if (d[i]==1 && d[i+1]==2 && c[i]>=0) {cout<<"Impossible"; return 0;}
        if (d[i]==2 && d[i+1]==1 && c[i]<=0) {cout<<"Impossible"; return 0;}
        delta+=c[i];
        if (d[i]!=d[i+1] && mark==0 )
        {
            mark=i;
            smark=delta;
   //         cout<<delta<<smark<<endl;
        }
    }
    if (d[1]==1 && mark==n) {cout<<"Infinity"; return 0;}
    if (d[1]==2)
    {
        for (int i=1899; i>=1900-smark; i--)
        {
            if (i+delta-c[n]>=1900 && d[n]==1) {cout<<i+delta; return 0;}
            if (i+delta-c[n]<1900 && d[n]==2) {cout<<i+delta; return 0;}
        }
    }
    if (d[1]==1)
    {
//        cout<<delta<<smark<<endl;
        for (int i=1900-smark; i>=1900; i--)
        {
            if (i+delta-c[n]>=1900 && d[n]==1) {cout<<i+delta; return 0;}
            if (i+delta-c[n]<1900 && d[n]==2) {cout<<i+delta; return 0;}
        }
    }
//
//    cout<<"het";
    return 0;
}


///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c[maxn],d[maxn];
int delta,mark=0,smark;
int main()
{
//    freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",&c[i],&d[i]);
        if (d[i-1]==1 && d[i]==2 && c[i-1]>=0) {cout<<"Impossible"; return 0;}
        if (d[i-1]==2 && d[i]==1 && c[i-1]<=0) {cout<<"Impossible"; return 0;}
        delta+=c[i];
        if (d[i]!=d[i+1] && mark==0)
        {
            mark=i;
            smark=delta;
       //     cout<<delta<<smark<<endl;
        }
    }
    if (d[1]==2)
    {
        for (int i=1899; i>=1900-smark; i--)
        {
            if (i+delta>=1900 && d[n]==1) {cout<<i+delta; return 0;}
            if (i+delta<1900 && d[n]==2) {cout<<i+delta; return 0;}
        }
    }
    cout<<"Infinity";
    return 0;
}


///
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c[maxn],d[maxn];
int delta,Max=INT_MAX, Min=-INT_MAX;
int main()
{
 //   freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",c+i,d+i);
        delta=delta + c[i-1];
        if (d[i]==1) Min=max(1900-delta,Min);
        if (d[i]==2) Max=min(1899-delta,Max);
        if (Min>Max) {puts("Impossible"); return 0;}
    }
    if (Max==INT_MAX) puts("Infinity");
    else cout<<Max+delta+c[n];
    return 0;
}


typedef long long ll;
using namespace std;
const int maxn=200003;

int n,c,d;
int delta,Max=INT_MAX, Min=-INT_MAX;
int main()
{
 //   freopen("nhap.inp", "r", stdin);
    cin>>n;
    for (int i=1; i<=n; i++)
    {
        scanf("%d %d",&c,&d);
        if (d==1) Min=max(1900-delta,Min);
        if (d==2) Max=min(1899-delta,Max);
        if (Min>Max) {puts("Impossible"); return 0;}
        delta=delta + c;
    }
    if (Max==INT_MAX) puts("Infinity");
    else cout<<Max+delta;
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,minRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		{
		minR = minRating ;
	minRChanged =true;
		}
	}
	else
		{ long int maxRating;
			maxRating=1900-constant-1;
		//	cout<<"final = "<<maxRating<<" constamt = "<<constant<<endl;
			if(maxR>=maxRating)
				{
				maxR=maxRating ;
				maxRChanged = true;
				}
			}
		if(maxR>=minR)
		{if(division[0]==1){
			if(minR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
			else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

		}
		else flagImpossible =true;

	}
	if(flagImpossible)
	cout<<"Impossible";
	else if(!maxRChanged||!minRChanged)//||!minRChanged))
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	infinityFlag=true;
	else
	finalRating=1899+wholeConstant ;
  if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;

}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,minRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)    // 1 division
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		{
		minR = minRating ;
         minRChanged =true;
		}
	}
	else // 2nd division
		{ long int maxRating;
			maxRating=1900-constant-1;
		 if(maxR>=maxRating)
				{
				maxR=maxRating ;
				maxRChanged = true;
				//cout<<"setting maxRchnge = "<<maxRChanged;
				}
		}
		}//end of else
if(maxR>=minR&&maxRChanged)
{if(division[0]==1){
	if(minR>=1900)
	finalRating = maxR+wholeConstant;
     else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
			else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

} // end of if minr>=maxR and maxRchanged
else if(maxR>=minR&&!maxRChanged)
{//cout<<"Hello error"<<" maxRchnge ="<<maxRChanged<<endl;
if(division[0]==2)
{            if(minR>=1900)
            flagImpossible =true;
            else
             finalRating = 1899+wholeConstant;
}
else{
           infinityFlag=true;

}
} //end of else-if
else flagImpossible =true;

//cout<<"MaxR= "<<maxR<<" minR= "<<minR<<endl<<"maxR chang = "<<maxRChanged<<" minRcnh ="<<minRChanged<<endl;
	if(flagImpossible)
	cout<<"Impossible";
	else if(infinityFlag)//||!minRChanged))
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	{
	infinityFlag=true;
	  cout<<"Infinity";}
	else
	{
	finalRating=1899+wholeConstant ;
		cout<<finalRating;}

}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,minRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		{
		minR = minRating ;
	minRChanged =true;
		}
	}
	else
		{ long int maxRating;
			maxRating=1900-constant-1;
		//	cout<<"final = "<<maxRating<<" constamt = "<<constant<<endl;
			if(maxR>=maxRating)
				{
				maxR=maxRating ;
				maxRChanged = true;
				}
			}
		if(maxR>=minR)
		{if(division[0]==1){
			if(minR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
			else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

		}
		else flagImpossible =true;

	}
	if(flagImpossible)
	cout<<"Impossible";
	else if(!maxRChanged&&!minRChanged)//||!minRChanged))
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	infinityFlag=true;
	else
	finalRating=1899+wholeConstant ;
  if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;

}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		minR = minRating ;
	}
	else
		{ long int maxRating;
			maxRating=1900-constant-1;
		//	cout<<"final = "<<maxRating<<" constamt = "<<constant<<endl;
			if(maxR>=maxRating)
				{
				maxR=maxRating ;
				maxRChanged = true;
				}
			}
		if(maxR>=minR)
		{if(division[0]==1){
			if(minR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
		else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

		}
		else flagImpossible =true;

	}

	if(flagImpossible)
	cout<<"Impossible";
	else if(infinityFlag||!maxRChanged)
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	infinityFlag=true;
	else
	finalRating=1899+wholeConstant ;
  if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;

}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,minRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		{
		minR = minRating ;
	//	minRChanged =true;
		}
	}
	else
		{ long int maxRating;
			maxRating=1900-constant-1;
		//	cout<<"final = "<<maxRating<<" constamt = "<<constant<<endl;
			if(maxR>=maxRating)
				{
				maxR=maxRating ;
				maxRChanged = true;
				}
			}
		if(maxR>=minR)
		{if(division[0]==1){
			if(minR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
			else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

		}
		else flagImpossible =true;

	}
	if(flagImpossible)
	cout<<"Impossible";
	else if(!maxRChanged)//||!minRChanged))
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	infinityFlag=true;
	else
	finalRating=1899+wholeConstant ;
  if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;

}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
int main(){
	long int n;
	cin>>n;
	long int maxR=INT_MAX;
	long int minR = INT_MIN ;
	long long int finalRating=0;
	long long int constant=0,wholeConstant=0;
	long	int ratingChange[n] ;
	int division[n] ;
	bool maxRChanged=false,flagImpossible=false,infinityFlag=false;
	for(long int i=0;i<n;i++)
	{cin>>ratingChange[i]>>division[i];
	wholeConstant+=ratingChange[i] ;
	}
	if(n!=1){
	for(long int i =0;i<n-1;i++)
	{ constant+=ratingChange[i];
	if(division[i+1]==1)
	{long int minRating;
		minRating=1900-constant;
		if(minRating>=minR)
		minR = minRating ;
	}
	else
		{ long int maxRating;
			maxRating=1900-constant-1;
		//	cout<<"final = "<<maxRating<<" constamt = "<<constant<<endl;
			if(maxR>=maxRating)
				{
				maxR=maxRating ;
				}
			}
		if(maxR>=minR)
		{if(division[0]==1){
			if(minR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   {if(maxR>=1900)
			finalRating = maxR+wholeConstant;
		   else
		   flagImpossible=true;
	       }
		}
		else {
			if(minR>=1900)
			flagImpossible=true;
		else
			{
				if(maxR<1900)
					finalRating = maxR+wholeConstant ;
					else
			finalRating = 1899+wholeConstant ;
		}
		}

		}
		else flagImpossible =true;

	}

	if(flagImpossible)
	cout<<"Impossible";
	else if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;
}
else {
	if(division[0]==1)
	infinityFlag=true;
	else
	finalRating=1899+wholeConstant ;
  if(infinityFlag)
  cout<<"Infinity";
  else
	cout<<finalRating;

}
	return 0;
}