anchor.diff:    /** Returns `this`. */
     int floor();
   
  -  /** Returns [this]. */
  +  /** Returns `this`. */
     int ceil();
   
  -  /** Returns [this]. */
  +  /** Returns `this`. */
     int truncate();
   
     /** Returns `this.toDouble()`. */
  
positive.code:   double truncateToDouble();
  
    /**
     * Returns a representation of this [int] value.
     *
     * It should always be the case that if [:i:] is an [int] value,
     * then [:i == int.parse(i.toString()):].
     */
    String toString();
  
  
negative.code:  * It is a compile-time error for a class to attempt to extend or implement int.
   */
  abstract class int extends num {
    /**
     * Bit-wise and operator.
     *
     * Treating both `this` and [other] as sufficiently large two's component
     * integers, the result is a number with only the bits set that are set in
     * both `this` and [other]
     *
     * Of both operands are negative, the result is negative, otherwise
     * the result is non-negative.
     */
    int operator &(int other);
  
    /**
     * Bit-wise or operator.
     *
     * Treating both `this` and [other] as sufficiently large two's component
     * integers, the result is a number with the bits set that are set in either
     * of `this` and [other]
     *
     * If both operands are non-negative, the result is non-negative,
     * otherwise the result us negative.
     */
    int operator |(int other);
  
    /**
     * Bit-wise exclusive-or operator.
     *
     * Treating both `this` and [other] as sufficiently large two's component
     * integers, the result is a number with the bits set that are set in one,
     * but not both, of `this` and [other]
     *
     * If the operands have the same sign, the result is non-negative,
     * otherwise the result is negative.
     */
    int operator ^(int other);
  
    /**
     * The bit-wise negate operator.
     *
     * Treating `this` as a sufficiently large two's component integer,
     * the result is a number with the opposite bits set.
     *
     * This maps any integer `x` to `-x - 1`.
     */
    int operator ~();
  
    /**
     * Shift the bits of this integer to the left by [shiftAmount].
     *
     * Shifting to the left makes the number larger, effectively multiplying
     * the number by `pow(2, shiftIndex)`.
     *
     * There is no limit on the size of the result. It may be relevant to
     * limit intermediate values by using the "and" operator with a suitable
     * mask.
     *
     * It is an error of [shiftAmount] is negative.
     */
    int operator <<(int shiftAmount);
  
    /**
     * Shift the bits of this integer to the right by [shiftAmount].
     *
     * Shifting to the right makes the number smaller and drops the least
     * significant bits, effectively doing an integer division by
     *`pow(2, shiftIndex)`.
     *
     * It is an error of [shiftAmount] is negative.
     */
    int operator >>(int shiftAmount);
  
    /** Returns true if and only if this integer is even. */
  