anchor.diff:      List<jsAst.Statement> statements = <jsAst.Statement>[];
       if (trivialNsmHandlers.length == 0) return statements;
   
  +    bool minify = compiler.enableMinification;
  +    bool useDiffEncoding = minify && trivialNsmHandlers.length > 30;
  +
       // Find out how many selectors there are with the special calling
       // convention.
  -    bool hasSpecialCallingConvention(Selector selector) {
  -        return backend.isInterceptedName(selector.name);
  -    }
  -    Iterable<Selector> specialSelectors = trivialNsmHandlers.where(
  -        (Selector s) => backend.isInterceptedName(s.name));
  +    Iterable<Selector> interceptedSelectors = trivialNsmHandlers.where(
  +            (Selector s) => backend.isInterceptedName(s.name));
       Iterable<Selector> ordinarySelectors = trivialNsmHandlers.where(
  -        (Selector s) => !backend.isInterceptedName(s.name));
  +            (Selector s) => !backend.isInterceptedName(s.name));
   
       // Get the short names (JS names, perhaps minified).
  -    Iterable<jsAst.Name> specialShorts =
  -        specialSelectors.map(namer.invocationMirrorInternalName);
  +    Iterable<jsAst.Name> interceptedShorts =
  +        interceptedSelectors.map(namer.invocationMirrorInternalName);
       Iterable<jsAst.Name> ordinaryShorts =
           ordinarySelectors.map(namer.invocationMirrorInternalName);
   
  -    bool minify = compiler.enableMinification;
  -    bool useDiffEncoding = minify && trivialNsmHandlers.length > 30;
  -
  -    jsAst.Expression diffEncoding = new _DiffEncodedListOfNames(
  -        [specialShorts, ordinaryShorts],
  -        useDiffEncoding);
  -
  +    jsAst.Expression sortedShorts;
  +    Iterable<String> sortedLongs;
  +    if (useDiffEncoding) {
  +      assert(minify);
  +      sortedShorts = new _DiffEncodedListOfNames(
  +          [interceptedShorts, ordinaryShorts]);
  +    } else {
  +      Iterable<Selector> sorted =
  +          [interceptedSelectors, ordinarySelectors].expand((e) => (e));
  +      sortedShorts = js.concatenateStrings(
  +          js.joinLiterals(
  +              sorted.map(namer.invocationMirrorInternalName),
  +              js.stringPart(",")),
  +          addQuotes: true);
  +
  +      if (!minify) {
  +        sortedLongs = sorted.map((selector) =>
  +            selector.invocationMirrorMemberName);
  +      }
  +    }
       // Startup code that loops over the method names and puts handlers on the
       // Object class to catch noSuchMethod invocations.
       ClassElement objectClass = compiler.objectClass;
  
positive.code:                               implements AstContainer {
    String _cachedValue;
    jsAst.ArrayInitializer ast;
    bool useDiffEncoding;
  
    _DiffEncodedListOfNames(Iterable<Iterable<jsAst.Name>> names,
                            this.useDiffEncoding) {
      // Store the names in ArrayInitializer nodes to make them discoverable
      // by traversals of the ast.
      ast = new jsAst.ArrayInitializer(
  
negative.code: 
      int previous = 0;
      for (String short in shorts) {
        if (short.length <= NsmEmitter.MAX_MINIFIED_LENGTH_FOR_DIFF_ENCODING) {
          int base63 = fromBase88(short);
          int diff = base63 - previous;
          previous = base63;
          String base26Diff = toBase26(diff);
          diffEncoding.write(base26Diff);
        } else {
          if (diffEncoding.length != 0) {
            diffEncoding.write(',');
          }
          diffEncoding.write(short);
  