Problem:
Score : 300 points

Problem Statement

As a token of his gratitude, Takahashi has decided to give his mother an integer sequence.
The sequence A needs to satisfy the conditions below:

A consists of integers between X and Y (inclusive).

For each 1\leq i \leq |A|-1, A_{i+1} is a multiple of A_i and strictly greater than A_i.

Find the maximum possible length of the sequence.

Constraints

1 \leq X \leq Y \leq 10^{18}

All input values are integers.

Input

Input is given from Standard Input in the following format:

X Y

Output

Print the maximum possible length of the sequence.

Sample Input 1

3 20

Sample Output 1

3

The sequence 3,6,18 satisfies the conditions.

Sample Input 2

25 100

Sample Output 2

3

Sample Input 3

314159265 358979323846264338

Sample Output 3

31

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

use std::io::BufRead;
use std::str::{self, FromStr};

pub struct StdinReader<R: BufRead> {
    reader: R,
    buf: Vec<u8>,
}

impl<R: BufRead> StdinReader<R> {
    pub fn new(reader: R) -> StdinReader<R> {
        StdinReader {
            reader: reader,
            buf: Vec::new(),
        }
    }

    pub fn reads<T: FromStr>(&mut self) -> T {
        self.read_until(b' ')
    }

    pub fn readl<T: FromStr>(&mut self) -> T {
        self.read_until(b'\n')
    }

    pub fn read_until<T: FromStr>(&mut self, delim: u8) -> T {
        loop {
            self.buf.clear();
            let len = self.reader
                .read_until(delim, &mut self.buf)
                .expect("failed reading bytes");
            match len {
                0 => panic!("early eof"),
                1 if self.buf[0] == delim => (),
                _ => {
                    if self.buf[len - 1] == delim {
                        self.buf.truncate(len - 1);
                    }
                    break;
                }
            }
        }

        let elem = str::from_utf8(&self.buf).expect("invalid utf-8 string");
        elem.parse()
            .unwrap_or_else(|_| panic!(format!("failed parsing: {}", elem)))
    }
}

fn solution<R: BufRead>(mut r: StdinReader<R>) -> String {
    let x: u64 = r.reads();
    let y: u64 = r.readl();
    let mut tmp: u64 = x;
    let mut ans: u64 = 0;
    while tmp <= y {
        ans += 1;
        tmp *= 2;
    }
    format!("{}", ans)
}

fn main() {
    use std::io::stdin;
    let stdin = stdin();
    let r = StdinReader::new(stdin.lock());
    println!("{}", solution(r));
}