code: public boolean shouldRollBack(long number) {
          // we roll back if the rule contains a modulus substitution,
          // the number being formatted is an even multiple of the rule's
          // divisor, and the rule's base value is NOT an even multiple
          // of its divisor
          // In other words, if the original description had
          //    100: << hundred[ >>];
          // that expands into
          //    100: << hundred;
          //    101: << hundred >>;
          // internally.  But when we're formatting 200, if we use the rule
          // at 101, which would normally apply, we get "two hundred zero".
          // To prevent this, we roll back and use the rule at 100 instead.
          // This is the logic that makes this happen: the rule at 101 has
          // a modulus substitution, its base value isn't an even multiple
          // of 100, and the value we're trying to format _is_ an even
          // multiple of 100.  This is called the "rollback rule."
          if (!((sub1 != null && sub1.isModulusSubstitution()) || (sub2 != null && sub2.isModulusSubstitution()))) {
              return false;
          }
          long divisor = power(radix, exponent);
          return (number % divisor) == 0 && (baseValue % divisor) != 0;
      }
docs: Used by the owning rule set to determine whether to invoke the
  rollback rule (i.e., whether this rule or the one that precedes
  it in the rule set's list should be used to format the number)
  @param number The number being formatted
  @return True if the rule set should use the rule that precedes
  this one in its list; false if it should use this rule