Problem:
Score : 300 points

Problem Statement

Snuke loves puzzles.

Today, he is working on a puzzle using S- and c-shaped pieces.
In this puzzle, you can combine two c-shaped pieces into one S-shaped piece, as shown in the figure below:

Snuke decided to create as many Scc groups as possible by putting together one S-shaped piece and two c-shaped pieces.

Find the maximum number of Scc groups that can be created when Snuke has N S-shaped pieces and M c-shaped pieces.

Constraints

1 ≤ N,M ≤ 10^{12}

Input

The input is given from Standard Input in the following format:

N M

Output

Print the answer.

Sample Input 1

1 6

Sample Output 1

2

Two Scc groups can be created as follows:

Combine two c-shaped pieces into one S-shaped piece

Create two Scc groups, each from one S-shaped piece and two c-shaped pieces

Sample Input 2

12345 678901

Sample Output 2

175897

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

// 入力マクロ
// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 より
#[macro_export]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}
#[macro_export]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}
#[macro_export]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: usize, m: usize
    }
    let n = n;
    let mut m = m;
    let mut scc = 0;
    
    if n >= m / 2 {
        scc = m / 2;
    } else {
        scc = n;
        m -= scc * 2;

        m /= 2;
        scc += m / 2
    }

    println!("{}", scc);
}




// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

use std::process;
pub fn exit() {
    process::exit(0)
}
/// 比較可能な2つの引数のうち大きい方を返す
pub fn max<T: PartialOrd>(n: T, m: T) -> T {
    if n >= m {
        n
    } else {
        m
    }
}

/// 比較可能な2つの引数のうち小さい方を返す
pub fn min<T: PartialOrd>(n: T, m: T) -> T {
    if n <= m {
        n
    } else {
        m
    }
}

/// floor + as i64
pub fn into_floor(a: f64) -> i64 {
    (a - a % 1.0) as i64
}

/// ceil + as i64
pub fn into_ceil(a: f64) -> i64 {
    (a - a % 1.0) as i64 + 1i64
}

/// "Yes", "No" を出力
pub fn yes_no(flag: bool) {
    if flag {
        println!("Yes");
    } else {
        println!("No");
    }
}

/// Yes
pub fn yes() {
    println!("Yes");
}

/// No
pub fn no() {
    println!("No");
}

/// 互除法を用いて最大公約数を求める
pub fn gcd(n: u64, m: u64) -> u64 {
    let (mut n, mut m) = (max(n, m), min(n, m));
    let mut _r = 0;
    while n % m != 0 {
        _r = n % m;
        n = m;
        m = _r;
    }
    m
}

/// 最小公倍数を求める
pub fn lcm(n: u64, m: u64) -> u64 {
    n * m / gcd(n, m)
}

/// 配列全体の最大公約数
pub fn gcd_vec(v: &[u64]) -> u64 {
    let mut r = v[0];
    for i in v.iter().skip(1) {
        r = gcd(r, *i);
    }
    r
}

/// 配列全体の最小公倍数
pub fn lcm_vec(v: &[u64]) -> u64 {
    let mut r = v[0];
    for i in v.iter().skip(1) {
        r = lcm(r, *i);
    }
    r
}

/// Find the first factor (other than 1) of a number
fn firstfac(x: u64) -> u64 {
    if x % 2 == 0 {
        return 2;
    };
    // TODO: return to step_by
    // for n in (3..).step_by(2).take_while(|m| m*m <= x) {
    for n in (1..).map(|m| 2 * m + 1).take_while(|m| m * m <= x) {
        if x % n == 0 {
            return n;
        };
    }
    // No factor found. It must be prime.
    x
}

/// Test whether a number is prime. Checks every odd number up to `sqrt(n)`.
pub fn is_prime(n: u64) -> bool {
    if n <= 1 {
        return false;
    }
    firstfac(n) == n
}

// TODO!
// pub fn parmutation<T: PartialOrd>(v: &Vec<T>) -> Vec<Vec<T>> {
//     let mut sorted = v;

// }