function cumulativeInverse(
  uint256 neumarkUlps,
  uint256 minEurUlps,
  uint256 maxEurUlps
) public constant returns (uint256 euroUlps) {
  require(maxEurUlps >= minEurUlps);
  require(cumulative(minEurUlps) <= neumarkUlps);
  require(cumulative(maxEurUlps) >= neumarkUlps);
  uint256 min = minEurUlps;
  uint256 max = maxEurUlps;

  // Binary search
  while (max > min) {
    uint256 mid = (max + min) / 2;
    uint256 val = cumulative(mid);
    // exact solution should not be used, a late points of the curve when many euroUlps are needed to
    // increase by one nmkUlp this will lead to  "indeterministic" inverse values that depend on the initial min and max
    // and further binary division -> you can land at any of the euro value that is mapped to the same nmk value
    // with condition below removed, binary search will point to the lowest eur value possible which is good because it cannot be exploited even with 0 gas costs
    /* if (val == neumarkUlps) {
                return mid;
            }*/
    // NOTE: approximate search (no inverse) must return upper element of the final range
    //  last step of approximate search is always (min, min+1) so new mid is (2*min+1)/2 => min
    //  so new min = mid + 1 = max which was upper range. and that ends the search
    // NOTE: when there are multiple inverses for the same neumarkUlps, the `max` will be dragged down
    //  by `max = mid` expression to the lowest eur value of inverse. works only for ranges that cover all points of multiple inverse
    if (val < neumarkUlps) {
      min = mid + 1;
    } else {
      max = mid;
    }
  }
  // NOTE: It is possible that there is no inverse
  //  for example curve(0) = 0 and curve(1) = 6, so
  //  there is no value y such that curve(y) = 5.
  //  When there is no inverse, we must return upper element of last search range.
  //  This has the effect of reversing the curve less when
  //  burning Neumarks. This ensures that Neumarks can always
  //  be burned. It also ensure that the total supply of Neumarks
  //  remains below the cap.
  return max;
}