Problem:
Score : 300 points

Problem Statement

You are given four integers A, B, C, and D. Find the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.

Constraints

1\leq A\leq B\leq 10^{18}

1\leq C,D\leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B C D

Output

Print the number of integers between A and B (inclusive) that can be evenly divided by neither C nor D.

Sample Input 1

4 9 2 3

Sample Output 1

2

5 and 7 satisfy the condition.

Sample Input 2

10 40 6 8

Sample Output 2

23

Sample Input 3

314159265358979323 846264338327950288 419716939 937510582

Sample Output 3

532105071133627368

Solution in Rust (1.15.1) (judge verdict: Accepted)

fn main() {
    let mut reader = acio::Reader::new();
    let a = reader.read::<u64>() - 1;
    let b = reader.read::<u64>();
    let c = reader.read::<u64>();
    let d = reader.read::<u64>();
    let l = acbat::lcm(c, d);
    let f = |x| x - x / c - x / d + 1;
    let k = f(l);
    let ad = f(a % l);
    let bd = f(b % l);
    let ac = (a / l * k) + ad;
    let bc = (b / l * k) + bd;
    //println!("{} / {} + {}, {}", k, l, ad, bd);
    //println!("{} - {} = {}", bc, ac, bc - ac);
    println!("{}", bc - ac);
}

/// Batteries for AtCoder
#[allow(dead_code)]
mod acbat {
    pub fn lcm(v1: u64, v2: u64) -> u64 {
        v1 * v2 / gcd(v1, v2)
    }

    pub fn gcd(v1: u64, v2: u64) -> u64 {
        if v1 == v2 {
            v1
        } else if v1 < v2 {
            gcd(v1, v2 - v1)
        } else {
            gcd(v1 - v2, v1)
        }
    }
}

/// IO Module for AtCoder
#[allow(dead_code)]
mod acio {
    use std::fmt::Debug;
    use std::io::{stdin, Stdin};
    use std::str::FromStr;

    pub struct Reader {
        input: Stdin,
        stack: Vec<String>,
    }

    impl Reader {
        pub fn new() -> Self {
            Reader {
                input: stdin(),
                stack: vec![],
            }
        }

        pub fn read_by<F>(&mut self, count: u64) -> Vec<F>
        where
            F: FromStr,
            <F as FromStr>::Err: Debug,
        {
            let mut v = vec![];
            for _ in 0..count {
                v.push(self.read());
            }
            return v;
        }

        pub fn read<F>(&mut self) -> F
        where
            F: FromStr,
            <F as FromStr>::Err: Debug,
        {
            if self.stack.is_empty() {
                let mut line = self.read_line();
                self.stack.append(&mut line);
                self.stack.reverse();
            }
            self.stack.pop().unwrap().parse().unwrap()
        }

        fn read_line(&mut self) -> Vec<String> {
            let mut buf = String::new();
            self.input.read_line(&mut buf).unwrap();
            buf.split_whitespace().map(|s| s.to_string()).collect()
        }
    }
}