let compute_using_prototype_for_state state kf =
  match kf.fundec with
  | Definition _ -> assert false
  | Declaration (_, varinfo, _,_) ->
      let behaviors = !Value.valid_behaviors kf state in
      let assigns = Ast_info.merge_assigns behaviors in
      let return_deps,deps =
        match assigns with
          [] ->
            Lmap_bitwise.From_Model.LOffset.empty,
            Lmap_bitwise.From_Model.empty
        | assigns ->
            let (rt_typ,_,_,_) = splitFunctionTypeVI varinfo in
            let input_zone ins =
              match ins with
                  [] -> Zone.top
                | l ->
                    (try
                       List.fold_left
                         (fun acc loc ->
                           Zone.join acc
                             (match loc with
                               Location loc ->
                                 Locations.valid_enumerate_bits
                                   (!Properties.Interp.loc_to_loc
                                       ~result:None
                                       state
                                       loc.it_content)
                             | Nothing -> Zone.bottom))
                         Zone.bottom
                         l
                     with Invalid_argument "not an lvalue" ->
                       From_parameters.result  ~once:true ~current:true
                         "Unable to extract precise FROM in %a"
                         Kernel_function.pretty_name kf;
                       Zone.top)
            in
            let treat_assign acc (out, ins) =
              try
                let output_loc =
                  match out with
                    Location out ->
                      !Properties.Interp.loc_to_loc ~result:None state
                        out.it_content
                  | Nothing -> assert false
                in
                let output_zone = Locations.valid_enumerate_bits output_loc in
                Lmap_bitwise.From_Model.add_binding ~exact:true
                  acc output_zone (input_zone ins)
              with Invalid_argument "not an lvalue" ->
                 From_parameters.result ~once:true ~current:true "Unable to extract assigns in %a"
                  Kernel_function.pretty_name kf;
                acc

            in
            let treat_ret_assign acc (out,ins) =
              try
                let coffs = match out with
                    Location out ->
                      !Properties.Interp.loc_to_offset ~result:None
                        out.it_content
                  | Nothing -> []
                in
                List.fold_left
                  (fun acc coff ->
                     let (base,width) = bitsOffset rt_typ coff in
                     Lmap_bitwise.From_Model.LOffset.add_iset
                       ~exact:true
                       (Abstract_value.Int_Intervals.from_ival_size
                          (Ival.of_int base)
                          (Int_Base.inject (Int.of_int width)))
                       (input_zone ins) acc)
                  acc coffs
              with Invalid_argument "not an lvalue" | SizeOfError _ ->
                From_parameters.result  ~once:true ~current:true
                  "Unable to extract a proper offset. Using FROM for the whole \\result";
                Lmap_bitwise.From_Model.LOffset.add_iset ~exact:false
                  (Abstract_value.Int_Intervals.from_ival_size
                     (Ival.of_int 0) (Bit_utils.sizeof rt_typ))
                  (input_zone ins) acc
            in
            let return_assigns, other_assigns =
              List.fold_left
                (fun (ra,oa as res) (x,_ as a) ->
                   match x with
                       Location loc ->
                         if Logic_utils.is_result loc.it_content
                         then a::ra,oa else ra,a::oa
                     | Nothing -> res
                )
                ([],[]) assigns
            in
            (List.fold_left treat_ret_assign
               Lmap_bitwise.From_Model.LOffset.empty return_assigns,
             List.fold_left
               treat_assign
               Lmap_bitwise.From_Model.empty
               other_assigns)
      in
      { deps_return = return_deps; Function_Froms.deps_table = deps }