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: Wrong Answer)

use std::io::*;
use std::str::FromStr;

#[allow(dead_code)]
fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[allow(dead_code)]
struct FenwickTree {
    seq: Vec<i64>,
}
#[allow(dead_code)]
impl FenwickTree {
    fn new(n: usize) -> FenwickTree {
        FenwickTree { seq: vec![0; n + 2] }
    }
    fn add(&mut self, index: usize, value: i64) {
        let mut index = (index + 1) as i32;
        while (index as usize) < self.seq.len() {
            self.seq[index as usize] += value;
            index += index & -index;
        }
    }
    // inclusive
    fn sum(&self, index: usize) -> i64 {
        let mut ret = 0;
        let mut index = (index + 1) as i32;
        while index > 0 {
            ret += self.seq[index as usize];
            index -= index & -index;
        }
        ret
    }
}

struct Solver {
    s: Vec<char>,
}

impl Solver {
    fn new() -> Solver {
        Solver { s: read::<String>().chars().collect::<Vec<char>>(), }
    }
    fn solve(&mut self) {
        let s: &Vec<char> = &self.s;
        let n = s.len();
        let mut indexs = vec![vec![]; 200];
        for i in 0..n {
            indexs[s[i] as usize].push(i);
        }
        let odd_cnt = indexs.iter().filter(|vs| vs.len() != 0 && vs.len() % 2 == 1).count();
        if odd_cnt > 1 {
            println!("-1");
            return;
        }
        let mut dests = vec![None; n];
        let mut srcs = vec![None; n];
        let mut ans = 0;
        let mut mid = None;
        for index in indexs.iter() {
            for i in 0..index.len() / 2 {
                let revi = index.len() - i - 1;
                dests[index[i]] = Some(index[revi]);
                srcs[index[revi]] = Some(index[i]);
            }
            if index.len() % 2 == 1 {
                mid = Some(index[index.len() / 2]);
            }
        }   
        let mut starts = FenwickTree::new(n);
        let mut ends = FenwickTree::new(n);
        for pos in 0..n {
            if let Some(src) = srcs[pos] {
                if let Some(mid) = mid {
                    if mid < src || pos < mid { ans += 2; }
                }
                starts.add(src, -1);
                let inner = (ends.sum(pos) - ends.sum(src)) as usize;
                let intersect = (pos - src - 1) - inner * 2;
                let over = starts.sum(src) as usize;
                let outer = n / 2 - 1 - inner - intersect - over;
                ans += intersect + outer * 2;
                ends.add(src, 1);
            }
            if let Some(_) = dests[pos] {
                starts.add(pos, 1);
            }
        }
        println!("{}", ans / 2);
    }
}

fn main() {
    let mut solver = Solver::new();
    solver.solve();
}