anchor.diff:          OtherError ->
               OtherError
       end.
  -                
  +
   load_code(Module, Bin, Warnings) ->
       code:purge(Module),
       case code:load_binary(Module, atom_to_list(Module) ++ ".erl", Bin) of
  
positive.code: 
  tag_ast(Name, Args, Context, TreeWalker) ->
      {{InterpretedArgs, AstInfo1}, TreeWalker1} = lists:foldr(fun
              ({{identifier, _, Key}, {trans, StringLiteral}}, {{ArgsAcc, AstInfoAcc}, TreeWalkerAcc}) ->
                  {{TransAst, TransAstInfo}, TreeWalker0} = translated_ast(StringLiteral, Context, TreeWalkerAcc),
                  {{[erl_syntax:tuple([erl_syntax:atom(Key), TransAst])|ArgsAcc], merge_info(TransAstInfo, AstInfoAcc)}, TreeWalker0};
              ({{identifier, _, Key}, Value}, {{ArgsAcc, AstInfoAcc}, TreeWalkerAcc}) ->
                  {{Ast0, AstInfo0}, TreeWalker0} = value_ast(Value, false, false, Context, TreeWalkerAcc),
                  {{[erl_syntax:tuple([erl_syntax:atom(Key), Ast0])|ArgsAcc], merge_info(AstInfo0, AstInfoAcc)}, TreeWalker0}
          end, {{[], #ast_info{}}, TreeWalker}, Args),
  
      {RenderAst, RenderInfo} = custom_tags_modules_ast(Name, InterpretedArgs, Context),
      {{RenderAst, merge_info(AstInfo1, RenderInfo)}, TreeWalker1}.
  
  custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [], is_compiling_dir = false }) ->
      {erl_syntax:application(none, erl_syntax:atom(render_tag),
              [key_to_string(Name), erl_syntax:list(InterpretedArgs),
               erl_syntax:variable("RenderOptions")]),
          #ast_info{custom_tags = [Name]}};
  custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [], is_compiling_dir = true, module = Module }) ->
      {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
              [erl_syntax:list(InterpretedArgs), erl_syntax:variable("RenderOptions")]),
               #ast_info{ custom_tags = [Name] }};
  custom_tags_modules_ast(Name, InterpretedArgs, #dtl_context{ custom_tags_modules = [Module|Rest] } = Context) ->
      try lists:max([I || {N,I} <- Module:module_info(exports), N =:= Name]) of
          2 ->
              {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
                  [erl_syntax:list(InterpretedArgs),
                   erl_syntax:variable("RenderOptions")]), #ast_info{}};
          1 ->
              {erl_syntax:application(erl_syntax:atom(Module), erl_syntax:atom(Name),
                  [erl_syntax:list(InterpretedArgs)]), #ast_info{}};
          I ->
              throw({unsupported_custom_tag_fun, {Module, Name, I}})
      catch _:function_clause ->
          custom_tags_modules_ast(Name, InterpretedArgs,
              Context#dtl_context{ custom_tags_modules = Rest })
      end.
  
  print(true, Fmt, Args) ->
  
negative.code:                     case parse(CustomTagFile, Context) of
                          {ok, DjangoParseTree, CheckSum} ->
                              {{BodyAst, BodyAstInfo}, TreeWalker1} = with_dependency(
  								      {CustomTagFile, CheckSum}, body_ast(DjangoParseTree, Context, TreeWalker)),
                              MatchAst = options_match_ast(), 
                              Clause = erl_syntax:clause(
  				       [key_to_string(Tag), erl_syntax:variable("_Variables"), erl_syntax:variable("RenderOptions")],
  				       none, MatchAst ++ [BodyAst]),
                              custom_tags_clauses_ast1(CustomTags, [Tag|ExcludeTags],
  						     [Clause|ClauseAcc], merge_info(BodyAstInfo, InfoAcc), 
  						     Context, TreeWalker1);
                          Error ->
                              throw(Error)
                      end;
                  false ->
                      custom_tags_clauses_ast1(CustomTags, [Tag | ExcludeTags],
  					     ClauseAcc, InfoAcc, Context, TreeWalker)
              end
      end.
  
  dependencies_function(Dependencies) ->
      erl_syntax:function(
        erl_syntax:atom(dependencies), [erl_syntax:clause([], none, 
  							[erl_syntax:list(lists:map(fun 
  										       ({XFile, XCheckSum}) -> 
  											  erl_syntax:tuple([erl_syntax:string(XFile), erl_syntax:string(XCheckSum)])
  										  end, Dependencies))])]).
  
  translatable_strings_function(TranslatableStrings) ->
      erl_syntax:function(
        erl_syntax:atom(translatable_strings), [erl_syntax:clause([], none,
  								[erl_syntax:list(lists:map(fun(String) -> 
  												   erl_syntax:string(String) 
  											   end,
  											   TranslatableStrings))])]).
  
  translated_blocks_function(TranslatedBlocks) ->
      erl_syntax:function(
        erl_syntax:atom(translated_blocks), [erl_syntax:clause([], none,
  							     [erl_syntax:list(lists:map(fun(String) -> 
  												erl_syntax:string(String) 
  											end,
  											TranslatedBlocks))])]).
  
  variables_function(Variables) ->
      erl_syntax:function(
        erl_syntax:atom(variables), [erl_syntax:clause([], none,
  						     [erl_syntax:list([erl_syntax:atom(S) || S <- lists:usort(Variables)])])]). 
  
  custom_forms(Dir, Module, Functions, AstInfo) ->
      ModuleAst = erl_syntax:attribute(erl_syntax:atom(module), [erl_syntax:atom(Module)]),
      ExportAst = erl_syntax:attribute(erl_syntax:atom(export),
  				     [erl_syntax:list([
  						       erl_syntax:arity_qualifier(erl_syntax:atom(source_dir), erl_syntax:integer(0)),
  						       erl_syntax:arity_qualifier(erl_syntax:atom(dependencies), erl_syntax:integer(0)),
  						       erl_syntax:arity_qualifier(erl_syntax:atom(translatable_strings), erl_syntax:integer(0))
  						       | 
  						       lists:foldl(fun({FunctionName, _, _}, Acc) ->
  									   [erl_syntax:arity_qualifier(erl_syntax:atom(FunctionName), erl_syntax:integer(1)),
  									    erl_syntax:arity_qualifier(erl_syntax:atom(FunctionName), erl_syntax:integer(2))|Acc]
  								   end, [], Functions)]
  						     )]),
      SourceFunctionAst = erl_syntax:function(
  			  erl_syntax:atom(source_dir), [erl_syntax:clause([], none, [erl_syntax:string(Dir)])]),
      DependenciesFunctionAst = dependencies_function(AstInfo#ast_info.dependencies), 
      TranslatableStringsFunctionAst = translatable_strings_function(AstInfo#ast_info.translatable_strings),
      FunctionAsts = lists:foldl(fun({_, Function1, Function2}, Acc) -> [Function1, Function2 | Acc] end, [], Functions),
  
      [erl_syntax:revert(X) || X <- [ModuleAst, ExportAst, SourceFunctionAst, DependenciesFunctionAst, TranslatableStringsFunctionAst
  				   | FunctionAsts] ++ AstInfo#ast_info.pre_render_asts].
  
  forms(File, Module, {BodyAst, BodyInfo}, {CustomTagsFunctionAst, CustomTagsInfo}, BinaryStrings, CheckSum) ->
      MergedInfo = merge_info(BodyInfo, CustomTagsInfo),
      Render0FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  					     [erl_syntax:clause([], none, [erl_syntax:application(none, 
  												  erl_syntax:atom(render), [erl_syntax:list([])])])]),
      Render1FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  					     [erl_syntax:clause([erl_syntax:variable("_Variables")], none,
  								[erl_syntax:application(none,
  											erl_syntax:atom(render),
  											[erl_syntax:variable("_Variables"), erl_syntax:list([])])])]),
      Function2 = erl_syntax:application(none, erl_syntax:atom(render_internal), 
  				       [erl_syntax:variable("_Variables"), erl_syntax:variable("RenderOptions")]),
      ClauseOk = erl_syntax:clause([erl_syntax:variable("Val")], none,
  				 [erl_syntax:tuple([erl_syntax:atom(ok), erl_syntax:variable("Val")])]),     
      ClauseCatch = erl_syntax:clause([erl_syntax:variable("Err")], none,
  				    [erl_syntax:tuple([erl_syntax:atom(error), erl_syntax:variable("Err")])]),            
      Render2FunctionAst = erl_syntax:function(erl_syntax:atom(render),
  					     [erl_syntax:clause([erl_syntax:variable("_Variables"),
  								 erl_syntax:variable("RenderOptions")], none, 
  								[erl_syntax:try_expr([Function2], [ClauseOk], [ClauseCatch])])]),  
  
      SourceFunctionTuple = erl_syntax:tuple(
  			    [erl_syntax:string(File), erl_syntax:string(CheckSum)]),
      SourceFunctionAst = erl_syntax:function(
  			  erl_syntax:atom(source),
  			  [erl_syntax:clause([], none, [SourceFunctionTuple])]),
  
      DependenciesFunctionAst = dependencies_function(MergedInfo#ast_info.dependencies),
  
      TranslatableStringsAst = translatable_strings_function(MergedInfo#ast_info.translatable_strings),
  