anchor.diff:      comment_line(Rest, Pos, Parsed);
   code(<<"/*",Rest/binary>>, Pos, Parsed) ->
       comment_block(Rest, Pos, Parsed);
  +code(<<A:8,_/binary>> = Rest, Pos, Parsed) when A =:= $' orelse A =:= $" ->
  +    {Rest0, Pos0, S} = string(Rest,Pos,[]),
  +    code(Rest0, Pos0, [S|Parsed]);
   code(<<"<<<",_/binary>> = Rest, Pos, Parsed) ->
  -    {Rest0, Pos0, Parsed0} = string(Rest,Pos,Parsed),
  +    {Rest0, Pos0, S} = string(Rest,Pos,[]),
  +    code(Rest0, Pos0, [S|Parsed]);
  +code(<<A:8,_/binary>> = Rest, Pos, Parsed) when ?IS_ALPHA(A) ->
  +    {Rest0, Pos0, Parsed0} = constant(Rest,Pos,Parsed),
       code(Rest0, Pos0, Parsed0);
   code(<<Space:1/binary,Rest/binary>>, Pos, Parsed) when ?IS_SPACE(Space) ->
       code(Rest, add_pos(Pos,1), Parsed);
   code(<<NewLine:1/binary,Rest/binary>>, Pos, Parsed) when ?IS_NEWLINE(NewLine) ->
       code(Rest, new_line(Pos), Parsed);
  +%% TODO: this should be handle via expression call inside of each function
  +% code(<<Op:3/binary,Rest/binary>>, Pos, Parsed) when ?IS_OP3(Op) ->
  +%     code(Rest, add_pos(Pos,3), add_op({Op,precedence0(Op)}, Parsed));
  +% code(<<Op:2/binary,Rest/binary>>, Pos, Parsed) when ?IS_OP2(Op) ->
  +%     code(Rest, add_pos(Pos,2), add_op({Op,precedence0(Op)}, Parsed));
  +% code(<<Op:1/binary,Rest/binary>>, Pos, Parsed) when ?IS_OP1(Op) ->
  +%     code(Rest, add_pos(Pos,1), add_op({Op,precedence(Op)}, Parsed));
  +code(<<";",Rest/binary>>, Pos, Parser) ->
  +    code(Rest, add_pos(Pos,1), Parser);
   code(<<_/utf8,_>> = Text, Pos, _) ->
       throw({error, {parse, Pos, sample_text(Text)}}).
   
  
positive.code:     shunting_yard(Rest, [Op], Postfix);
  shunting_yard([open|Rest], OpS, Postfix) ->
      shunting_yard(Rest, [open|OpS], Postfix);
  shunting_yard([close|Rest], OpS, Postfix) ->
      {Add, [_Drop|NewOpS]} = lists:splitwith(fun(A) -> A =/= open end, OpS),
      shunting_yard(Rest, NewOpS, Postfix ++ Add);
  shunting_yard([{_,{left,P1}}=Op|Rest], [{_,{_,P2}}]=OpS, Postfix) when P1 < P2 ->
      shunting_yard(Rest, [Op|OpS], Postfix);
  shunting_yard([{_,{right,P1}}=Op|Rest], [{_,{_,P2}}]=OpS, Postfix) when P1 =< P2 ->
      shunting_yard(Rest, [Op|OpS], Postfix);
  shunting_yard([{_,{left,P1}}=Op|Rest], [{_,{_,P2}}]=OpS, Postfix) when P1 >= P2 ->
      shunting_yard(Rest, [Op], Postfix ++ OpS);
  shunting_yard([{_,{right,P1}}=Op|Rest], [{_,{_,P2}}]=OpS, Postfix) when P1 > P2 ->
      shunting_yard(Rest, [Op], Postfix ++ OpS);
  shunting_yard([{_,{_,_}}=Op|Rest], OpS, Postfix) ->
      shunting_yard(Rest, [Op|OpS], Postfix);
  shunting_yard([A|Rest], OpS, Postfix) ->
      shunting_yard(Rest, OpS, Postfix ++ [A]).
  
  add_line(#eval{}=E, {_,Row,Col}) -> E#eval{line={{line,Row},{column,Col}}};
  add_line(#print{}=P, {_,Row,Col}) -> P#print{line={{line,Row},{column,Col}}};
  add_line(#variable{}=V, {_,R,C}) -> V#variable{line={{line,R},{column,C}}};
  add_line(#constant{}=C, {_,R,C}) -> C#constant{line={{line,R},{column,C}}};
  add_line(#int{}=I, {_,R,C}) -> I#int{line={{line,R},{column,C}}};
  add_line(#text_to_process{}=T, {_,R,C}) ->
      T#text_to_process{line={{line,R},{column,C}}};
  
negative.code: code_block_level({_,Row,Col}) -> {code_block,Row,Col}.
  code_value_level({_,Row,Col}) -> {code_value,Row,Col}.
  code_statement_level({_,Row,Col}) -> {code_statement,Row,Col}.
  arg_level({_,Row,Col}) -> {arg,Row,Col}.
  print_level({_,Row,Col}) -> {print,Row,Col}.
  
  add_op('end', [{op,Content}]) ->
      solve(Content);
  add_op(Add, [{op,Content}|Parsed]) ->
      [{op, Content ++ [Add]}|Parsed];
  add_op(Add, Parsed) ->
      [{op,[Add]}|Parsed].
  
  