anchor.diff:    }
   
     int excludeNull(int value) {
  -    return value & (powersetTop - nullMask);
  +    return value & ~nullMask;
     }
   
     AbstractBool couldBeTypedArray(int value) => isOther(value);
  
positive.code: 
    AbstractBool isPrimitiveArray(int value) => isOther(value);
  
    AbstractBool isPrimitiveBoolean(int value) => isPotentiallyBoolean(value)
        ? AbstractBool.trueOrMaybe(
            isDefinitelyTrue(value) || isDefinitelyFalse(value))
        : AbstractBool.False;
  
    AbstractBool isPrimitiveNumber(int value) => isOther(value);
  
  
negative.code:   int get boolOrNullMask => boolMask | nullMask;
    int get nullOrOtherMask => nullMask | otherMask;
    int get boolNullOtherMask => boolOrNullMask | otherMask;
    int get preciseMask => _singletonIndices.fold(
        powersetBottom, (mask, index) => mask | 1 << index);
  
    int get powersetBottom => 0;
    int get powersetTop => (1 << _maxIndex + 1) - 1;
  
    bool isPotentiallyBoolean(int value) => (value & boolMask) != 0;
    bool isPotentiallyNull(int value) => (value & nullMask) != 0;
    bool isPotentiallyOther(int value) => (value & otherMask) != 0;
  
    bool isDefinitelyTrue(int value) => value == trueMask;
    bool isDefinitelyFalse(int value) => value == falseMask;
    bool isDefinitelyNull(int value) => value == nullMask;
    bool isSingleton(int value) =>
        isDefinitelyTrue(value) ||
        isDefinitelyFalse(value) ||
        isDefinitelyNull(value);
  
    /// Returns `true` if only singleton bits are set and `false` otherwise.
    bool isPrecise(int value) => value & ~preciseMask == 0;
  
    AbstractBool isOther(int value) =>
        AbstractBool.maybeOrFalse(isPotentiallyOther(value));
  