anchor.diff:          self.emitFullDedent()
   } -> channel(HIDDEN)
      ;
  -   
  +
   WHITESPACE: ('\t' | ' ')+
  -{        
  -if (self._tokenStartColumn == 0 and self._openBRCount == 0 
  +{
  +if (self._tokenStartColumn == 0 and self._openBRCount == 0
       and not self._lineContinuation):
  -    
  +
       la = self._input.LA(1)
  -    if la not in [ord('\r'), ord('\n'), ord('#')]:
  +    if la not in [ord('\r'), ord('\n'), ord('#'), -1]:
           self._suppressNewlines = False
           wsCount = 0
           for ch in self.text:
  -            if   ch == ' ':  wsCount += 1
  +            if   ch == ' ' : wsCount += 1
               elif ch == '\t': wsCount += 8
   
           if wsCount > self._indents.wsval():
  
positive.code:         if t.type != Token.EOF:
              return t
          else:
              self.emitFullDedent()
              self.emitEndmarker()
              self.emitEndToken(t)  
              return self._tokens.deq()
              
  def emitEndToken(self, token):
      self._tokens.enq(token)
      
  def emitIndent(self, length=0, text='INDENT'):
      t = self.createToken(Python2Parser.INDENT, text, length)
      self._tokens.enq(t)
      
  def emitDedent(self):
      t = self.createToken(Python2Parser.DEDENT, 'DEDENT')
      self._tokens.enq(t)
      
  def emitFullDedent(self):
      while not self._indents.empty():
          self._indents.pop()
          self.emitDedent()
      
  def emitEndmarker(self):
      t = self.createToken(Python2Parser.ENDMARKER, 'ENDMARKER')
      self._tokens.enq(t)
      
  def emitNewline(self):
      t = self.createToken(Python2Parser.NEWLINE, 'NEWLINE')
      self._tokens.enq(t)
    
  def createToken(self, type_, text="", length=0):
      start = self._tokenStartCharIndex
      stop = start + length
      t = CommonToken(self._tokenFactorySourcePair, 
                      type_, self.DEFAULT_TOKEN_CHANNEL, 
                      start, stop)
      t.text = text
      return t
  }
  
  // Included from official site.
  /*
   * Grammar for Python
   *
  
negative.code: /*
   * Parser grammar taken directly from official Python 2.7.13 grammar
   * with only minor syntactical changes (instances of [X] changed to (X)?, and
   * semicolons added to ends of rules).:
   * https://docs.python.org/2/reference/grammar.html
   *
   * Added lexer rules, and code to handle INDENT's, DEDENT's,
   * line continuations, etc.
   *
   * Compiles with ANTLR 4.7, generated lexer/parser for Python 2 target.
   */
   
   grammar Python2;
  
   tokens { INDENT, DEDENT, NEWLINE, ENDMARKER }
  
  @lexer::header {
  from Python2Parser import Python2Parser
  from antlr4.Token  import CommonToken
  
  class IndentStack:
      def __init__(self)    : self._s = []
      def empty(self)       : return len(self._s) == 0
      def push(self, wsval) : self._s.append(wsval)
      def pop(self)         : self._s.pop()
      def wsval(self)       : return self._s[-1] if len(self._s) > 0 else 0
  
  class TokenQueue:
      def __init__(self)  : self._q = []
      def empty(self)     : return len(self._q) == 0
      def enq(self, t)    : self._q.append(t)
      def deq(self)       : return self._q.pop(0)
  }
  
  @lexer::members {
      # Indented to append code to the constructor.
      self._openBRCount       = 0
      self._suppressNewlines  = False
      self._lineContinuation  = False
      self._tokens            = TokenQueue()
      self._indents           = IndentStack()
  
  def nextToken(self):
      if not self._tokens.empty():
          return self._tokens.deq()
  