import java.io.IOException;
import java.util.Scanner;
import java.util.StringTokenizer;
/*
* 3n+1 Problem: problema basico para entender memoria dinamica
* la version de aqui es diferente a la que entregue al juez
* la razon es que el problema si lo leen no tiene condcion de
* escape, me toco implementar unas cosas remamonas con buffer
* reader y una funcion que encontre por internet pero ambas hacen
* ruido por lo cual lo dejo con solo el scanner >_<
*
*/
public class Main {
//Nos dicen que las entradas estan entre 1 y 1000000
static int size = 1000005;
//El Vector para almacenar los valores ya calculados
static long[] granizada = new long[size];
public static void main(String[] args) {
long i = 1;
long j = 1;
long temp;
granizada[1]=1;
Scanner scn = new Scanner (System.in);
while (scn.hasNext()){
i = scn.nextInt();
j = scn.nextInt();
String n = null;
long mem=0;
long max=0;
// no dice que i se siempre menor que j
if(i>j){
temp=i;
i=j;
j=temp;
}
// ojo aqui va hasta j
for (long a=i; a<=j; a++){
mem = memDinamCic(a);
if(max < mem)
max = mem;
}
System.out.println(i + " " + j + " " + max);
}
}
/*
* La vaina se reduce a que si estamos buscando un numero
* que se demora una cantidad x de ciclos, por ejemplo 3
* la secuencia seria:
* 3 -> son 8 Ciclos
* 10 -> son 7 Ciclos
* 5 -> son 6 Ciclos
* 16 -> son 5 Ciclos
* .
* .
* .
* Ya vieron el invariante, si yo guardo en el vector la
* la cantidad de ciclos de 10 cuando me pidan 3 solo voy
* a tener sumarle 1 al valor de 10 que ya conosco...
* */
private static long memDinamCic(long a) {
if(a<size){
if(granizada[(int) a]!=0)
return granizada[(int) a];
}
if(a%2!=0){
if(a<size){
granizada[(int) a] = 1 + memDinamCic((a*3)+1);
return granizada[(int) a];
}
return 1 + memDinamCic((a*3)+1);
}
else{
if(a<size){
granizada[(int) a]= 1 + memDinamCic(a/2);
return granizada[(int) a];
}
return 1 + memDinamCic(a/2);
}
}
}