// -*- coding:utf-8-unix -*- // #![feature(map_first_last)] #![allow(dead_code)] #![allow(unused_imports)] #![allow(unused_macros)] use std::cmp::*; use std::collections::*; use std::fmt::*; use std::hash::*; use std::io::BufRead; use std::iter::FromIterator; use std::*; const INF: i64 = 1223372036854775807; const UINF: usize = INF as usize; const LINF: i64 = 2147483647; const INF128: i128 = 1223372036854775807000000000000; const MOD1: i64 = 1000000007; const MOD9: i64 = 998244353; const MOD: i64 = MOD9; const UMOD: usize = MOD as usize; const M_PI: f64 = 3.14159265358979323846; macro_rules! p { ($x:expr) => { //if expr println!("{}", $x); }; } macro_rules! vp { // vector print separate with space ($x:expr) => { println!( "{}", $x.iter() .map(|x| x.to_string()) .collect::>() .join(" ") ); }; } macro_rules! d { ($x:expr) => { eprintln!("{:?}", $x); }; } macro_rules! yn { ($val:expr) => { if $val { println!("Yes"); } else { println!("No"); } }; } macro_rules! map{ // declear btreemap ($($key:expr => $val:expr),*) => { { let mut map = ::std::collections::BTreeMap::new(); $( map.insert($key, $val); )* map } }; } macro_rules! set{ // declear btreemap ($($key:expr),*) => { { let mut set = ::std::collections::BTreeSet::new(); $( set.insert($key); )* set } }; } //input output #[allow(dead_code)] fn read() -> T { let mut s = String::new(); std::io::stdin().read_line(&mut s).ok(); s.trim().parse().ok().unwrap() } #[allow(dead_code)] fn read_vec() -> Vec { read::() .split_whitespace() .map(|e| e.parse().ok().unwrap()) .collect() } #[allow(dead_code)] fn read_mat(n: u32) -> Vec> { (0..n).map(|_| read_vec()).collect() } #[allow(dead_code)] fn readii() -> (i64, i64) { let mut vec: Vec = read_vec(); (vec[0], vec[1]) } #[allow(dead_code)] fn readiii() -> (i64, i64, i64) { let mut vec: Vec = read_vec(); (vec[0], vec[1], vec[2]) } #[allow(dead_code)] fn readuu() -> (usize, usize) { let mut vec: Vec = read_vec(); (vec[0], vec[1]) } fn readuuu() -> (usize, usize, usize) { let mut vec: Vec = read_vec(); (vec[0], vec[1], vec[2]) } fn extgcd(a: i128, b: i128) -> (i128, i128, i128) { if b == 0 { (a.abs(), a.signum(), 0) } else { let (g, x, y) = extgcd(b, a % b); (g, y, x - (a / b) * y) } } fn modinv(a: i128, m: i128) -> i128 { let (g, x, _) = extgcd(a, m); let inv = x % m; if inv < 0 { inv + m } else { inv } } fn crt(r1: i128, m1: i128, r2: i128, m2: i128) -> (i128, i128) { let diff = r2 - r1; let inv = modinv(m1 % m2, m2); let k = (diff % m2 + m2) % m2 * inv % m2; let r = r1 + k * m1; let m = m1 * m2; let r = ((r % m) + m) % m; (r, m) } fn main() { let n = read::() as i128; let (p, q, r) = readuuu(); let (a, b, c) = readuuu(); let (p, q, r) = (p as i128, q as i128, r as i128); let (a, b, c) = (a as i128, b as i128, c as i128); let (x, m) = crt(a, p, b, q); let (x, m) = crt(x, m, c, r); // let x = x as u128; // let m = m as u128; let ans = if x > n { 0 } else { (n - x) / m + 1 }; println!("{}", ans); }