Problem:
Score: 500 points

Problem Statement

We have caught N sardines. The deliciousness and fragrantness of the i-th sardine is A_i and B_i, respectively.

We will choose one or more of these sardines and put them into a cooler. However, two sardines on bad terms cannot be chosen at the same time.

The i-th and j-th sardines (i \neq j) are on bad terms if and only if A_i \cdot A_j + B_i \cdot B_j = 0.

In how many ways can we choose the set of sardines to put into the cooler? Since the count can be enormous, print it modulo 1000000007.

Constraints

All values in input are integers.

1 \leq N \leq 2 \times 10^5

-10^{18} \leq A_i, B_i \leq 10^{18}

Input

Input is given from Standard Input in the following format:

N
A_1 B_1
:
A_N B_N

Output

Print the count modulo 1000000007.

Sample Input 1

3
1 2
-1 1
2 -1

Sample Output 1

5

There are five ways to choose the set of sardines, as follows:

The 1-st

The 1-st and 2-nd

The 2-nd

The 2-nd and 3-rd

The 3-rd

Sample Input 2

10
3 2
3 2
-1 1
2 -1
-3 -9
-8 12
7 7
8 1
8 2
8 4

Sample Output 2

479

Solution in C# (Mono-csc 3.5.0) (judge verdict: Wrong Answer)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using static System.Math;
using static Math2;
using static io;
using static Utils;

public class CP {

  public void Solve() {
    var N = Cin<int>();
    var fish = new Dictionary < (long a, long b),
      (int posi, int nega) > ();
    int zero = 0;

    for (int i = 0; i < N; ++i) {
      var(a, b) = Cin<long, long>();
      if ((a, b) == (0, 0)) {++zero; continue; }
      var gcd = GCD(Abs(a), Abs(b));
      a /= gcd;
      b /= gcd;
      if (b < 0) {
        a = -a;
        b = -b;
      }
      var isrotated = false;
      if (a <= 0) {
        (a, b) = (b, -a);
        isrotated = true;
      }
      if (!fish.ContainsKey((a, b))) {
        fish[(a, b)] = (0, 0);
      }
      if (isrotated) {
        fish[(a, b)] = (fish[(a, b)].posi, fish[(a, b)].nega + 1);
      } else {
        fish[(a, b)] = (fish[(a, b)].posi + 1, fish[(a, b)].nega);
      }
    }
    long ans = 1;
    foreach (var x in fish) {
      ans *= (Power(2, x.Value.nega) + Power(2, x.Value.posi) - 1);
      ans %= MOD;
    }
    ans -= 1;
    Put((ans + zero) % MOD);
  }
}
public static class Math2 {
  public const int INF = 1 << 29;
  public const long INFL = 1L << 60;
  public const long MOD = 1000000007;
  public const long MOD2 = 998244353;

  public static long Power(long a, long b, long MOD = 1000000007) //i^N
  {
    long res = 1;
    while (b > 0) {
      if ((b & 1) != 0)res = res * a % MOD;
      a = a * a % MOD;
      b >>= 1;
    }
    return res;
  }
  public static long Power2(long a, long b) //i^N
  {
    long res = 1;
    while (b > 0) {
      if ((b & 1) != 0)res = res * a;
      a = a * a;
      b >>= 1;
    }
    return res;
  }
  public static long GCD(long a, long b) {
    if (a == 0)return b;
    while (b > 0) {
      var r = a % b;
      a = b;
      b = r;
    }
    return a;
  }
  public static long LCM(long a, long b) => (b / GCD(a, b)) * a;
  public static long Comb(long n, long r, int MOD = 1000000007) {
    if (r > n - r)r = n - r;
    long Nume = 1;
    long Deno = 1;

    if (r > n - r)r = n - r;
    for (long i = 1; i <= r; ++i) {
      Deno = (Deno * i) % MOD;
      Nume = Nume * (n - i + 1) % MOD;
    }
    return (Nume * inv(Deno)) % MOD;
  }
  public static long Comb2(long n, long r) {
    long Nume = 1;
    long Deno = 1;

    if (r > n - r)r = n - r;
    for (long i = 1; i <= r; ++i) {
      Deno *= i;
      Nume *= n - i + 1;
    }
    return Nume / Deno;
  }
  public static long inv(long x, int MOD = 1000000007) {
    return Power(x, MOD - 2, MOD);
  }
}
public static class Utils {
  public static void Swap<T>(ref T A, ref T B) {
    T x = A;
    A = B;
    B = x;
  }
  public static int DigitSum(string N) {

    int ret = 0;
    for (int i = 0; i < N.Length; ++i)ret += N[i] - '0';
    return ret;
  }
  public static string ConvertBase(long N, int K) {
    StringBuilder ret = new StringBuilder();
    while (N > 0) {
      var r = N % K;
      N /= K;
      ret.Append(r);
    }
    return new string(ret.ToString().ToCharArray().Reverse().ToArray());
  }
  public static bool NextPermutation<T>(IList<T> lis, Comparison<T> cmp) {
    int n = lis.Count;
    int i = n - 1;
    while (i - 1 >= 0) {
      if (cmp(lis[i - 1], lis[i]) < 0)break;
      --i;
    }
    if (i == 0)return false;
    int j = i;
    while (j + 1 < n) {
      if (cmp(lis[i - 1], lis[j + 1]) > 0)break;
      ++j;
    }
    (lis[i - 1], lis[j]) = (lis[j], lis[i - 1]);
    int k = i;
    int l = n - 1;
    while (k < l) {
      (lis[k], lis[l]) = (lis[l], lis[k]);

      ++k;
      --l;
    }
    return true;
  }
  public static bool NextPermutation<T>(IList<T> lis) => NextPermutation(lis, Comparer<T>.Default.Compare);
}
public class PriorityQueue<T> {
  List<T> _item;
  public int Count { get { return _item.Count; } }
  bool _isascend { get; set; }
  public T Peek { get { return _item[0]; } }
  Comparison<T> Comp;
  public PriorityQueue(bool IsAscend = true, IEnumerable<T> list = null) : this(Comparer<T>.Default.Compare, IsAscend, list) { }
  public PriorityQueue(Comparison<T> cmp, bool IsAscend = true, IEnumerable<T> list = null) {
    _item = new List<T>();
    _isascend = IsAscend;
    this.Comp = cmp;
    if (list != null) {
      _item.AddRange(list);
      Build();
    }
  }

  private int Compare(int i, int j) => (_isascend ? -1 : 1) * Comp(_item[i], _item[j]);
  private void Swap(int i, int j) { var t = _item[i]; _item[i] = _item[j]; _item[j] = t; }
  private int Parent(int i) => (i - 1) >> 1;
  private int Left(int i) => (i << 1) + 1;
  public T Enqueue(T val) {
    int i = _item.Count;
    _item.Add(val);
    while (i > 0) {
      int p = Parent(i);
      if (Compare(i, p) > 0)
        Swap(i, p);
      i = p;
    }
    return val;
  }
  private void Heapify(int index) {
    for (int i = index, j;
      (j = Left(i)) < _item.Count; i = j) {
      if (j != _item.Count - 1 && Compare(j, j + 1) < 0)j++;
      if (Compare(i, j) < 0)
        Swap(i, j);
    }
  }
  public T Dequeue() {
    T val = _item[0];
    _item[0] = _item[_item.Count - 1];
    _item.RemoveAt(_item.Count - 1);
    Heapify(0);
    return val;
  }
  private void Build() {
    for (var i = (_item.Count >> 1) - 1; i >= 0; i--)
      Heapify(i);
  }
  public bool Any() => Count > 0;
}
class Program {
  static void Main(string[] args) {
    var CP = new CP();
    CP.Solve();
  }
}
public static class io {

  public static void Put(string a) => Console.WriteLine(a);
  public static void Put(params object[] i) => Put(string.Join(" ", i));
  public static void Put<T>(IEnumerable<T> a) => Put(string.Join(" ", a));
  public static void PutV<T>(IEnumerable<T> a) { foreach (var z in a)Put(z); }
  public static void YN(bool i) {
    if (i)Put("Yes");
    else Put("No");
  }
  public static string Str => Console.ReadLine();
  public static string[] Strs => Str.Split(" ");
  public static bool IsTypeEqual<T, U>() => typeof(T).Equals(typeof(U));
  public static T ConvertType<T, U>(U a) => (T)Convert.ChangeType(a, typeof(T));
  public static T Cast<T>(string s) {
    if (IsTypeEqual<T, int>())return ConvertType<T, int>(int.Parse(s));
    else if (IsTypeEqual<T, long>())return ConvertType<T, long>(long.Parse(s));
    else if (IsTypeEqual<T, double>())return ConvertType<T, double>(double.Parse(s));
    else if (IsTypeEqual<T, char>())return ConvertType<T, char>(char.Parse(s));
    else return ConvertType<T, string>(s);
  }
  public static T[] Castarr<T>(string[] s) {

    var ret = new T[s.Length];
    int i = 0;
    if (IsTypeEqual<T, char>()) {
      var list = new List<T>();
      foreach (var t in s) {
        foreach (var u in t) {
          list.Add(ConvertType<T, char>(char.Parse(u.ToString())));
        }
      }
      return list.ToArray();
    }
    foreach (var t in s) {
      if (IsTypeEqual<T, int>())ret[i++] = ConvertType<T, int>(int.Parse(t));
      else if (IsTypeEqual<T, long>())ret[i++] = ConvertType<T, long>(long.Parse(t));
      else if (IsTypeEqual<T, double>())ret[i++] = ConvertType<T, double>(double.Parse(t));
      else ret[i++] = ConvertType<T, string>(t);
    }
    return ret;
  }
  public static T Cin<T>() { var t = Strs; return (Cast<T>(t[0])); }
  public static(T a1, U a2)Cin<T, U>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1])); }
  public static(T a1, U a2, V a3)Cin<T, U, V>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1]), Cast<V>(t[2])); }
  public static(T a1, U a2, V a3, W a4)Cin<T, U, V, W>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1]), Cast<V>(t[2]), Cast<W>(t[3])); }
  public static(T a1, U a2, V a3, W a4, X a5)Cin<T, U, V, W, X>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1]), Cast<V>(t[2]), Cast<W>(t[3]), Cast<X>(t[4])); }
  public static(T a1, U a2, V a3, W a4, X a5, Y a6)Cin<T, U, V, W, X, Y>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1]), Cast<V>(t[2]), Cast<W>(t[3]), Cast<X>(t[4]), Cast<Y>(t[5])); }
  public static(T a1, U a2, V a3, W a4, X a5, Y a6, Z a7)Cin<T, U, V, W, X, Y, Z>() { var t = Strs; return (Cast<T>(t[0]), Cast<U>(t[1]), Cast<V>(t[2]), Cast<W>(t[3]), Cast<X>(t[4]), Cast<Y>(t[5]), Cast<Z>(t[6])); }
  public static T[] Cinarr<T>() { var t = Strs; return Castarr<T>(t); }
  public static T[] CinV<T>(int n) {
    var ret = new T[n];
    for (int i = 0; i < n; ++i) {
      ret[i] = Cin<T>();
    }
    return ret;
  }

  public static T Change<T>(this T x, Func<T, T> f) {
    return f(x);
  }
}