Important  This document may not represent best practices for current development, links to downloads and other resources may no longer be valid. Current recommended version can be found here. 
>> Operator (Visual Basic)
Performs an arithmetic right shift on a bit pattern.
result = pattern >> amount
 result

Required. Integral numeric value. The result of shifting the bit pattern. The data type is the same as that of pattern.
 pattern

Required. Integral numeric expression. The bit pattern to be shifted. The data type must be an integral type (SByte, Byte, Short, UShort, Integer, UInteger, Long, or ULong).
 amount

Required. Numeric expression. The number of bits to shift the bit pattern. The data type must be Integer or widen to Integer.
Arithmetic shifts are not circular, which means the bits shifted off one end of the result are not reintroduced at the other end. In an arithmetic right shift, the bits shifted beyond the rightmost bit position are discarded, and the leftmost (sign) bit is propagated into the bit positions vacated at the left. This means that if pattern has a negative value, the vacated positions are set to one; otherwise they are set to zero.
Note that the data types Byte, UShort, UInteger, and ULong are unsigned, so there is no sign bit to propagate. If pattern is of any unsigned type, the vacated positions are always set to zero.
To prevent shifting by more bits than the result can hold, Visual Basic masks the value of amount with a size mask corresponding to the data type of pattern. The binary AND of these values is used for the shift amount. The size masks are as follows:
Data type of pattern  Size mask (decimal)  Size mask (hexadecimal) 

SByte, Byte  7  &H00000007 
Short, UShort  15  &H0000000F 
Integer, UInteger  31  &H0000001F 
Long, ULong  63  &H0000003F 
If amount is zero, the value of result is identical to the value of pattern. If amount is negative, it is taken as an unsigned value and masked with the appropriate size mask.
Arithmetic shifts never generate overflow exceptions.
Overloading
The >> operator can be overloaded, which means that a class or structure can redefine its behavior when an operand has the type of that class or structure. If your code uses this operator on such a class or structure, be sure you understand its redefined behavior. For more information, see Operator Procedures.
The following example uses the >> operator to perform arithmetic right shifts on integral values. The result always has the same data type as that of the expression being shifted.
Dim pattern As Short = 2560 ' The bit pattern is 0000 1010 0000 0000. Dim result1, result2, result3, result4, result5 As Short result1 = pattern >> 0 result2 = pattern >> 4 result3 = pattern >> 10 result4 = pattern >> 18 result5 = pattern >> 1
The results of the preceding example are as follows:

result1 is 2560 (0000 1010 0000 0000).

result2 is 160 (0000 0000 1010 0000).

result3 is 2 (0000 0000 0000 0010).

result4 is 640 (0000 0010 1000 0000).

result5 is 0 (shifted 15 places to the right).
The shift amount for result4 is calculated as 18 AND 15, which equals 2.
The following example shows arithmetic shifts on a negative value.
Dim negPattern As Short = 8192 ' The bit pattern is 1110 0000 0000 0000. Dim negResult1, negResult2 As Short negResult1 = negPattern >> 4 negResult2 = negPattern >> 13
The results of the preceding example are as follows:

negresult1 is 512 (1111 1110 0000 0000).

negresult2 is 1 (the sign bit is propagated).