anchor.diff:  simulate_impl([unary_minus|T]) ->
   	{Operand, NewStack} = simulate_impl(T),
   	{do_unary_operation(unary_minus, Operand), NewStack};
  +simulate_impl([if_then_else|T]) ->
  +	{Operand1, NewStack} = simulate_impl(T),
  +	case Operand1 of
  +		0 -> simulate_impl(unroll_stack(NewStack));
  +		_ -> 
  +			{ThenResult, StackWithElse} = simulate_impl(NewStack),
  +			StackWithoutElse = unroll_stack(StackWithElse),
  +			{ThenResult, StackWithoutElse}
  +	end;
   simulate_impl([H|T]) ->
   	{Operand2, NewStack} = simulate_impl(T),
   	{Operand1, NewStack2} = simulate_impl(NewStack),
   	{do_binary_operation(H, Operand1, Operand2), NewStack2}.
  +
  +unroll_stack([H|T]) when is_number(H)-> T;
  +unroll_stack([unary_minus|T]) -> unroll_stack(T);
  +unroll_stack([if_then_else|T]) ->
  +	%Unroll three operands
  +	unroll_stack(unroll_stack(unroll_stack(T)));
  +unroll_stack([_|T]) ->
  +	%Unroll two operands
  +	unroll_stack(unroll_stack(T));
  +unroll_stack([]) -> [].
   
   do_unary_operation(Operation, Operand) when Operation =:= unary_minus ->
   	-Operand.
  
positive.code: 	print_impl(Operand2),
  	io:format(" else "),
  	print_impl(Operand3).
  	
  compute_impl({number, Number}) ->
  	Number;
  compute_impl({unary_minus, Expression}) ->
  
negative.code: 	case {Operand1, Operand2} of
  		{{number, 0}, _} -> {number, 0};
  		{_, {number, 0}} -> {number, 0};
  		{{number, 1}, {number, 1}} -> {number, 1};
  		{{number, 1}, _} -> Operand2;
  		{_, {number, 1}} -> Operand1;
  		{{number, -1}, {number, -1}} -> {number, 1};
  