// template {{{
#include <bits/stdc++.h>
using namespace std;

// #define int long long

#define GET_MACRO(a, b, c, d, NAME, ...) NAME
#define REP2(i, n) REP3(i, 0, n)
#define REP3(i, a, b) REP4(i, a, b, 1)
#define REP4(i, a, b, s) for (ll i = (a); i < (ll)(b); i += s)
#define RREP2(i, n) RREP3(i, 0, n)
#define RREP3(i, a, b) for (ll i = (b) - 1; i >= (ll)(a); i--)

#define rep(...) GET_MACRO(__VA_ARGS__, REP4, REP3, REP2)(__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__,, RREP3, RREP2)(__VA_ARGS__)
#define eb emplace_back
#define ef emplace_front
#define pb pop_back
#define pf pop_front
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define popcnt __builtin_popcountll

#ifdef DEBUG
	#define dump(x) cerr << "line " << __LINE__ << " : " << #x " = " << x << endl;
#else
	#define dump(x)
#endif

using uint = unsigned;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;

template<typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;

template<typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;

const int INF = 1e9 + 10;
const ll LLINF = 1e18 + 10;

const int dx[] = {-1, 0, 1, 0, -1, 1, 1, -1};
const int dy[] = {0, -1, 0, 1, -1, -1, 1, 1};

template<typename T>
inline T sq(T x){
	return x * x;
}

template<typename T, typename U>
inline bool chmax(T &x, U y){
	if (x >= y) return false;
	x = y;
	return true;
}

template<typename T, typename U>
inline bool chmin(T &x, U y){
	if (x <= y) return false;
	x = y;
	return true;
}

template<typename T>
inline T& sort(T &c){
	sort(all(c));
	return c;
}

template<typename T>
inline T& reverse(T &c){
	reverse(all(c));
	return c;
}

template<typename T>
inline T& unique(T &c){
	sort(all(c));
	c.erase(unique(all(c)), end(c));
	return c;
}

template<typename T>
inline T sorted(const T &c){
	T d = c;
	return move(sort(d));
}

template<typename T>
inline T reversed(const T &c){
	T d = c;
	return move(reverse(d));
}

template<typename T>
inline T uniqued(const T &c){
	T d = c;
	return move(unique(d));
}

ll modpow(ll x, ll e, ll mod = 1000000007){
	ll res = 1;
	e %= mod - 1;
	while (e){
		if (e & 1) res = res * x;
		x = x * x;
		e >>= 1;
	}
	return res;
}

inline ll in(){
	ll x;
	scanf("%lld", &x);
	return x;
}

inline double inD(){
	double x;
	scanf("%lf", &x);
	return x;
}

inline string inS(){
	string s;
	cin >> s;
	return s;
}

pair<ll, ll> rot45(ll x, ll y){
	return mp(x + y, x - y);
}

pair<ll, ll> rot45inv(ll u, ll v){
	return mp((u + v) / 2, (u - v) / 2);
}

template<typename T, size_t N>
struct print_tuple {
	static void print(const T &t, ostream &os){
		print_tuple<T, N - 1>::print(t, os);
		os << " " << get<N - 1>(t);
	}
};

template<typename T>
struct print_tuple<T, 1> {
	static void print(const T &t, ostream &os){
		os << get<0>(t);
	}
};

template<typename ...Args>
ostream& operator<<(ostream &os, const tuple<Args...> &t){
	print_tuple<tuple<Args...>, tuple_size<tuple<Args...>>::value>::print(t, os);
}
// }}}
// modint {{{
const ll MOD = 1e9 + 7;

struct ModInt {
	ModInt(): v(0){}
	ModInt(ll v): v((v % MOD + MOD) % MOD){}
	ModInt(const string &s){
		bool neg = false;
		auto it = begin(s);
		if (*it == '-'){
			neg = true;
			++it;
		}
		v = 0;
		while (it != end(s)){
			v = (v * 10 + (*it - '0')) % MOD;
		}
		if (neg) v = (MOD - v) % MOD;
	}
	
	operator ll() const {
		return v;
	}

	ModInt operator+(const ModInt &r) const {
		ll res = v + r.v;
		if (res >= MOD) res -= MOD;
		return res;
	}

	ModInt operator-(const ModInt &r) const {
		ll res = v - r.v;
		if (res < 0) res += MOD;
		return res;
	}

	ModInt operator*(const ModInt &r) const {
		return v * r.v % MOD;
	}

	ModInt operator/(const ModInt &r) const {
		return v * r.inv() % MOD;
	}

	ModInt& operator+=(const ModInt &r){
		return *this = *this + r;
	}

	ModInt& operator-=(const ModInt &r){
		return *this = *this - r;
	}

	ModInt& operator*=(const ModInt &r){
		return *this = *this * r;
	}

	ModInt& operator/=(const ModInt &r){
		return *this = *this / r;
	}

	ModInt pow(ll e) const {
		ll res = 1, x = v;
		while (e > 0){
			if (e & 1) res = (res * x) % MOD;
			x = (x * x) % MOD;
			e >>= 1;
		}
		return res;
	}

	ModInt inv() const {
		assert(v != 0);
		return pow(MOD - 2);
	}

private:
	ll v;
};
// }}}
// rig matrix {{{
template<typename T>
class RigMatrix {
public:	
	RigMatrix(): h(0), w(0), z(0), e(1), a(){}
	RigMatrix(int h, int w): h(h), w(w), z(0), e(1), a(h, vector<T>(w, z)){}
	RigMatrix(int h, int w, int z, int e): h(h), w(w), z(z), e(e), a(h, vector<T>(w, z)){}
	
	int height() const { return h; }
	int width() const { return w; }
	
	const T& operator()(int r, int c) const {
		assert(0 <= r && r < h);
		assert(0 <= c && c < w);
		return a[r][c];
	}

	T& operator()(int r, int c){
		assert(0 <= r && r < h);
		assert(0 <= c && c < w);
		return a[r][c];
	}

	RigMatrix operator+(const RigMatrix &r) const {
		assert(h == r.h && w == r.w);
		assert(e == r.e && z == r.z);
		RigMatrix res(h, w, z, e);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < w; j++){
				res[i][j] = (*this)(i, j) + r(i, j);
			}
		}
		return res;
	}

	RigMatrix operator*(const RigMatrix &r) const {
		assert(w == r.h);
		assert(z == r.z && e == r.e);
		RigMatrix res(h, r.w, z, e);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < r.w; j++){
				for (int k = 0; k < w; k++){
					res(i, j) = res(i, j) + (*this)(i, k) * r(k, j);
				}
			}
		}
		return res;
	}

	RigMatrix& operator+=(const RigMatrix &r){
		assert(h == r.h && w == r.h);
		for (int i = 0; i < h; i++){
			for (int j = 0; j < w; j++){
				(*this)(i, j) = (*this)(i, j) + r(i, j);
			}
		}
		return *this;
	}

	RigMatrix& operator*=(const RigMatrix &r){
		return *this = *this * r;
	}

	RigMatrix pow(ll x) const {
		RigMatrix A = *this;
		RigMatrix R(h, w, z, e);
		rep(i, h) R(i, i) = e;
		while (x > 0){
			if (x & 1) R *= A;
			A *= A;
			x >>= 1;
		}
		return R;
	}
	
private:
	int z, e;
	int h, w;
	vector<vector<T>> a;
};
// }}}

ModInt fib(ll x){
	RigMatrix<ModInt> a(2, 2), b(2, 1);
	a(0, 0) = a(0, 1) = a(1, 0) = 1;
	b(0, 0) = b(1, 0) = 1;
	return (a.pow(x + 1) * b)(1, 0);
}

int main()
{
	int n = in();
	ModInt res = 1;
	rep(i, n){
		ll c = in();
		string d = inS();
		ll e = 0;
		for (char ch : d){
			e = (e * 10 + (ch - '0')) % 1000000006;
		}
		res *= fib(c).pow(e);
	}
	cout << res << endl;
}