# V5004\. OWASP\. Consider inspecting the expression\. Bit shifting of the 32\-bit value with a subsequent expansion to the 64\-bit type\.

The analyzer has detected a potential error in an expression containing a shift operation: a 32\-bit value is shifted in the program\. The resulting 32\-bit value is then explicitly or implicitly cast to a 64\-bit type\.

Consider an example of incorrect code:

```cpp
unsigned __int64 X;
X = 1u << N;
```

This code causes [undefined behavior](https://pvs-studio.com/en/blog/posts/cpp/0142/) if the N value is higher than 32\. In practice, it means that you cannot use this code to write a value higher than 0x80000000 into the 'X' variable\.

You can fix the code by making the type of the left argument 64\-bit\.

This is the correct code:

```cpp
unsigned __int64 X;
X = 1ui64 << N;
```

The analyzer will not generate the warning if the result of an expression with the shift operation fits into a 32\-bit type\. It means that significant bits don't get lost and the code is correct\.

This is an example of safe code:

```cpp
char W = 7;
long long Q = W << 10;
```

The code works in the following way\. At first, the 'W' variable is extended to the 32\-bit 'int' type\. Then a shift operation is performed and we get the value 0x00001C00\. This number fits into a 32\-bit type, which means that no error occurs\. At the last step this value is extended to the 64\-bit 'long long' type and written into the 'Q' variable\.