In wrestling with an older file format, it's notable how entrenched 32-bit numbers are (for bit fiddling purposes) within big specifications. JavaScript itself (I believe) converts its numbers to 32-bit for the purposes of its **<<**, **>>** and **>>>** operators.

As R3 Alpha and Ren-C shifts on 64-bit signed integers, it is not then compatible with some of those older specification. Thus I was trying to twist my brain into figuring out how bridge the gap. In short, I gave up and went with this approach which, while appalling, works as intended:

```
bits-zero: enbase/base #{0000000000000000} 2
bits-one: enbase/base #{FFFFFFFFFFFFFFFF} 2
brute-force-shift: func [
value [binary!]
bits [integer!]
/logical
<local> length is-negative
][
length: 8 * length-of value
not-negative: zero? 128 and+ value/1
value: enbase/base value 2
case [
not negative? bits [
insert reverse value skip bits-zero 64 - bits
reverse head clear skip value length
]
any [
logical
not-negative
][
insert value skip tail bits-zero bits
head clear skip value length
]
<else> [
insert value skip tail bits-one bits
head clear skip value length
]
]
debase/base value 2
]
```

It works on **binary!** values up to 8 bytes and operates based on whatever the width of the input binary is, thus can be used along with **enbin/debin** to operate on **integer!** values at any desired width.

While it'd be useful to have a native version that operated on **integer!** with **enbin/debin**-like paramaters, my case use only needed the op on a **binary!** value without the round trip.