#include<bits/stdc++.h>
using namespace std;
#define ALL(x) x.begin(),x.end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define debug(v) cout<<#v<<":";for(auto x:v){cout<<x<<' ';}cout<<endl;
#define mod 1000000007
using ll=long long;
const int INF=1000000000;
const ll LINF=1001002003004005006ll;
int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
// ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return true;}return false;}
 
struct IOSetup{
    IOSetup(){
        cin.tie(0);
        ios::sync_with_stdio(0);
        cout<<fixed<<setprecision(12);
    }
} iosetup;
 
template<typename T1,typename T2>
ostream &operator<<(ostream &os,const pair<T1,T2>&p){
    os<<p.first<<" "<<p.second;
    return os;
}
 
template<typename T>
ostream &operator<<(ostream &os,const vector<T>&v){
    for(int i=0;i<(int)v.size();i++) os<<v[i]<<(i+1==(int)v.size()?"":" ");
    return os;
}

template<typename T1,typename T2>
istream &operator>>(istream &is,pair<T1,T2>&p){
    is>>p.first>>p.second;
    return is;
}

template<typename T>
istream &operator>>(istream &is,vector<T>&v){
    for(T &x:v)is>>x;
    return is;
}

template<ll Mod>
struct ModInt{
    long long x;
    ModInt():x(0){}
    ModInt(long long y):x(y>=0?y%Mod:(Mod-(-y)%Mod)%Mod){}
    ModInt &operator+=(const ModInt &p){
        if((x+=p.x)>=Mod) x-=Mod;
        return *this;
    }
    ModInt &operator-=(const ModInt &p){
        if((x+=Mod-p.x)>=Mod)x-=Mod;
        return *this;
    }
    ModInt &operator*=(const ModInt &p){
        x=(int)(1ll*x*p.x%Mod);
        return *this;
    }
    ModInt &operator/=(const ModInt &p){
        (*this)*=p.inverse();
        return *this;
    }
    ModInt operator-()const{return ModInt(x);}
    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 ModInt &p)const{return x==p.x;}
    ModInt operator!=(const ModInt &p)const{return x!=p.x;}
    ModInt inverse()const{
        int a=x,b=Mod,u=1,v=0,t;
        while(b>0){
            t=a/b;
            swap(a-=t*b,b);swap(u-=t*v,v);
        }
        return ModInt(u);
    }
    ModInt pow(long long n)const{
        ModInt ret(1),mul(x);
        while(n>0){
            if(n&1) ret*=mul;
            mul*=mul;n>>=1;
        }
        return ret;
    }
    friend ostream &operator<<(ostream &os,const ModInt &p){return os<<p.x;}
    friend istream &operator>>(istream &is,ModInt &a){long long t;is>>t;a=ModInt<Mod>(t);return (is);}
    static int get_mod(){return Mod;}
};
using mint=ModInt<mod>;


// 2^127 = 170141183460469231731687303715884105728 ~ 10^38
using int128=__int128;
 
ostream &operator<<(ostream &os,const __int128 n){
    if(n==0){
        os<<0;
        return os;
    }
    __int128 num=n;
    bool neg=false;
    if(num<0)neg=true,num=-num;
    string res="";
    while(num>0){
        res.push_back('0'+num%10);
        num/=10;
    }
    if(neg) res.push_back('-');
    reverse(begin(res),end(res));
    os<<res;
    return os;
}
 
istream &operator>>(istream &is,__int128 &n){
    string s;
    is>>s;
    int idx=0;
    bool neg=false;
    if(s[0]=='-')neg=true,idx++;
    n=0;
    for(;idx<(int)s.size();idx++){
        n=10*n+s[idx]-'0';
    }
    if(neg) n=-n;
    return is;
}
 
__int128 abs128(__int128 x){
    return x<0?-x:x;
}
 
__int128 gcd128(__int128 a,__int128 b){
    if(a==0) return b;
    if(b==0) return a;
    return b>0?gcd128(b,a%b):a;
}
 



template<class INT>
struct Fraction{
    INT num,den;// numerator / denominator
    INT Igcd(INT a,INT b){return (b?Igcd(b,a%b):a);}
    void normalize(){
        INT g=Igcd(num,den);
        num/=g;den/=g;
        if(den<0)num=-num,den=-den;
    }
    Fraction(INT num=0,INT den=1):num(num),den(den){normalize();}
    long double to_ld()const{return (long double)num/den;}
    double to_d()const{return (double)num/den;}
    Fraction &operator+=(const Fraction &rhs){
        num=num*rhs.den+rhs.num*den;
        den*=rhs.den;
        normalize();
        return *this;
    }
    Fraction &operator-=(const Fraction &rhs){
        num=num*rhs.den-rhs.num*den;
        den*=rhs.den;
        normalize();
        return *this;
    }
    Fraction &operator*=(const Fraction &rhs){
        num*=rhs.num;
        den*=rhs.den;
        normalize();
        return *this;
    }
    Fraction &operator/=(const Fraction &rhs){
        num*=rhs.den;
        den*=rhs.num;
        normalize();
        return *this;
    }
    Fraction abs(){
        Fraction ret(*this);
        if(ret<0)ret.first=ret.first*(-1);
        return ret;
    }
    Fraction operator-(){(*this).first*=-1;return *this;}
    Fraction operator+=(const int &rhs){(*this)+=Fraction(rhs);return *this;}
    Fraction operator+=(const long long &rhs){(*this)+=Fraction(rhs);return *this;}
    Fraction operator-=(const int &rhs){(*this)-=Fraction(rhs);return *this;}
    Fraction operator-=(const long long &rhs){(*this)-=Fraction(rhs);return *this;}
    Fraction operator*=(const int &rhs){(*this)*=Fraction(rhs);return *this;}
    Fraction operator*=(const long long &rhs){(*this)*=Fraction(rhs);return *this;}
    Fraction operator/=(const int &rhs){(*this)/=Fraction(rhs);return *this;}
    Fraction operator/=(const long long &rhs){(*this)/=Fraction(rhs);return *this;}
    Fraction operator+(const Fraction &rhs)const{return Fraction(*this)+=rhs;}
    Fraction operator-(const Fraction &rhs)const{return Fraction(*this)-=rhs;}
    Fraction operator*(const Fraction &rhs)const{return Fraction(*this)*=rhs;}
    Fraction operator/(const Fraction &rhs)const{return Fraction(*this)/=rhs;}
    bool operator==(const Fraction &rhs)const{return num*rhs.den==den*rhs.num;}
    bool operator!=(const Fraction &rhs)const{return !(*this==rhs);}
    bool operator>=(const Fraction &rhs)const{return num*rhs.den>=den*rhs.num;}
    bool operator<=(const Fraction &rhs)const{return num*rhs.den<=den*rhs.num;}
    bool operator>(const Fraction &rhs)const{return num*rhs.den>den*rhs.num;}
    bool operator<(const Fraction &rhs)const{return num*rhs.den<den*rhs.num;}
    friend ostream &operator<<(ostream &os,const Fraction &p){return os<<p.num<<"/"<<p.den;}
};
using frac=Fraction<int128>;


signed main(){
    int n;cin>>n;
    int c00=0;
    vector<int128> a,b;
    rep(i,n){
        int128 x,y;cin>>x>>y;
        if(x==0 and y==0)c00+=1;
        else a.push_back(x),b.push_back(y);
    }
    n=(int)a.size();

    map<frac,int> cl;
    int xl=0,xr=0;
    rep(i,n){
        // lhs
        if(b[i]==0) xl++;
        if(a[i]==0) xr++;
        if(a[i]!=0 and b[i]!=0)cl[frac(a[i],b[i])]++;
    }

    mint res=1;
    vector<pair<int,int>> w;
    int s=0;
    if(xl>0 and xr>0){
        w.emplace_back(xl,xr);
    }
    for(auto [lhs,x]:cl){
        frac rhs=frac(-1)/lhs;
        if(cl.count(rhs)){
            if(cl[rhs] and x)w.emplace_back(x,cl[rhs]);
            cl[rhs]=0;
            cl[lhs]=0;
        }
    }
    for(auto [x,y]:w){
        res*=mint(2).pow(x)+mint(2).pow(y)-1;
        s+=x+y;
    }
    res*=mint(2).pow(n-s);
    res-=1;res+=c00;
    cout<<res<<endl;
    return 0;
}


Measured memory_bytes: 28048