code: function verifsint(value, max, min) {
    assert.ok(typeof (value) == 'number',
        'cannot write a non-number as a number');
  
    assert.ok(value <= max, 'value larger than maximum allowed value');
  
    assert.ok(value >= min, 'value smaller than minimum allowed value');
  
    assert.ok(Math.floor(value) === value, 'value has a fractional component');
  }
docs: /*
  We now move onto our friends in the signed number category. Unlike unsigned
  numbers, we're going to have to worry a bit more about how we put values into
  arrays. Since we are only worrying about signed 32-bit values, we're in
  slightly better shape. Unfortunately, we really can't do our favorite binary
  & in this system. It really seems to do the wrong thing. For example:
  
  > -32 & 0xff
  224
  
  What's happening above is really: 0xe0 & 0xff = 0xe0. However, the results of
  this aren't treated as a signed number. Ultimately a bad thing.
  
  What we're going to want to do is basically create the unsigned equivalent of
  our representation and pass that off to the wuint* functions. To do that
  we're going to do the following:
  
  - if the value is positive
  we can pass it directly off to the equivalent wuint
  - if the value is negative
  we do the following computation:
  mb + val + 1, where
  mb   is the maximum unsigned value in that byte size
  val  is the Javascript negative integer
  
  
  As a concrete value, take -128. In signed 16 bits this would be 0xff80. If
  you do out the computations:
  
  0xffff - 128 + 1
  0xffff - 127
  0xff80
  
  You can then encode this value as the signed version. This is really rather
  hacky, but it should work and get the job done which is our goal here.
   /*
  A series of checks to make sure we actually have a signed 32-bit number