let state_refresh (sender : string) (message : string) (reciever : string) (message_receiver : string) : unit =
   local_variable_change:=[];
   List.iter
   (fun (name,id,statesL,actionsL) ->
           let sender_state = ref "" in 
            if(reciever=(get_name_in_session name id))
        then(   
                let new_statesL = ref [] in
                List.iter
                (fun (state,exec) ->
                List.iter
                 (fun (initial,_,final) ->  
                        sender_state := "";                          
                        if( (!exec)=false && 
                                message_receiver=(findIknows initial) && 
                                ((match_state reciever state reciever (findState initial) ) || state=""))
                        then(
                                if(state<>"" && state<>(findState initial)) 
                                then (         ignore(assign_var_of_state reciever state reciever (findState initial));
                                         clear_message_story ()
                                         ) ;
                                if  (match_message_with_one_state_of_agent sender sender_state message reciever (findState initial))
                                then(
                                (*prerr_string ("^reciever^"^message^"^state^"^"^(findState initial)^"^(findState final)^");*)
                                if((findIknows initial)<>""then (
                                                        ignore(assign_var sender (!sender_state) message reciever (findState initial) (findIknows initial));
                                                        );
                                if(!intruder_mode && "(Intruder_, 0)"=reciever) then operations_affectation_treatment reciever state;
                                clear_message_story ();
                                local_variable_change:=[];
                                let old_exec = (!exec) in
                                if((findIknows final)<>"" && not(List.mem (findState final,ref false) (!statesL))) 
                                then (if( (not(List.mem (findState final,ref true) (!new_statesL)))
                                  (* &&  (not(List.mem (findState final,ref false) (!new_statesL))) *) )
                                 then new_statesL:= (findState final,ref true)::(!new_statesL))
                                else (if( (not(List.mem (findState final,ref false) (!new_statesL))) 
                                 (*&& (not(List.mem (findState final,ref true) (!new_statesL))) *) )
                                then new_statesL:= (findState final,ref false)::(!new_statesL));                
                                if(List.mem message (get_rcv_stack reciever state) && (findIknows initial)<>""
                                then  (if(not(remove_rcv_stack reciever state message) && (!new_statesL)=[])
                                        then statesL:=(remove (state,exec) (!statesL))                                        
                                        )
                                else if (not(old_exec) && (rcv_stack_is_empty reciever state)) then(
                                        List.iter         
                                        (fun (initial,_,final) -> if((match_state reciever state reciever (findState initial)) && message<>(findIknows initial) && ""<>(findIknows initial))
                                                                 then         add_in_rcv_stack reciever state (findIknows initial)
                                                ) actionsL
                                        );
                                )
                                else if(state<>"" && state<>(findState initial)) then (previous_message_story () ; remove_local_variable_change());
                        (*        List.iter
                                (fun (s,e) -> 
                                        if(not(List.mem (s,ref true) (!new_statesL)) && not(List.mem (s,ref false) (!new_statesL)) && !e=false) then new_statesL:=((s,e)::(!new_statesL));
                                )
                                (!statesL);*)

                        );
                 ) actionsL;
                ) (!statesL);
                  remove_all_message_stack reciever;
                if ((!new_statesL)<>[]) then statesL := (!new_statesL);
        )
     )(!automate);
        
             List.iter
        (fun (name,id,statesL,actionsL) ->
                if(sender=(get_name_in_session name id))
                then(
                        let lock = ref true in
                        let new_statesL = ref [] in
                        List.iter
                        (fun (state,exec) -> 
                        if(operations_test_treatment_right sender state)
                        then(
                                if ( (!exec) && (message_stack_is_empty sender state))
                                 then (  
                                        List.iter
                                                (fun (initial,_,final) -> if(state=(findState final) &&  ""<>(findIknows final) )
                                                                then (        exec:=false;
                                                                        if((!lock) && ""=(findIknows initial) && message=(findIknows final)) 
                                                                        then (lock:=false(*new_statesL:=[] ;*)  statesL:=[] ; remove_all_message_stack sender );
                                                                        );
                                        )
                                        actionsL;
                                
                                        List.iter
                                        (fun (initial,_,final) -> if( ((!lock) || (findIknows initial)=""&& state=(findState final))
                                                                then (        if(message<>(findIknows final)) 
                                                                        then add_in_message_stack sender state (findIknows final);
                                                                        if((!lock) && (findIknows initial)="")
                                                                        then         (if(not(List.mem (findState final,ref true) (!new_statesL)))
                                                                                then new_statesL:= (findState final,ref true)::(!new_statesL))
                                                                        else         (if(not(List.mem (findState final,ref false) (!new_statesL)))
                                                                                then new_statesL:= (findState final,ref false)::(!new_statesL));
                                                                )
                                        )
                                        actionsL;                        
                                        )
                                else if(not(!exec) && (*(!new_statesL)=[] &&*) (message_stack_is_empty sender state)) 
                                        then        statesL:=(remove (state,exec) (!statesL))
                                else if(not(message_stack_is_empty sender state)) 
                                        then  (if(not(remove_message_stack sender state message) (* &&  (!new_statesL)=[] && (!exec) *))
                                                then statesL:=(remove (state,exec) (!statesL))                                        
                                        );                        
                                 ) 
                        )
                        (!statesL);

                        remove_all_rcv_stack sender;

                        if ((!new_statesL)<>[]) then statesL := (remove_double ((!new_statesL)@(!statesL)));
                        (*List.iter
                        (fun (s,e) ->
                                if(!e=true && (List.mem (s, ref false) (!statesL)) ) then statesL := remove (s,e) (!statesL)
                        )
                        (!new_statesL) *)

                        );
                        
                if((*sender=(get_name_in_session name id) || *)reciever=(get_name_in_session name id))
                then(
                        let succ_state = ref ([] : (string * bool ref ) list) in
                        List.iter
                        (fun (state,exec) -> 
                        List.iter
                        (fun (initial,_,final) -> 
                                succ_state:= (if (((!exec)=false && (List.mem (findIknows final)(get_message_stack reciever state))))
                                then []
                                else (let rec aux l res=
                                        match l with [] -> List.rev res;
                                                |((initial1,_,final1)::ls) ->
                                                        if ((match_state reciever state reciever (findState initial1))
                                                                && (findIknows initial1)=""                                                        
                                                                && not(List.mem ((findState final1),ref false) (!statesL)) 
                                                                && not(List.mem ((findState final1),ref false) (!succ_state)) 
                                                                && not(List.mem ((findState final1),ref false) res))
                                                        then         (aux ls (((findState final1),ref true)::res))
                                                        else aux ls res ;
                                        in
                                        aux actionsL [] ))@(!succ_state);
                        )actionsL;
                        ) (!statesL);
                        if ((!succ_state)<>[]) then statesL := (remove_double ((!statesL)@(!succ_state)));
                );
                        
                                
                ) (!automate);
   
        (*Hashtbl.iter 
        (fun  (name_in_session,state_t,type_of_message) m -> 
                if((type_of_message=") && (name_in_session=sender) ) 
                then refresh_var_of_state name_in_session state_t (!tag_number))
        message_stack; *)

           local_variable_change:=[];
        if(!intruder_mode && ("(Intruder_, 0)"=reciever || "(Intruder_, 0)"=sender)) then update_intruder_knowledge ()