use proconio::{fastout, input};

fn gcd(a: usize, b: usize) -> usize {
    use std::cmp::{max, min};
    let mi = min(a, b);
    let ma = max(a, b);

    let r = ma % mi;
    if r == 0 {
        return mi;
    }

    gcd(mi, r)
}

fn reduce(a: isize, b: isize) -> (isize, isize) {
    let mut a = a;
    let mut b = b;
    if b < 0 {
        b = -b;
        a = -a;
    }

    let g = gcd(a.abs() as usize, b.abs() as usize) as isize;
    (a / g, b / g)
}

fn inv(ab: (isize, isize)) -> (isize, isize) {
    if ab.0 < 0 {
        (ab.1, -ab.0)
    } else {
        (-ab.1, ab.0)
    }
}

static MOD: isize = 1000000007;

#[fastout]
fn main() {
    input! {
        n: usize,
        abs: [(isize, isize); n]
    };

    let mut f = vec![0; n + 1];
    f[0] = 1;
    for i in 1..=n {
        f[i] = (f[i - 1] * 2) % MOD;
    }

    let mut abzero = 0;
    let mut abs2 = vec![];
    let mut hash = std::collections::HashMap::<(isize, isize), usize>::new();
    for (a, b) in abs {
        if a == 0 && b == 0 {
            abzero += 1;
            continue;
        }

        let rab = reduce(a, b);
        if let Some(v) = hash.get_mut(&rab) {
            *v = *v + 1;
        } else {
            hash.insert(rab, 1);
        }

        abs2.push((a, b));
    }

    let mut set = std::collections::HashSet::<(isize, isize)>::new();
    let mut m = 1;
    let abs2len = abs2.len();
    for (a, b) in abs2 {
        let rab = reduce(a, b);
        if set.contains(&rab) {
            continue;
        }

        set.insert(rab);

        let rab_n = *hash.get(&rab).unwrap() as usize;
        let mut s = 1;
        for _ in 0..rab_n {
            s *= 2;
            s %= MOD;
        }

        let rab_inv = inv(rab);
        if !hash.contains_key(&rab_inv) {
            m *= s;
            m %= MOD;
            continue;
        }

        set.insert(rab_inv);

        s += (MOD - 1);
        s %= MOD;

        let inv_n = *hash.get(&rab_inv).unwrap() as usize;
        let mut t = 1;
        for _ in 0..inv_n {
            t *= 2;
            t %= MOD;
        }

        t += (MOD - 1);
        t %= MOD;

        m *= (s + t + 1) % MOD;
        m %= MOD;
    }

    if abzero == n {
        println!("{}", n);
    } else {
        println!("{}", (abzero as isize + m + (MOD - 1)) % MOD);
    }
}
