anchor.diff:              updatedValues[suffixRule] = -1;
             }
           }
  -      }
  -
  -      // We also need to consider the backwards case, where a later rule in the
  -      // suffix implies a rule in the prefix. If that happens, and the prefix
  -      // rule did not split, then we can't let the suffix rule that implies it
  -      // split either since that would lead to a failed implication.
  -      if (ruleValue == 0) {
  +      } else {
  +        // We also need to consider the backwards case, where a later rule in
  +        // the suffix implies a rule in the prefix. If that happens, and the
  +        // prefix rule did not split, then we can't let the suffix rule that
  +        // implies it split either since that would violate the implication.
           for (var suffixRule in suffixRules) {
             // If we already have a harder constraint, keep it.
             if (updatedValues.containsKey(suffixRule)) continue;
  
positive.code:           if (_ruleImplications[suffixRule].contains(prefixRule)) {
              updatedValues[suffixRule] = 0;
            }
          }
        }
      }
  
negative.code:     assert(value >= 0);
  
      var chunk = _chunks[prefix.length];
  
      // If the rule causes this chunk to split, recurse and find the best
      // solution for the suffix following this chunk.
      if (!chunk.rule.isSplit(value, chunk)) {
        // Keep track of the rule that did begin this line so we can take into
        // account its implications.
        var previousSplit;
        if (solution._prefix.length > 0) {
          previousSplit = _chunks[solution._prefix.length - 1].rule;
        }
  
        // If this chunk bumps us past the page limit and we already have a
        // solution that fits, no solution after this chunk will beat that, so
        // stop looking.
  