method vstmt_aux stmt =
    let treat_loop body_ref stmt =

      (* varinfo of the init_var associated to this loop *)
      let vi_init = Data_for_aorai.get_varinfo (Data_for_aorai.loopInit^"_"^(string_of_int stmt.sid)) in


(*    1) The associated init variable is set to 0 in first position
         (or in second position if the first stmt is a if)*)


      let stmt_varset =
        Cil.mkStmtOneInstr
          (Set((Var vi_init,NoOffset),
               Aorai_utils.mk_int_exp 0, Location.unknown))
      in
      stmt_varset.sid<-(Cil.Sid.next ());
      stmt_varset.ghost<-true;

      begin
        (* Function adaptated from the cil printer *)
        try
          let rec skipEmpty = function
              [] -> []
            | {skind=Instr (Skip _);labels=[]} :: rest -> skipEmpty rest
            | x -> x
          in

          match skipEmpty !body_ref.bstmts with
            | {skind=If(_,tb,fb,_)} as head:: _ ->
                begin
                  match skipEmpty tb.bstmts, skipEmpty fb.bstmts with
                    | _, {skind=Break _}:: _
                    | _, {skind=Goto _} :: _
                    | {skind=Goto _} :: _, _
                    | {skind=Break _} :: _, _ ->
                        !body_ref.bstmts<-head::(stmt_varset::(List.tl !body_ref.bstmts))

                    | _ ->
                        raise Not_found
                end
            | _ -> raise Not_found

        with
          | Not_found ->
              !body_ref.bstmts<-stmt_varset::!body_ref.bstmts
      end;


(*    2) The associated init variable is set to 1 before the loop *)
      let new_loop = mkStmt stmt.skind in
      new_loop.sid<-(Cil.Sid.next ());
      let stmt_varset =
        Cil.mkStmtOneInstr (Set((Var(vi_init),NoOffset),
                                Aorai_utils.mk_int_exp 1, Location.unknown))
      in
      stmt_varset.sid <- Cil.Sid.next ();
      stmt_varset.ghost <- true;
      let block = mkBlock [stmt_varset;new_loop] in
      stmt.skind<-Block(block);




(*    3) Generation of the loop invariant *)
      let mk_imply operator predicate =
        (Logic_const.unamed
           (Pimplies
              (Logic_const.unamed (Prel(operator,
                                        Aorai_utils.mk_term_from_vi vi_init,
                                        Aorai_utils.zero_term())),
               Logic_const.unamed predicate)))
      in
(* The loop invariant is :
     (Global invariant)  // all never reached state /crossed transition are set to zero
   & (Pre2)              // internal pre-condition
   & (Init => Pre1)      // external pre-condition
   & (not Init => Post2) // internal post-condition
   (init : fresh variable which indicates if the iteration is the first one).
*)

      let global_loop_inv = Aorai_utils.get_global_loop_inv (ref stmt) in
      condition_to_invariant global_loop_inv (ref new_loop);

      let pre2 = Aorai_utils.get_restricted_int_pre_bc (ref stmt) in
      if pre2<>Cil_types.Ptrue then
        predicate_to_invariant (ref new_loop) (Logic_const.unamed pre2);

      let pre1 = Aorai_utils.get_restricted_ext_pre_bc (ref stmt) in
      if pre1<>Cil_types.Ptrue then
        predicate_to_invariant (ref new_loop) (mk_imply Rneq pre1);

      let post2 = Aorai_utils.get_restricted_int_post_bc (ref stmt) in
      if post2<>Cil_types.Ptrue then
        predicate_to_invariant (ref new_loop) (mk_imply Req post2);



(*    4) Keeping in mind to preserve old annotations after visitor end *)
      Hashtbl.add post_treatment_loops (ref stmt) (ref new_loop);


(*    5) Updated stmt is returned *)
          stmt
    in
    if treatloops then
      match stmt.skind with
        | Loop (_,block,_,_,_) ->
            ChangeDoChildrenPost(stmt, treat_loop (ref block))

        | _ -> DoChildren
    else
      DoChildren