%-----------------------------------------------------------------------------% % Copyright (C) 1994-2004 The University of Melbourne. % This file may only be copied under the terms of the GNU General % Public License - see the file COPYING in the Mercury distribution. %-----------------------------------------------------------------------------% % % Switch detection - when a disjunction contains disjuncts that unify the % same input variable with different function symbols, replace (part of) % the disjunction with a switch. % % Main author: fjh. % %-----------------------------------------------------------------------------% :- module check_hlds__switch_detection. :- interface. :- import_module hlds__hlds_goal. :- import_module hlds__hlds_module. :- import_module hlds__hlds_pred. :- import_module parse_tree__prog_data. :- import_module bool, io, list. :- pred detect_switches(module_info::in, module_info::out, io__state::di, io__state::uo) is det. :- pred detect_switches_in_proc(proc_id::in, pred_id::in, module_info::in, module_info::out) is det. % find_bind_var(Var, ProcessUnify, Goal0, Goals, Subst0, Subst, % Result0, Result, FoundDeconstruct): % Used by both switch_detection and cse_detection. % Searches through `Goal0' looking for the first deconstruction % unification with `Var' or an alias of `Var'. % If a deconstruction unification of the variable is found, % `ProcessUnify' is called to handle it and searching is stopped. % If not, `Result' is set to `Result0'. :- pred find_bind_var(prog_var::in, process_unify(Result, Info)::in(process_unify), hlds_goal::in, hlds_goal::out, Result::in, Result::out, Info::in, Info::out, bool::out) is det. :- type process_unify(Result, Info) == pred(prog_var, hlds_goal, list(hlds_goal), Result, Result, Info, Info). :- inst process_unify = (pred(in, in, out, in, out, in, out) is det). %-----------------------------------------------------------------------------% %-----------------------------------------------------------------------------% :- implementation. :- import_module check_hlds__det_util. :- import_module check_hlds__inst_match. :- import_module check_hlds__type_util. :- import_module hlds__hlds_data. :- import_module hlds__hlds_goal. :- import_module hlds__instmap. :- import_module hlds__passes_aux. :- import_module parse_tree__prog_data. :- import_module parse_tree__prog_mode. :- import_module term. :- import_module char, int, assoc_list, map, set, std_util, require. %-----------------------------------------------------------------------------% % Traverse the module structure, calling `detect_switches_in_goal' % for each procedure body. detect_switches(!ModuleInfo, !IO) :- module_info_predids(!.ModuleInfo, PredIds), detect_switches_in_preds(PredIds, !ModuleInfo, !IO). :- pred detect_switches_in_preds(list(pred_id)::in, module_info::in, module_info::out, io::di, io::uo) is det. detect_switches_in_preds([], !ModuleInfo, !IO). detect_switches_in_preds([PredId | PredIds], !ModuleInfo, !IO) :- module_info_preds(!.ModuleInfo, PredTable), map__lookup(PredTable, PredId, PredInfo), detect_switches_in_pred(PredId, PredInfo, !ModuleInfo, !IO), detect_switches_in_preds(PredIds, !ModuleInfo, !IO). :- pred detect_switches_in_pred(pred_id::in, pred_info::in, module_info::in, module_info::out, io::di, io::uo) is det. detect_switches_in_pred(PredId, PredInfo0, !ModuleInfo, !IO) :- ProcIds = pred_info_non_imported_procids(PredInfo0), ( ProcIds \= [] -> write_pred_progress_message("% Detecting switches in ", PredId, !.ModuleInfo, !IO) ; true ), detect_switches_in_procs(ProcIds, PredId, !ModuleInfo). :- pred detect_switches_in_procs(list(proc_id)::in, pred_id::in, module_info::in, module_info::out) is det. detect_switches_in_procs([], _PredId, !ModuleInfo). detect_switches_in_procs([ProcId | ProcIds], PredId, !ModuleInfo) :- detect_switches_in_proc(ProcId, PredId, !ModuleInfo), detect_switches_in_procs(ProcIds, PredId, !ModuleInfo). detect_switches_in_proc(ProcId, PredId, !ModuleInfo) :- module_info_preds(!.ModuleInfo, PredTable0), map__lookup(PredTable0, PredId, PredInfo0), pred_info_procedures(PredInfo0, ProcTable0), map__lookup(ProcTable0, ProcId, ProcInfo0), % To process each ProcInfo, we get the goal, % initialize the instmap based on the modes of the head vars, % and pass these to `detect_switches_in_goal'. proc_info_goal(ProcInfo0, Goal0), proc_info_vartypes(ProcInfo0, VarTypes), proc_info_get_initial_instmap(ProcInfo0, !.ModuleInfo, InstMap0), detect_switches_in_goal(!.ModuleInfo, VarTypes, InstMap0, Goal0, Goal), proc_info_set_goal(Goal, ProcInfo0, ProcInfo), map__det_update(ProcTable0, ProcId, ProcInfo, ProcTable), pred_info_set_procedures(ProcTable, PredInfo0, PredInfo), map__det_update(PredTable0, PredId, PredInfo, PredTable), module_info_set_preds(PredTable, !ModuleInfo). %-----------------------------------------------------------------------------% % Given a goal, and the instmap on entry to that goal, % replace disjunctions with switches whereever possible. :- pred detect_switches_in_goal(module_info::in, vartypes::in, instmap::in, hlds_goal::in, hlds_goal::out) is det. detect_switches_in_goal(ModuleInfo, VarTypes, InstMap0, !Goal) :- detect_switches_in_goal_1(ModuleInfo, VarTypes, InstMap0, _InstMap, !Goal). % This version is the same as the above except that it returns % the resulting instmap on exit from the goal, which is % computed by applying the instmap delta specified in the % goal's goalinfo. :- pred detect_switches_in_goal_1(module_info::in, vartypes::in, instmap::in, instmap::out, hlds_goal::in, hlds_goal::out) is det. detect_switches_in_goal_1(ModuleInfo, VarTypes, InstMap0, InstMap, Goal0 - GoalInfo, Goal - GoalInfo) :- detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, GoalInfo, Goal0, Goal), update_instmap(Goal0 - GoalInfo, InstMap0, InstMap). % Here we process each of the different sorts of goals. :- pred detect_switches_in_goal_2(module_info::in, vartypes::in, instmap::in, hlds_goal_info::in, hlds_goal_expr::in, hlds_goal_expr::out) is det. detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, GoalInfo, disj(Goals0), Goal) :- ( Goals0 = [] -> Goal = disj([]) ; goal_info_get_nonlocals(GoalInfo, NonLocals), set__to_sorted_list(NonLocals, NonLocalsList), detect_switches_in_disj(NonLocalsList, Goals0, GoalInfo, InstMap0, VarTypes, NonLocalsList, ModuleInfo, [], Goal) ). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, conj(Goals0), conj(Goals)) :- detect_switches_in_conj(ModuleInfo, VarTypes, InstMap0, Goals0, Goals). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, par_conj(Goals0), par_conj(Goals)) :- detect_switches_in_par_conj(ModuleInfo, VarTypes, InstMap0, Goals0, Goals). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, not(Goal0), not(Goal)) :- detect_switches_in_goal(ModuleInfo, VarTypes, InstMap0, Goal0, Goal). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, if_then_else(Vars, Cond0, Then0, Else0), if_then_else(Vars, Cond, Then, Else)) :- detect_switches_in_goal_1(ModuleInfo, VarTypes, InstMap0, InstMap1, Cond0, Cond), detect_switches_in_goal(ModuleInfo, VarTypes, InstMap1, Then0, Then), detect_switches_in_goal(ModuleInfo, VarTypes, InstMap0, Else0, Else). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, some(Vars, CanRemove, Goal0), some(Vars, CanRemove, Goal)) :- detect_switches_in_goal(ModuleInfo, VarTypes, InstMap0, Goal0, Goal). detect_switches_in_goal_2(_, _, _, _, Goal @ generic_call(_, _, _, _), Goal). detect_switches_in_goal_2(_, _, _, _, Goal @ call(_, _, _, _, _, _), Goal). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap0, _GoalInfo, Goal0, Goal) :- Goal0 = unify(_, RHS0, _, _, _), ( RHS0 = lambda_goal(_, _, _, _, _, Vars, Modes, _, LambdaGoal0) -> % we need to insert the initial insts for the lambda % variables in the instmap before processing the lambda goal instmap__pre_lambda_update(ModuleInfo, Vars, Modes, InstMap0, InstMap1), detect_switches_in_goal(ModuleInfo, VarTypes, InstMap1, LambdaGoal0, LambdaGoal), RHS = RHS0 ^ rhs_lambda_goal := LambdaGoal, Goal = Goal0 ^ unify_rhs := RHS ; Goal = Goal0 ). detect_switches_in_goal_2(ModuleInfo, VarTypes, InstMap, _, switch(Var, CanFail, Cases0), switch(Var, CanFail, Cases)) :- detect_switches_in_cases(ModuleInfo, VarTypes, InstMap, Cases0, Cases). detect_switches_in_goal_2(_, _, _, _, Goal @ foreign_proc(_, _, _, _, _, _), Goal). detect_switches_in_goal_2(_, _, _, _, shorthand(_), _) :- % these should have been expanded out by now error("detect_switches_in_goal_2: unexpected shorthand"). %-----------------------------------------------------------------------------% % This is the interesting bit - we've found a non-empty % disjunction, and we've got a list of the non-local variables % of that disjunction. Now for each non-local variable, we % check whether there is a partition of the disjuncts such that % each group of disjunctions can only succeed if the variable % is bound to a different functor. :- type cases == map(cons_id, list(hlds_goal)). :- type sorted_case_list == list(case). % the sorted_case_list should always be sorted on cons_id - % `delete_unreachable_cases' relies on this. :- type again ---> again(prog_var, list(hlds_goal), sorted_case_list). :- pred detect_switches_in_disj(list(prog_var)::in, list(hlds_goal)::in, hlds_goal_info::in, instmap::in, vartypes::in, list(prog_var)::in, module_info::in, list(again)::in, hlds_goal_expr::out) is det. detect_switches_in_disj([Var | Vars], Goals0, GoalInfo, InstMap, VarTypes, AllVars, ModuleInfo, Again0, Goal) :- % can we do at least a partial switch on this variable? ( instmap__lookup_var(InstMap, Var, VarInst0), inst_is_bound(ModuleInfo, VarInst0), partition_disj(Goals0, Var, GoalInfo, Left, CasesList) -> % % A switch needs to have at least two cases. % % But, if there is a complete one-case switch % for a goal, we must leave it as a disjunction % rather than doing an incomplete switch on a % different variable, because otherwise we might % get determinism analysis wrong. (The complete % one-case switch may be decomposable into other % complete sub-switches on the functor's arguments) % ( % are there any disjuncts that are not part of the % switch? Left = [] -> ( CasesList = [_, _ | _] -> cases_to_switch(CasesList, Var, VarTypes, GoalInfo, InstMap, ModuleInfo, Goal) ; detect_sub_switches_in_disj(ModuleInfo, VarTypes, InstMap, Goals0, Goals), Goal = disj(Goals) ) ; % insert this switch into the list of incomplete % switches only if it has at least two cases % ( CasesList = [_, _ | _] -> Again1 = [again(Var, Left, CasesList) | Again0] ; Again1 = Again0 ), % try to find a switch detect_switches_in_disj(Vars, Goals0, GoalInfo, InstMap, VarTypes, AllVars, ModuleInfo, Again1, Goal) ) ; detect_switches_in_disj(Vars, Goals0, GoalInfo, InstMap, VarTypes, AllVars, ModuleInfo, Again0, Goal) ). detect_switches_in_disj([], Goals0, GoalInfo, InstMap, VarTypes, AllVars, ModuleInfo, AgainList0, disj(Goals)) :- ( AgainList0 = [], detect_sub_switches_in_disj(ModuleInfo, VarTypes, InstMap, Goals0, Goals) ; AgainList0 = [Again | AgainList1], select_best_switch(AgainList1, Again, BestAgain), BestAgain = again(Var, Left0, CasesList), cases_to_switch(CasesList, Var, VarTypes, GoalInfo, InstMap, ModuleInfo, SwitchGoal), detect_switches_in_disj(AllVars, Left0, GoalInfo, InstMap, VarTypes, AllVars, ModuleInfo, [], Left), goal_to_disj_list(Left - GoalInfo, LeftList), Goals = [SwitchGoal - GoalInfo | LeftList] ). :- pred select_best_switch(list(again)::in, again::in, again::out) is det. select_best_switch([], BestAgain, BestAgain). select_best_switch([Again | AgainList], BestAgain0, BestAgain) :- ( Again = again(_, _, CasesList), BestAgain0 = again(_, _, BestCasesList), list__length(CasesList, Length), list__length(BestCasesList, BestLength), Length < BestLength -> BestAgain1 = BestAgain0 ; BestAgain1 = Again ), select_best_switch(AgainList, BestAgain1, BestAgain). :- pred detect_sub_switches_in_disj(module_info::in, vartypes::in, instmap::in, list(hlds_goal)::in, list(hlds_goal)::out) is det. detect_sub_switches_in_disj(_ModuleInfo, _VarTypes, _InstMap, [], []). detect_sub_switches_in_disj(ModuleInfo, VarTypes, InstMap, [Goal0 | Goals0], [Goal | Goals]) :- detect_switches_in_goal(ModuleInfo, VarTypes, InstMap, Goal0, Goal), detect_sub_switches_in_disj(ModuleInfo, VarTypes, InstMap, Goals0, Goals). :- pred detect_switches_in_cases(module_info::in, vartypes::in, instmap::in, list(case)::in, list(case)::out) is det. detect_switches_in_cases(_ModuleInfo, _VarTypes, _InstMap, [], []). detect_switches_in_cases(ModuleInfo, VarTypes, InstMap, [Case0 | Cases0], [Case | Cases]) :- Case0 = case(Functor, Goal0), detect_switches_in_goal(ModuleInfo, VarTypes, InstMap, Goal0, Goal), Case = case(Functor, Goal), detect_switches_in_cases(ModuleInfo, VarTypes, InstMap, Cases0, Cases). :- pred detect_switches_in_par_conj(module_info::in, vartypes::in, instmap::in, list(hlds_goal)::in, list(hlds_goal)::out) is det. detect_switches_in_par_conj(_ModuleInfo, _VarTypes, _InstMap, [], []). detect_switches_in_par_conj(ModuleInfo, VarTypes, InstMap, [Goal0 | Goals0], [Goal | Goals]) :- detect_switches_in_goal(ModuleInfo, VarTypes, InstMap, Goal0, Goal), detect_switches_in_par_conj(ModuleInfo, VarTypes, InstMap, Goals0, Goals). :- pred detect_switches_in_conj(module_info::in, vartypes::in, instmap::in, list(hlds_goal)::in, list(hlds_goal)::out) is det. detect_switches_in_conj(_ModuleInfo, _VarTypes, _InstMap, [], []). detect_switches_in_conj(ModuleInfo, VarTypes, InstMap0, [Goal0 | Goals0], [Goal | Goals]) :- detect_switches_in_goal_1(ModuleInfo, VarTypes, InstMap0, InstMap1, Goal0, Goal), detect_switches_in_conj(ModuleInfo, VarTypes, InstMap1, Goals0, Goals). %-----------------------------------------------------------------------------% % partition_disj(Goals, Var, GoalInfo, VarTypes, ModuleInfo, % Left, Cases): % Attempts to partition the disjunction `Goals' into a switch on `Var'. % If at least partially successful, returns the resulting `Cases', with % any disjunction goals not fitting into the switch in Left. % Given the list of goals in a disjunction, and an input variable % to switch on, we attempt to partition the goals into a switch. % For each constructor id, we record the list of disjuncts % which unify the variable with that constructor. % We partition the goals by abstractly interpreting the unifications % at the start of each disjunction, to build up a substitution. :- pred partition_disj(list(hlds_goal)::in, prog_var::in, hlds_goal_info::in, list(hlds_goal)::out, sorted_case_list::out) is semidet. partition_disj(Goals0, Var, GoalInfo, Left, CasesList) :- map__init(Cases0), partition_disj_trial(Goals0, Var, [], Left, Cases0, Cases), map__to_assoc_list(Cases, CasesAssocList), CasesAssocList \= [], % there must be at least one case fix_case_list(CasesAssocList, GoalInfo, CasesList). :- pred partition_disj_trial(list(hlds_goal)::in, prog_var::in, list(hlds_goal)::in, list(hlds_goal)::out, cases::in, cases::out) is det. partition_disj_trial([], _Var, !Left, !Cases). partition_disj_trial([Goal0 | Goals], Var, !Left, !Cases) :- find_bind_var(Var, find_bind_var_for_switch_in_deconstruct, Goal0, Goal, no, MaybeFunctor, unit, _, _), ( MaybeFunctor = yes(Functor), ( map__search(!.Cases, Functor, DisjList0) -> DisjList = [Goal | DisjList0], map__det_update(!.Cases, Functor, DisjList, !:Cases) ; DisjList = [Goal], map__det_insert(!.Cases, Functor, DisjList, !:Cases) ) ; MaybeFunctor = no, !:Left = [Goal0 | !.Left] ), partition_disj_trial(Goals, Var, !Left, !Cases). :- pred find_bind_var_for_switch_in_deconstruct(prog_var::in, hlds_goal::in, list(hlds_goal)::out, maybe(cons_id)::in, maybe(cons_id)::out, unit::in, unit::out) is det. find_bind_var_for_switch_in_deconstruct(_UnifyVar, Goal0, Goals, _Result0, Result, _, unit) :- ( Goal0 = GoalExpr0 - GoalInfo, UnifyInfo0 = GoalExpr0 ^ unify_kind, UnifyInfo0 = deconstruct(_, Functor, _, _, _, _) -> Result = yes(Functor), % The deconstruction unification now becomes % deterministic, since the test will get % carried out in the switch. UnifyInfo = UnifyInfo0 ^ deconstruct_can_fail := cannot_fail, GoalExpr = GoalExpr0 ^ unify_kind := UnifyInfo, Goal = GoalExpr - GoalInfo, Goals = [Goal] ; error("find_bind_var_for_switch_in_deconstruct") ). %-----------------------------------------------------------------------------% find_bind_var(Var, ProcessUnify, Goal0, Goal, Result0, Result, Info0, Info, FoundDeconstruct) :- map__init(Substitution), find_bind_var(Var, ProcessUnify, Goal0, Goal, Substitution, _, Result0, Result, Info0, Info, DeconstructSearch), ( DeconstructSearch = before_deconstruct, FoundDeconstruct = no ; DeconstructSearch = found_deconstruct, FoundDeconstruct = yes ; DeconstructSearch = given_up_search, FoundDeconstruct = no ). :- type deconstruct_search ---> before_deconstruct ; found_deconstruct ; given_up_search. :- pred find_bind_var(prog_var::in, process_unify(Result, Info)::in(process_unify), hlds_goal::in, hlds_goal::out, prog_substitution::in, prog_substitution::out, Result::in, Result::out, Info::in, Info::out, deconstruct_search::out) is det. find_bind_var(Var, ProcessUnify, Goal0 - GoalInfo, Goal, Substitution0, Substitution, Result0, Result, Info0, Info, FoundDeconstruct) :- ( Goal0 = some(Vars, CanRemove, SubGoal0) -> find_bind_var(Var, ProcessUnify, SubGoal0, SubGoal, Substitution0, Substitution, Result0, Result, Info0, Info, FoundDeconstruct), Goal = some(Vars, CanRemove, SubGoal) - GoalInfo ; Goal0 = conj(SubGoals0) -> conj_find_bind_var(Var, ProcessUnify, SubGoals0, SubGoals, Substitution0, Substitution, Result0, Result, Info0, Info, FoundDeconstruct), Goal = conj(SubGoals) - GoalInfo ; Goal0 = unify(A, B, _, UnifyInfo0, _) -> ( % check whether the unification is a deconstruction % unification on Var or a variable aliased to Var UnifyInfo0 = deconstruct(UnifyVar, _, _, _, _, _), term__apply_rec_substitution( term__variable(Var), Substitution0, term__variable(Var1)), term__apply_rec_substitution( term__variable(UnifyVar), Substitution0, term__variable(UnifyVar1)), Var1 = UnifyVar1 -> call(ProcessUnify, Var, Goal0 - GoalInfo, Goals, Result0, Result, Info0, Info), conj_list_to_goal(Goals, GoalInfo, Goal), FoundDeconstruct = found_deconstruct, Substitution = Substitution0 ; Goal = Goal0 - GoalInfo, FoundDeconstruct = before_deconstruct, % otherwise abstractly interpret the unification Result = Result0, Info = Info0, ( interpret_unify(A, B, Substitution0, Substitution1) -> Substitution = Substitution1 ; % the unification must fail - just ignore it Substitution = Substitution0 ) ) ; Goal = Goal0 - GoalInfo, Substitution = Substitution0, Result = Result0, Info = Info0, FoundDeconstruct = given_up_search ). :- pred conj_find_bind_var(prog_var::in, process_unify(Result, Info)::in(process_unify), list(hlds_goal)::in, list(hlds_goal)::out, prog_substitution::in, prog_substitution::out, Result::in, Result::out, Info::in, Info::out, deconstruct_search::out) is det. conj_find_bind_var(_Var, _, [], [], !Substitution, !Result, !Info, before_deconstruct). conj_find_bind_var(Var, ProcessUnify, [Goal0 | Goals0], [Goal | Goals], !Substitution, !Result, !Info, FoundDeconstruct) :- find_bind_var(Var, ProcessUnify, Goal0, Goal, !Substitution, !Result, !Info, FoundDeconstruct1), ( FoundDeconstruct1 = before_deconstruct -> conj_find_bind_var(Var, ProcessUnify, Goals0, Goals, !Substitution, !Result, !Info, FoundDeconstruct) ; FoundDeconstruct = FoundDeconstruct1, Goals = Goals0 ). %-----------------------------------------------------------------------------% :- pred cases_to_switch(sorted_case_list::in, prog_var::in, vartypes::in, hlds_goal_info::in, instmap::in, module_info::in, hlds_goal_expr::out) is det. cases_to_switch(CasesList, Var, VarTypes, _GoalInfo, InstMap, ModuleInfo, Goal) :- instmap__lookup_var(InstMap, Var, VarInst), ( inst_is_bound_to_functors(ModuleInfo, VarInst, Functors) -> functors_to_cons_ids(Functors, ConsIds0), list__sort(ConsIds0, ConsIds), delete_unreachable_cases(CasesList, ConsIds, CasesList1), ( list__same_length(Functors, CasesList1) -> CanFail = cannot_fail ; CanFail = can_fail ) ; map__lookup(VarTypes, Var, Type), CasesList1 = CasesList, ( switch_covers_all_cases(ModuleInfo, Type, CasesList1) -> CanFail = cannot_fail ; CanFail = can_fail ) ), detect_switches_in_cases(ModuleInfo, VarTypes, InstMap, CasesList1, Cases), % We turn switches with no arms into fail, since this avoids having % the code generator flush the control variable of the switch. % We can't easily eliminate switches with one arm, since the % code of the arm will have the unification between the variable % and the function symbol as det. The gain would be minimal to % nonexistent anyway. ( Cases = [], Goal = disj([]) ; Cases = [_ | _], Goal = switch(Var, CanFail, Cases) ). % check whether a switch handles all the possible % constants/functors for the type :- pred switch_covers_all_cases(module_info::in, (type)::in, sorted_case_list::in) is semidet. switch_covers_all_cases(ModuleInfo, Type, CasesList) :- type_util__switch_type_num_functors(ModuleInfo, Type, NumFunctors), list__length(CasesList, NumCases), NumCases = NumFunctors. % convert the assoc_list(cons_id, list(hlds_goal) back into % a plain list(case). :- pred fix_case_list(assoc_list(cons_id, list(hlds_goal))::in, hlds_goal_info::in, list(case)::out) is det. fix_case_list([], _, []). fix_case_list([Functor - DisjList0 | Cases0], GoalInfo, [case(Functor, Goal) | Cases]) :- % We need to put the list back the right way around. list__reverse(DisjList0, DisjList), disj_list_to_goal(DisjList, GoalInfo, Goal), fix_case_list(Cases0, GoalInfo, Cases). %-----------------------------------------------------------------------------%