#include <bits/stdc++.h>
using namespace std;
#define int long long
#define override_rep(i, l, r, mes, ...) mes
#define rep1(i, n) for (int i = 0; i < n; i++)
#define rep2(i, l, r) for (int i = l; i < r; i++)
#define rep(...) override_rep(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
using P = pair<int, int>;
template<typename T, typename U>
istream& operator>>(istream& in, pair<T, U>& p) {
    in >> p.first >> p.second;
    return in;
}

template<int64_t MOD>
class ModInt {
	typedef int64_t T;
	T x;

  public:
	ModInt(T value) {
		if (value < 0) value = (MOD - (-value) % MOD);
		x = value % MOD;
	}

	ModInt operator-() const {
		return ModInt(-x);
	}

	ModInt& operator+=(const ModInt& p)  {
		if ((x += p.get()) >= MOD) x -= MOD;
		return *this;
	}

	ModInt& operator-=(const ModInt& p) {
		if ((x += MOD - p.get()) >= MOD) x -= MOD;
		return *this;
	}

	ModInt& operator*=(const ModInt& p) {
		x = x * p.get() % MOD;
		return *this;
	}

	ModInt& operator/=(const ModInt& p) {
		*this *= p.inverse();
		return *this;
	}

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

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

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

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

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

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

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

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

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

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

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

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

	bool operator==(const ModInt& p) const {
		return x == p.get();
	}

	bool operator!=(const ModInt& p) const {
		return x != p.get();
	}

	bool operator==(const T& p) const {
		return x == ModInt(p);
	}

	bool operator!=(const T& p) {
		return x != ModInt(p);
	}

	ModInt inverse() const {
		int a = x, b = MOD, u = 1, v = 0;
		while (b) {
			int t = a / b;
			a -= t * b;
			u -= t * v;
			swap(a, b);
			swap(u, v);
		}
		return ModInt(u);
	}

	T get() const {
		return x;
	}

	friend ostream& operator<<(ostream& out,const ModInt& value){
	    out<<value.x;
	    return out;
	}
};

template<int64_t MOD>
ModInt<MOD> modPow(unsigned long long x, uint64_t n) {
	ModInt<MOD> ret(1),a(x);
	while (n) {
		if (n & 1U) ret = ret * a;
		a = a * a;
		n >>= 1U;
	}
	return ret;
}

signed main(signed argc, char* argv[]) {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    const int MOD = 1e9+7;
    int n;
    cin>>n;
    map<P,int> mp;
    rep(i,n){
        int a,b;
        cin>>a>>b;
        if(a==0&&b==0){
            mp[{0,0}]++;
        }
        else if(a==0){
            mp[{0,1}]++;
        }
        else if(b==0){
            mp[{1,0}]++;
        }
        else if(a<0&&b<0){
            a=-a;
            b=-b;
            int m=gcd(a,b);
            mp[{a/m,b/m}]++;
        }
        else if(a<0){
            a=-a;
            int m=gcd(a,b);
            mp[{-a/m,b/m}]++;
        }
        else if(b<0){
            b=-b;
            int m=gcd(a,b);
            mp[{-a/m,b/m}]++;
        }
        else{
            int m=gcd(a,b);
            mp[{a/m,b/m}]++;
        }
    }
    vector<P> memo;
    for(auto [p,cost]:mp){
        if(p==P(0,0))continue;
        if(p.first>0&&mp[{-p.second,p.first}]!=0)continue;
        memo.emplace_back(cost,mp[{p.second,-p.first}]);
    }
    ModInt<MOD> ans(1);
    for(P it:memo){
        if(it.second==0)ans*=(modPow<MOD>(2,it.first));
        else ans*=(modPow<MOD>(2,it.first)+modPow<MOD>(2,it.second)-1);
    }
    cout<<ans+mp[{0,0}]-1<<endl;
}


Measured memory_bytes: 37376