Problem understanding autoboxing

Hi! I have a mess here with boxing, I don't get it completely and I'm getting some estrange behaviour. Perhaps you guys can throw some light into it.

Please, see the code comments:

class MyClass{
	public void foo(){
		int i = 5;
		//Long j = i; //Cannot convert to long and box at the same time. This is how it works and we accept it.
		
		long l = i;  //A way to fix this is by first converting the value to long
		Long j2 = l; //and then autoboxing to an object. Ok!

//Same with other types:

char c = 5;
		//Integer x = c; //Nop, cannot convert and autobox in one step.
	
		int x = c; //But this is ok, there's no autobox here.

//More examples:

//Short s = c; //This doesn't work for the same reason.
		//Short s = x;

//And now with literals:

//Long j3 = 5; //Cannot convert from int to long and then autobox.
		Long j43 = 5L; //This works because the literal is considered a long literal by appending 'L'

//Now, the horror:

Short s = 5; //why does this compile???? the literal is an integer, it shouldn't be able to convert and autobox at the same time.
		Short s1 = (int)5; //why does this compile????
		Short s1 = (char)5; //why does this compile????
		//Short s1 = (long)5; //And now, this one does NOT compile ??? where's the logic

//Short s = 50000000; //doesn't compile here, number is an integer (too big for short)
		
	}
}

I think there's some compile magic that I'm missing.

please check the JLS here JLS - Narrowing Primitive Conversion Sec 5.2 It says narrowing int to short, byte and char is allowed if the values are within the legal ranges of them respectively!

In addition, if the expression is a constant expression (§15.28) of type byte, short, char or int :

A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the variable.
A narrowing primitive conversion followed by a boxing conversion may be used if the type of the variable is :
Byte and the value of the constant expression is representable in the type byte.
Short and the value of the constant expression is representable in the type short.
Character and the value of the constant expression is representable in the type char.
If the type of the expression cannot be converted to the type of the variable by a conversion permitted in an assignment context, then a compile-time error occurs.
If the type of the variable is float or double, then value set conversion is applied to the value v that is the results of the type conversion:

If v is of type float and is an element of the float-extended-exponent value set, then the implementation must map v to the nearest element of the float value set. This conversion may result in overflow or underflow.
If v is of type double and is an element of the double-extended-exponent value set, then the implementation must map v to the nearest element of the double value set. This conversion may result in overflow or underflow.
If the type of an expression can be converted to the type of a variable by assignment conversion, we say the expression (or its value) is assignable to the variable or, equivalently, that the type of the expression is assignment compatible with the type of the variable.

If, after the type conversions above have been applied, the resulting value is an object which is not an instance of a subclass or subinterface of the erasure of the type of the variable, then a ClassCastException is thrown.

also check the following code.