import bisect
import copy
import heapq
import sys
import itertools
import math
import queue
input = sys.stdin.readline
sys.setrecursionlimit(1000000)
mod = 1000000007

def read_values(): return map(int, input().split())
def read_index(): return map(lambda x: int(x) - 1, input().split())
def read_list(): return list(read_values())
def read_lists(N): return [read_list() for n in range(N)]
def init_dp1(init, N): return [init for _ in range(N)]
def init_dp2(init, N, M): return [[init for _ in range(M)] for _ in range(N)]


def f(v, k, L, K, A):
    p = v[0]
    t = -1 / k
    if t in K:
        return t

    i = bisect.bisect_right(L, t)
    if i != len(L):
        q = K[L[i]][0]
        if A[p][0] * A[q][0] + A[p][1] * A[q][1] == 0:
            return L[i]

    if i + 1 < len(L):
        q = K[L[i + 1]][0]
        if A[p][0] * A[q][0] + A[p][1] * A[q][1] == 0:
            return L[i + 1]
    
    if i > 0:
        q = K[L[i - 1]][0]
        if A[p][0] * A[q][0] + A[p][1] * A[q][1] == 0:
            return L[i - 1]

    return t


def main():
    N = int(input())
    A = read_lists(N)    

    K = {}
    zero = 0
    for i, a in enumerate(A):
        if a == [0, 0]:
            zero += 1
            continue

        if a[0] == 0:
            r = 10 ** 20
        else:
            r = a[1] / a[0]
        K.setdefault(r, []).append(i)

    L = sorted(list(K.keys()))    

    S = set()
    res = 1
    for k, v in K.items():
        if k in S:
            continue
        S.add(k)

        if k == 0:
            t = 10 ** 20
        elif k == 10 ** 20:
            t = 0
        else:
            t = f(v, k, L, K, A)

        if t in K:
            S.add(t)
            v2 = K[t]
            res *= (pow(2, len(v), mod) + pow(2, len(v2), mod) - 1) % mod
            res %= mod
        else:
            res *= 2
            res %= mod

    print((res + zero - 1) % mod)
 

if __name__ == "__main__":
    main()

