#include <algorithm>
#include <array>
#include <cassert>
#include <cstdint>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>

int64_t gcd(int64_t a, int64_t b) {
  while (b != 0) {
    int64_t t = b;
    b = a % b;
    a = t;
  }
  return a;
}

struct Rational {
  int64_t num, den;
};

Rational reduce(Rational in) {
  int64_t g = gcd(in.num, in.den);
  in.num /= g;
  in.den /= g;
  return in;
}

void make_common(Rational &a, Rational &b) {
  int64_t den_a = a.den;
  int64_t den_b = b.den;
  a.num *= den_b;
  a.den *= den_b;
  b.num *= den_a;
  b.den *= den_a;
}

Rational subtract(Rational a, Rational b) {
  make_common(a, b);
  Rational res;
  res.num = a.num - b.num;
  res.den = a.den;
  return reduce(res);
}

Rational scale(Rational a, int64_t scale) {
  a.num *= scale;
  return reduce(a);
}

bool greater_than_eq(Rational a, Rational b) {
  make_common(a, b);
  return a.num >= b.num;
}

bool less_than_eq(Rational a, Rational b) {
  make_common(a, b);
  return a.num <= b.num;
}

int main() {
  std::ios_base::sync_with_stdio(false);
  std::cin.tie(nullptr);

  // input
  int64_t L;
  Rational x, y, z;
  std::cin >> L >> x.num >> x.den >> y.num >> y.den >> z.num >> z.den;

  Rational one_third = {1, 3};
  Rational two_third = {2, 3};

  auto is_coord_corner = [&](Rational &c) {
    return less_than_eq(c, one_third) || greater_than_eq(c, two_third);
  };
  
  auto update_coord_for_recurse = [&](Rational &c) {
    while(greater_than_eq(c, one_third)) {
      c = subtract(c, one_third);
    }
    c = scale(c, 3);
  };


  for (int64_t l = 0; l < L; l++) {

    int count = 0;
    // clang-format off
    if (is_coord_corner(x)) count++;
    if (is_coord_corner(y)) count++;
    if (is_coord_corner(z)) count++;
    // clang-format on

    if (count < 2) {
      std::cout << 0 << std::endl;
      return 0;
    }

    update_coord_for_recurse(x);
    update_coord_for_recurse(y);
    update_coord_for_recurse(z);
  }

  std::cout << 1 << std::endl;
  return 0;
}