anchor.diff:          _ when ?is_upcase(H) ->
             tokenize_alias(Rest, Line, Column, Atom, Length, HasEnding, Scope, Tokens);
           _ ->
  -          tokenize_other_identifier(Rest, Line, Column, Atom, Scope, Tokens)
  +          tokenize_other_identifier(Rest, Line, Column, Length, Atom, Scope, Tokens)
         end;
       {error, Reason} ->
         {error, Reason, Original, Tokens}
  
positive.code:       tokenize(Rest, Line, Column + Length, Scope, [{aliases, {Line, Column, Column + Length}, [Atom]}|Tokens])
    end.
  
  tokenize_other_identifier(Rest, Line, Column, Atom, Scope, Tokens) ->
    case tokenize_kw_or_other(Rest, identifier, Line, Column, Atom, Tokens) of
      {keyword, Rest, {_, {_, _, EndColumn}} = Check, T} ->
        handle_terminator(Rest, Line, EndColumn, Scope, Check, T);
      {keyword, Rest, {_, {_, _, EndColumn}, _} = Check, T} ->
  
negative.code: 
  % ## Two Token Operators
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?two_op(T1, T2) ->
    handle_op(Rest, Line, Column, two_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) ->
    handle_op(Rest, Line, Column, arrow_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) ->
    handle_op(Rest, Line, Column, comp_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) ->
    handle_op(Rest, Line, Column, rel_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) ->
    handle_op(Rest, Line, Column, and_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) ->
    handle_op(Rest, Line, Column, or_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) ->
    handle_op(Rest, Line, Column, in_match_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) ->
    handle_op(Rest, Line, Column, type_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  tokenize([T1, T2|Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) ->
    handle_op(Rest, Line, Column, stab_op, 2, list_to_atom([T1, T2]), Scope, Tokens);
  
  % ## Single Token Operators
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?at_op(T) ->
    handle_unary_op(Rest, Line, Column, at_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?capture_op(T) ->
    handle_unary_op(Rest, Line, Column, capture_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?unary_op(T) ->
    handle_unary_op(Rest, Line, Column, unary_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?rel_op(T) ->
    handle_op(Rest, Line, Column, rel_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?dual_op(T) ->
    handle_unary_op(Rest, Line, Column, dual_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?mult_op(T) ->
    handle_op(Rest, Line, Column, mult_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?match_op(T) ->
    handle_op(Rest, Line, Column, match_op, 1, list_to_atom([T]), Scope, Tokens);
  
  tokenize([T|Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) ->
    handle_op(Rest, Line, Column, pipe_op, 1, list_to_atom([T]), Scope, Tokens);
  
  % Others
  
  