anchor.diff:      // END: Keyword check
     }
   
  -  int tokenizeString(int next, int start, bool raw) {
  -    _log("Running tokenizeString($next, $start, $raw)");
  +  int _tokenizeString(int next, int start, bool raw) {
  +    _log("Running _tokenizeString($next, $start, $raw)");
       
       int quoteChar = next;
  -    next = advance();
  +    next = _advance();
       if (identical(quoteChar, next)) {
  -      next = advance();
  +      next = _advance();
         if (identical(quoteChar, next)) {
           // Multiline string.
  -        return tokenizeMultiLineString(quoteChar, start, raw);
  +        return _tokenizeMultiLineString(quoteChar, start, raw);
         } else {
           // Empty string.
  -        return appendPath(utf8String(start, -1), next);
  +        return _appendPath(_utf8String(start, -1), next);
         }
       }
       if (raw) {
  -      return tokenizeSingleLineRawString(next, quoteChar, start);
  +      return _tokenizeSingleLineRawString(next, quoteChar, start);
       } else {
  -      return tokenizeSingleLineString(next, quoteChar, start);
  -    }
  -  }
  -  
  -  int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
  -    _log("Running tokenizeSingleLineRawString($next, $quoteChar, $start)");
  -    
  -    next = advance();
  +      return _tokenizeSingleLineString(next, quoteChar, start);
  +    }
  +  }
  +  
  +  int _tokenizeSingleLineRawString(int next, int quoteChar, int start) {
  +    _log("Running _tokenizeSingleLineRawString($next, $quoteChar, $start)");
  +    
  +    next = _advance();
       while (next != _U.$EOF) {
         if (identical(next, quoteChar)) {
  -        return appendPath(utf8String(start, 0), advance());
  +        return _appendPath(_utf8String(start, 0), _advance());
         } else if (identical(next, _U.$LF) || identical(next, _U.$CR)) {
  -        return error("unterminated string literal");
  -      }
  -      next = advance();
  -    }
  -    return error("unterminated string literal");
  -  }
  -  
  -  int tokenizeSingleLineString(int next, int quoteChar, int start) {
  -    _log("Running tokenizeSingleLineString($next, $quoteChar, $start)");
  +        return _error("unterminated string literal");
  +      }
  +      next = _advance();
  +    }
  +    return _error("unterminated string literal");
  +  }
  +  
  +  int _tokenizeSingleLineString(int next, int quoteChar, int start) {
  +    _log("Running _tokenizeSingleLineString($next, $quoteChar, $start)");
       
       while (!identical(next, quoteChar)) {
         if (identical(next, _U.$BACKSLASH)) {
  -        next = advance();
  +        next = _advance();
         } else if (identical(next, _U.$$)) {
           // URI's can't use String Interpolation
  -        return error("uri's can't contain string interpolation");
  +        return _error("uri's can't contain string interpolation");
         }
         if (next <= _U.$CR
             && (identical(next, _U.$LF) || 
                 identical(next, _U.$CR) || 
                 identical(next, _U.$EOF))) {
  -        return error("unterminated string literal");
  -      }
  -      next = advance();
  -    }
  -    return appendPath(utf8String(start + 1, -1), advance());
  -  }
  -  
  -  int tokenizeSlashOrComment(int next) {
  -    _log("Running tokenizeSlashOrComment($next)");
  -    
  -    next = advance();
  +        return _error("unterminated string literal");
  +      }
  +      next = _advance();
  +    }
  +    return _appendPath(_utf8String(start + 1, -1), _advance());
  +  }
  +  
  +  int _tokenizeSlashOrComment(int next) {
  +    _log("Running _tokenizeSlashOrComment($next)");
  +    
  +    next = _advance();
       if (identical(_U.$STAR, next)) {
  -      return tokenizeMultiLineComment(next);
  +      return _tokenizeMultiLineComment(next);
       } else if (identical(_U.$SLASH, next)) {
  -      return tokenizeSingleLineComment(next);
  +      return _tokenizeSingleLineComment(next);
       } else {
         // The rest of choices is /= and this is not allowed with imports.
         return _U.$EOF;
       }
     }
     
  -  int tokenizeMultiLineComment(int next) {
  -    _log("Running tokenizeMultiLineComment($next)");
  +  int _tokenizeMultiLineComment(int next) {
  +    _log("Running _tokenizeMultiLineComment($next)");
       
       int nesting = 1;
  -    next = advance();
  +    next = _advance();
       while (true) {
         if (identical(_U.$EOF, next)) {
           // TODO(ahe): Report error.
           return next;
         } else if (identical(_U.$STAR, next)) {
  -        next = advance();
  +        next = _advance();
           if (identical(_U.$SLASH, next)) {
             --nesting;
             if (0 == nesting) {
  -            next = advance();
  -            appendComment();
  +            next = _advance();
  +            _appendComment();
               return next;
             } else {
  -            next = advance();
  +            next = _advance();
             }
           }
         } else if (identical(_U.$SLASH, next)) {
  -        next = advance();
  +        next = _advance();
           if (identical(_U.$STAR, next)) {
  -          next = advance();
  +          next = _advance();
             ++nesting;
           }
         } else {
  -        next = advance();
  -      }
  -    }
  -  }
  -  
  -  int tokenizeSingleLineComment(int next) {
  -    _log("Running tokenizeSingleLineComment($next)");
  +        next = _advance();
  +      }
  +    }
  +  }
  +  
  +  int _tokenizeSingleLineComment(int next) {
  +    _log("Running _tokenizeSingleLineComment($next)");
       
       while (true) {
  -      next = advance();
  +      next = _advance();
         if (identical(_U.$LF, next) || 
             identical(_U.$CR, next) || 
             identical(_U.$EOF, next)) {
  -        appendComment();
  +        _appendComment();
           return next;
         }
       }
     }
     
  -  int tokenizeMultiLineRawString(int quoteChar, int start) {
  -    _log("Running tokenizeMultiLineRawString($quoteChar, $start)");
  -    
  -    int next = advance();
  +  int _tokenizeMultiLineRawString(int quoteChar, int start) {
  +    _log("Running _tokenizeMultiLineRawString($quoteChar, $start)");
  +    
  +    int next = _advance();
       outer: while (!identical(next, _U.$EOF)) {
         while (!identical(next, quoteChar)) {
  -        next = advance();
  +        next = _advance();
           if (identical(next, _U.$EOF)) break outer;
         }
  -      next = advance();
  +      next = _advance();
         if (identical(next, quoteChar)) {
  -        next = advance();
  +        next = _advance();
           if (identical(next, quoteChar)) {
             // appendByteStringToken(STRING_INFO, utf8String(start, 0));
             // return advance();
  -          return appendPath(utf8String(start, 0), advance());
  +          return _appendPath(_utf8String(start, 0), _advance());
           }
         }
       }
  -    return error("unterminated string literal");
  -  }
  -  
  -  int tokenizeMultiLineString(int quoteChar, int start, bool raw) {
  -    _log("Running tokenizeMultiLineString($quoteChar, $start, $raw)");
  -    
  -    if (raw) return tokenizeMultiLineRawString(quoteChar, start);
  -    int next = advance();
  +    return _error("unterminated string literal");
  +  }
  +  
  +  int _tokenizeMultiLineString(int quoteChar, int start, bool raw) {
  +    _log("Running _tokenizeMultiLineString($quoteChar, $start, $raw)");
  +    
  +    if (raw) return _tokenizeMultiLineRawString(quoteChar, start);
  +    int next = _advance();
       while (!identical(next, _U.$EOF)) {
         if (identical(next, _U.$$)) {
  -        start = byteOffset;
  +        start = _byteOffset;
           continue;
         }
         if (identical(next, quoteChar)) {
  -        next = advance();
  +        next = _advance();
           if (identical(next, quoteChar)) {
  -          next = advance();
  +          next = _advance();
             if (identical(next, quoteChar)) {
  -            return appendPath(utf8String(start,0), advance());
  +            return _appendPath(_utf8String(start,0), _advance());
             }
           }
           continue;
         }
         if (identical(next, _U.$BACKSLASH)) {
  -        next = advance();
  +        next = _advance();
           if (identical(next, _U.$EOF)) break;
         }
  -      next = advance();
  -    }
  -    return error("unterminated string literal");
  -  }
  -  
  -  String utf8String(int start, int offset) {
  -    _log("Running utf8String($start, $offset)");
  -    
  -    return new String.fromCharCodes(bytes.sublist(start,byteOffset+offset+1));
  -  }
  -  
  -  int error(String message) {
  -    _err("Running error($message)");
  +      next = _advance();
  +    }
  +    return _error("unterminated string literal");
  +  }
  +  
  +  String _utf8String(int start, int offset) {
  +    _log("Running _utf8String($start, $offset)");
  +    
  +    return new String.fromCharCodes(_bytes.sublist(start,_byteOffset+offset+1));
  +  }
  +  
  +  int _error(String message) {
  +    _err("Running _error($message)");
       return _U.$EOF;
     }
     
  -  int appendPath(String path, int returnValueIfAppended) {
  -    _log("Running appendPath($path, $returnValueIfAppended)");
  -    
  -    if (nextTokenIsImportant) {
  -      dependencies.add(path);
  -      nextTokenIsImportant = false;
  +  int _appendPath(String path, int returnValueIfAppended) {
  +    _log("Running _appendPath($path, $returnValueIfAppended)");
  +    
  +    if (_nextTokenIsImportant) {
  +      _dependencies.add(path);
  +      _nextTokenIsImportant = false;
       }
       return returnValueIfAppended;
     }
     
  -  void appendComment() {
  -    _log("Running appendComment()");
  +  void _appendComment() {
  +    _log("Running _appendComment()");
       // Comments is not important for us so just ignore.
     }
   }
  
positive.code:     }
      
      if (identical(next, _U.$SEMICOLON)) {
        nextTokenIsImportant = false;
      }
      
      // We only need to check for chars we find important.
      return advance(); // Ignore and get next char
    }
    
    int tokenizeRawStringKeywordOrIdentifier(int next) {
      _log("Running tokenizeRawStringKeywordOrIdentifier($next)");
      
      int nextnext = peek();
      if (identical(nextnext, _U.$DQ) || identical(nextnext, _U.$SQ)) {
        int start = byteOffset;
        next = advance();
        return tokenizeString(next, start, true);
      }
      return tokenizeKeywordOrIdentifier(next, true);
    }
    
    int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
      _log("Running tokenizeKeywordOrIdentifier($next, $allowDollar)");
      
      StringBuffer state = new StringBuffer();
      int start = byteOffset;
      
      while ((_U.$a <= next && next <= _U.$z) || 
             (_U.$A <= next && next <= _U.$Z)) {
        state.writeCharCode(next);
        next = advance();
      }
      
      // BEGIN: Keyword check (we only need: import, part, export
  
negative.code:     if ((_U.$a <= next && next <= _U.$z) ||
          (_U.$A <= next && next <= _U.$Z)) {
        if (identical(_U.$r, next)) {
          return _tokenizeRawStringKeywordOrIdentifier(next);
        }
        return _tokenizeKeywordOrIdentifier(next, true);
      }
      
      if (identical(next, _U.$DQ) || identical(next, _U.$SQ)) {
        return _tokenizeString(next, _byteOffset, false);
      }
      
      if (identical(next, _U.$SLASH)) {
        return _tokenizeSlashOrComment(next);
      }
      
      if (identical(next, _U.$EOF)) {
  