a d @s6ddlZddlZddlZddlmZddlmZmZddlm Z ddl m Z ddl m Z mZddlmZmZdd lmZd d lmZmZmZmZd d lmZmZmZdd lmZmZd dl m!Z!m"Z"d dl#m$Z$d dl%m&Z&m'Z'd dl(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl(m:Z:m;Z;mm?Z?m@Z@mAZAddlBmCZCmDZDmEZEd dlFmGZGmHZHddlImJZJddlKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTgdZUeVeWejXdgZYejZj[jj\j]ejZj[jj\j]dZ^ejZj[jj_j]ejZj[jj_j]dZ`eeMeaejbjcfeXdddZdeOeTeQeOejeeXfdd d!Zfe eeeDeCeXd"d#d$ZgeeeDeXd%d&d'ZheeMeaejbjcfd(d)d*ZieOeeOeNeeeCeXd+d,d-ZjeeMeaejbjcfeGeeOeCeQeeQeLd.feGeOeCfd/d0d1ZkejbjceMeeRejbjcfdd2d3d4ZleePead5d6d7Zmee ejbjceMeaejbjcfeed8d9d:ZneeeeCeMeaejbjcfeMeeXfePedd;dd?d@ZqeeMeaejbjcfeOeSejeepfdAdBdCZreeeMeaejbjcfeCeOeSejeepfdDdEdFZseeeMeaejbjcfeCeXdDdGdHZteSeeLfe eejbjceMeaejbjcfeeOeeGeCe dI dJdKZueeejbjceMeaejbjcfeeOeeGeCddL dMdNZveeLejbjceMeaejbjcfeeXeCddOdPdQZweejbjceMeaejbjcfeeMeae&feLeOeeXeOedR dSdTZxeeNeVeMeaefejbjceMeaejbjcfeddUdVdWZyeeSejeepfeMeae&fddXdYdZZzeeMeae&fdd[d\d]Z{eejbjceMeaejbjcfeXd^d_d`Z|eejbjceMeaejbjcfdadbdcZ}eeeMeaejbjcfeGdddedfZ~eeMeae&feMeaefeGeMeaeLfeCePeaeXeOedg dhdiZejbjceXeMeaejbjcfeLeGeCddjdkdlZeeMeaefeMeaeQeaepffeGeMeaeLfeeXePeaddm dndoZdteeSeeMeaeLffeXeMeaeQeaepffeQeLd.feSeGeMeaeLfdfeSeeMeaeLfdfeSeCeMeaeLfdfeXedq drdsZdS)uN) GraphModule)GraphNode)Argument)propagate_qconfig_) ObserverBase_is_activation_post_process)_is_reuse_input_qconfig QConfigAny)QConfigMapping)_generate_node_name_to_qconfig_update_qconfig_for_fusion_get_flattened_qconfig_dict_update_qconfig_for_qat)_default_root_node_getter!_get_pattern_to_quantize_handlersQuantizeHandler)Pattern NodePattern)is_equalization_observernode_supports_equalization)_sorted_patterns_dict)_MatchResultWithQConfig _find_matches) 3_insert_dequant_stubs_for_custom_module_lstm_output_is_custom_module_lstm+_maybe_get_custom_module_lstm_from_node_arg+_qconfig_satisfies_dtype_config_constraintsget_custom_module_class_keysall_node_args_have_no_tensorsassert_and_get_unique_device(get_non_observable_arg_indexes_and_typesget_new_attr_name_with_prefixnode_arg_is_weightnode_arg_is_biasNON_QUANTIZABLE_WEIGHT_OPSObservedGraphModuleAttrs)PlaceholderObserverconvert) _parent_nameget_qconfig_dtypesget_swapped_custom_module_class"activation_is_statically_quantized)get_pattern_to_dtype_configsget_module_to_qat_module&get_fusion_pattern_to_root_node_getter) BackendConfig DTypeConfigget_native_backend_config)PrepareCustomConfigStandaloneModuleConfigEntry) FakeTensor) AnyDictListOptionalSetTupleTypeUnionCallable)insert_observers_for_modelprepare propagate_dtypes_for_known_nodesinput_act_obs_or_fq_ctroutput_act_obs_or_fq_ctr)node named_modulesreturncCs*t|tjjo(|jdko(t|t|jS)N call_module) isinstancetorchfxropr strtargetrHrIrSi/var/www/html/stable-diffusion-webui/venv/lib/python3.9/site-packages/torch/ao/quantization/fx/prepare.py _is_activation_post_process_nodesrU) obs_or_fq_ctrrJcCs(|dur dS|}|jt|ddfSdS)zh Given a constructor for observer or fake quant module, returns a Tuple of dtype and is_dynamic N)NF is_dynamicF)dtypegetattr)rVZ obs_or_fqrSrSrT_get_dtype_and_is_dynamicsrZ)argrHqconfig dtype_configbackend_configrJcs>t|ttfr*tfdd|DSt|ts8dSt|}t|}| oZ| }|rjdd}t |\} } j dupj | kot j t | kot jS|rjddd} t | \} } j}| |k}t jdd }|dup|o|Sjdd d}t |\}} j}|dup8||kSdS) z] Check if the configured qconfig for the argument is supported by the backend or not c3s|]}t|VqdSN)(_is_input_arg_dtype_supported_by_backend).0ar^r]rHr\rSrT s z;_is_input_arg_dtype_supported_by_backend..Ttarget_dtype_inforFNweight_obs_or_fq_ctrF) is_activationbias_obs_or_fq_ctr)rLlisttupleallrr%r&metagetrZZ input_dtypeboolrWrZinput_dtype_with_constraints weight_dtypeZweight_dtype_with_constraints bias_dtype)r[rHr\r]r^ is_weightis_biasrgrF qconfig_dtypeqconfig_is_dynamicrfqconfig_weight_dtype_Zbackend_config_weight_dtype dtype_matchesqconfig_satisfies_constraintsrhqconfig_bias_dtypeZbackend_config_bias_dtyperSrcrTr`s>           r`)rHr\r]rJc CsT|j}d}|jdd}t|\}}|r0tj}||k}t||j}|dupR|oR|S)z[ Check if the configured qconfig for the output is supported by the backend or not NrerG)Z output_dtyperlrmrZrMfloat32rZoutput_dtype_with_constraints) rHr\r]Zbackend_config_output_dtypeZqconfig_output_dtyperGZqconfig_output_is_dynamicrwrxrSrSrT%_is_output_dtype_supported_by_backends  r{rRcCsJt||}t|jdkrFt|jdtrF|tjkrF|jdjdkrFdSdS)z Check if observer in same graph when the node output is not fp32 and input is 'placeholder' the input is assumed to be quantized, so it is observed in a different place rather than not observed. r placeholderFT)_get_arg_target_dtype_as_outputlenargsrLrrMquint8rO)rHrIZnode_output_dtyperSrSrT_is_observer_in_same_graphs  r)patternmatched_node_patternr\r^rJcCs|dus|durdS|dur(t|dks,Jt|}||g}t|}||t}||}|} |d} |D]T} d} t| jt| jD]} | ot | | || |} q| ot | || } | rldSqldS)z Check if the dtype configuration of a pattern is supported by the backend or not, and whether the qconfig satisfies constraints specified in the corresponding dtype config. NTr rF) r~r0rmr2rrirkwargsvaluesr`r{)rrr\r^Zpattern_to_dtype_configsZ dtype_configspattern_to_root_node_getterroot_node_getter root_nodeZ input_nodeZ output_noder] supportedr[rSrSrT9_is_pattern_dtype_config_and_qconfig_supported_by_backends,    r.)rHrIprepare_custom_configparent_qconfigparent_backend_configrJc Cszt|j}t||}tdddd}|j||}|j||}|jpPt |}|j } |j pbt }|j pl|} || || fS)z Returns the standalone module QConfigMapping and PrepareCustomConfig for `node`, assuming that the module pointed to by `node` is a standalone modules. NrS)rPrQtyper7standalone_module_classesrmstandalone_module_namesqconfig_mappingr Z set_globalexample_inputsrr6r^) rHrIrrr module_name module_typeZ config_entryrrr^rSrSrT_get_standalone_module_configss    r)rootmodule_to_qat_modulerJcCst||ddddS)NTF)mappingZinplaceZremove_qconfigr*)rrrSrSrT_qat_swap_modules!sr)rscCs>t|tr||jn"t|ttfr:|D]}t||q*dSr_)rLraddnamerirj_add_matched_node_name_to_set)rr maybe_noderSrSrTr&s  r)rHobservermodelrIgraphrJc Cst|}|r||t|r*|jd}nd}t|}||}t||||||<||"|d||fi} Wdn1s0Y| S)zp Attaches `observer` to `model`, and creates a node which calls `observer` on the output of `node`. Z_equalization_process_Zactivation_post_process_rKN)r"torrr$setattrZinserting_afterZ create_node) rHrrrIrZ model_deviceprefixZget_new_observer_nameZ observer_nameZnew_obsrSrSrT_insert_observer-s      "r)r last_noder\r^rIcache_for_no_tensor_checkprocessed_nodesrJc Cst|ttfr.|D]}t|||||||qnVt|trt|tsFJ|}||vrVdS|||durldSt||||} | |jd<dS)z Sets the target_dtype_info for each node in matched_node_pattern Note: processed_nodes is used to ensure we only process each node once Nre)rLrirj/_set_target_dtype_info_for_matched_node_patternrr%_get_target_activation_dtype_for_noderl) rrr\r^rIrrZ node_patternrHrerSrSrTrIs6   r)rHr\rIrrJc Cst|||}|rdddS|dur~t|\}}}|s8|ntj}|tjkr\|tjkr\|s\tjntj} |j|jtj| d|jdSt t S)a< For each op attribute in the op's input activation, output activation, weight, bias - returns the settings of dtype and is_dynamic we expect for the `quantize` call in the reference model representation, or None if there is no `quantize` call needed. For example, if we have a node corresponding to `op0` in x0 -> op0 -> x1 And we want a reference quantized representation to be x0 -> quant_static -> dequant -> op0 -> quant_dynamic -> dequant -> x1 Then this function will return { "input_act_obs_or_fq_ctr": MinMaxObserver.with_args(dtype=torch.quint8, is_dynamic=False), "output_act_obs_or_fq_ctr": MinMaxObserver.with_args(dtype=torch.quint8, is_dynamic=False), } TODO(future PR, if needed): explicitly spell out the non-Tensor dtypes. NrE)rX)rFrfrhrG) r!r-rMfloatfloat16 activationweightr)Z with_argscopy+_DEFAULT_FP32_QCONFIG_FOR_TARGET_DTYPE_INFO) rHr\rIrargs_have_no_tensorsZ act_dtyperoZinput_act_is_dynamicoutput_act_dtyperprSrSrTr}s:  r)r[rIrJcCst|tsJt||}d}|dur4|jdd}nDt||rj|jd}t|tsZJd|jdd}n|jdd}t|\}}|S)a Get the target output activation dtype for the argument in the original graph, skipping inserted observers We are assuming that the observers are inserted correctly, and the dtype for argument in quantized graph will match what is specified by the qconfig NrerGrz(Currently we only support observing Node)rLrrrlrUrrZ)r[rIZcustom_module_lstm_noderGZ observed_argrrvrSrSrTr}s      r})r[rHrIr^rJcCst|tsJt|||}t|||}| o0| }|rV|jdd}t|\}} |S|r|jtvrhdS|jddd} t| \} } | Sn"|jddd} t| \} } | SdS)W Get the target argument dtype for the argument `arg`, as input to node `node` rerFNrfrh) rLrr%r&rlrmrZrQr')r[rHrIr^rqrrrgrFrsrvrfrurhryrSrSrT&_get_arg_target_dtype_as_input_to_nodes"        rc Cslt|tsJt|||}t|||}| o0| }|rdd|jdvrd|jdd}t|\}} | SdSdS)rrFreFN)rLrr%r&rlrmrZ) r[rHrIr^rqrrrgrFrvrtrSrSrT+_get_arg_target_is_dynamic_as_input_to_nodes     r) rHr[r\rrIrqhandlerrr^rJc Cs6t|ttfrJg} |D]&} t|| ||||||| } | | qt|| St|tsX|St|tsfJ|} |duox|} |dusJ| st|||}t |}|r|j n|j }t ||}t ||||}t||||}| r||kr|tjkr|tvr| p|o||jdu}nt|||||\}}}}|j}d}t|jD]\}}||ur@|}q`q@|durpd}n4t ||}||vrtjntj}||ko|tjk}|j }|r2|}d}|jD]H\}}|jdkr||j}t|t|kr|j|kr|}qq|dur.t|||||}|} n|} | S)zk Given a `node` and an `arg`, inserts an input observer between `node` and `arg` if necessary. NrFrK)rLrirj-_maybe_insert_input_observer_for_arg_or_kwargappendrris_standalone_moduler%r rrr}rrrMr_DO_NOT_OBS_DTYPE_LISTrrinput_quantized_indexes enumeraterusersitemsrOrQrXr) rHr[r\rrIrrrr^Znew_arg_to_returnZ inner_argZ new_inner_argnew_argrrq_is_reuse_input_qconfig_Zact_post_process_ctrZarg_as_output_target_dtypeZarg_as_input_target_dtypeZarg_as_input_target_is_dynamicZ needs_obsrvsm_prepare_custom_configZsm_input_quantized_idxsZ cur_input_idxZarg_idxZ arg_to_checkZ new_obs_modZexisting_obs_nodeZmaybe_obs_nodeZ maybe_obs_modZ new_obs_noderSrSrTrs                       r) rHr\rrIrrrr^rJc Cs|dur dS|dusJg}|jD]&} t|| ||||||| } || q"i} |jD](\} } t|| ||||||| }|| | <qXt||_| |_dS)a  If needed, inserts observers to the input args and kwargs of `node`. Note: modifies `node` inplace. For example, if cur_node needs an observer after prev_node, we change from prev_node -> cur_node To prev_node -> obs -> cur_node N)rrrrrrj)rHr\rrIrrrr^new_argsr[rZ new_kwargskkwargZ new_kwargrSrSrT&_maybe_insert_input_observers_for_nodes.       r)rHequalization_qconfigrrIr is_branchr^rJc Cs|dust||sdS|r0td|ddSg}|jD]b}t|trTt|||r`||q:t|||} | rv|j n|j } | } t || |||} || q:t ||_dS)z If `node` needs to be equalized, find the input/weight observers it needs in `equalization_qconfig`, creates them, and inserts it into `graph`. If `node` does not need an equalization observer, returns None. NzCannot equalize z because it is part of a branch.) rwarningswarnrrLrr&rr%rZinput_activationrrj) rHrrrIrrr^rr[rqZact_eq_process_ctrZnew_eq_obs_modZnew_eq_obs_noderSrSrT3_maybe_insert_input_equalization_observers_for_nodes,       r) rHrrIr&node_name_to_match_result_with_qconfigmatched_patternris_qatrJcCs||jd\}} } }} |dur$dS| dus0J|jdksBJd|duoP|} |jdd} t| \}} |ttjgv}|ot | }|o| }|r| }t |||||SdSdS)z If `node` needs an output observer, creates it, inserts it into `graph` and returns it. If `node` does not need an output observer, returns None. NNNNNNoutputz3observer insertion for outputs is handled elsewherererG) rmrrOrrlrZrrMrr/rr)rHrrIrrrrrrrvrr\rrGrsZshould_insert_observerrrSrSrT&_maybe_insert_output_observer_for_nodes*  r)graph_output_nodeoutput_quantized_idxsnode_name_to_qconfigrrIrrJc s|dgks|gksJd|gkr&dStj}ttjtttftjjtttjjft tdfdd g}|j D]}| ||||||qnt ||_ dS)z If the output needs to be quantized and there are any nodes in the output which are not already observed, inserts observers for those nodes. rz,unrecognized format of output_quantized_idxsN)r target_dtyperrrIrrJc st|trZt||}||krT||j}|dus8Jd|}t|||||} | S|Snt|ttfrg} |D]} | | |||||qpt|tr| St| Sn>t|t ri} | D]\} }||||||| | <q| S| SdS)a` Navigate an arbitrary data structure of lists, tuples, dicts. For each container type, recurse on all inputs. Once any Node is found, insert an observer if needed and do not recurse further. For example, given a structure of {'foo1': [[bar1]], 'foo2': {'foo3': [[[bar3]]]}} we recurse down to bar1 and bar3, observe them if necessary, and if we inserted an observer then replace the original node with its observer. Returns the data structure with all nodes needing observation being replaced by their observers. Nz=Quantizing the output node without a qconfig is not supported) rLrr}rmrrrrirjrdictr)rrrrrIrZthis_node_dtyper\Z observer_modZ observer_noderesultsZ inner_nodeZ results_dictrZinner_v&_recursive_maybe_replace_node_with_obsrSrTrCs@         z[_maybe_insert_observers_before_graph_output.._recursive_maybe_replace_node_with_obs) rMrrrXr:rPr nnModulerrrrj) rrrrrIrZoutput_target_dtyperZold_argrSrrT+_maybe_insert_observers_before_graph_output's, ;  r)rHrrrJc Cshd|jdd<d|jdd<||jd\}}}}}|durd|rd|jd}t|trdt|||dS)z Assigns `target_dtype` to `node`, setting `is_dynamic` to False. If `node` is a general tensor shape op, also call this function recursively on the first argument, to propagate the dtype to the caller. NrerFrGrr)rlrmris_general_tensor_value_oprrLr_maybe_propagate_dtype_for_node) rHrrrrvrrr\Z prev_noderSrSrTrs   r)rrrJc Cs|jD]z}t|}|D]h}|||}|D]R}|j|}t|ttfrPt|}n|g}|D] } t| tjjj rZt | ||qZq*qqdS)a Currently we assume that inputs to the graph are either `torch.float` or `torch.quint8`, which is not always correct. For ops such as `x.masked_fill(mask, value)`, we know that the dtype of `mask` is a `BoolTensor`. Propagate this information throughout the graph. Note: not all dtypes in the graph will be correct after this pass, but a higher percentage of them will be correct. Hopefully in the future we can replace this with a better way to reason about dtypes of tensors. N) nodesr#rrLrjrirMrNrHrr) rrrHZnon_observable_arg_dictZarg_typeZnon_observable_indicesindexr[arg_listZcur_argrSrSrTrDs    rD)rHrrIrJcCs d}tt|jD](}t|j|tttfr|j|}qd}t| |st| jdkrzdS| jd} |d7}|dkrXt dqXt | j \} } t|| | | q>|jD]8\}}t||sJt |j \} } t|| | | qdS) a Ensures that we share an observer for all input arguments as well as the output argument. In detail, given a graph of x0 -> obs0 -> op -> x2 / x1 -> obs1 / where node obs0 points to observer instance observer0, obs1 points to observer1 and obs2 points to observer2, we make nodes obs1 and ob2 point to observer0. Returns: whether the operation succeeded or not NFrr|r i'z(Unable to find observer of previous nodeT)ranger~rrLrrirjrUrOAssertionErrorrQrPrr,rrr)rHrrIZ first_argiZ first_arg_argZiteration_guardZtrace_back_nodeZ target_to_useZobs_mod_to_useZ input_idxZ input_arg parent_nameroutput_obs_nodervrSrSrT(_maybe_make_input_output_share_observerssh              r)rHrrIcCsDt|j}|D],\}}t||s(J|||j|qdSr_)rirrrUZreplace_all_uses_withrZ erase_node)rHrrIrrrvrSrSrT_remove_output_observers   r)rHr\rIrc CsH||j}|j}t|||}||}t|j\}} t||| |dSr_)rQfloat_to_observed_mappingr. from_floatr,r) rHr\rIrZ custom_moduleZcustom_module_class_mappingZobserved_custom_module_classZobserved_custom_modulerrrSrSrT_swap_custom_module_to_observed(s r) rrrrequalization_config_mapr^observed_node_namesrrJc2 Csi}t|jdd} |j} |j} t} |jjD]} tt| j d<q.d}d}i}i}|jjD]8} | j dkrz||| <|d7}| j dkr\||| <|d7}q\| D]6\}}|\}}}}}|dusJt ||||| || q|jjD]} | j dkr|| | vrtt | j d<q| j d vr>t| | |}|rdddd | j d<q| j dkr|| | vrtt | j d<qt|j|t} | D]\}}|\}}}}}t||||}|dusJt| j dd \}}|s|dtttjfvrt ||tjjjj|| || qt|jj}t}d}d}d}|D]X} | j dkr:n| j d vrN|| jd \}}}}}|| jd} | j d}!d| j vr|!duot| j dt}"n|!du}"|dus|" o| j dk }#t||||}|#sN|rNt|jdd} | j dkr:|dusJt||d}$t | j!dkrt| j!dt"rt | j!dj#dkr| j!dj#D]N}%||%jddup|%j dkot| t$|%j%t&}&|%| krZ|&rZd}$qZt'|}'|'|t(}(|(|})| |)u}*|*rt)| ||| |j|||t*| | || |j|$|| |u}+|duo|+},t,|}-|+rNt-| | ||rrt.| || |j| j%|vr8|/| j%t0| || |nt1| || |j||||}.|.durNt| j#2}/|/D] }0|0|.urq|03| |.qt4| | }1|,r|1s|-rt5| || st6| || |durN|7rN| j%|vrN|/| j%t0| || |nt8| | ||| |j| j dkrd|d7}n| j dkr$|d7}| }q$|S)a$ Inserts observers, using the following high level algorithm: For each node in the graph: 1. determine the target dtype of this node in the quantized graph, and save it for future steps 2. determine the target dtype or all args and kwargs of this node 3. if any arg or kwarg's target dtype does not match the current node's dtype, insert an observer 4. if the current node needs an output observer, insert it For example: - starting graph: x0 -> linear -> x1 - observed graph after processing x0: x0(fp32) - observed graph after processing linear: x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8) - observed graph after processing x1: x0(fp32) -> x0_obs0(int8) -> linear(int8) -> linear_obs0(int8) -> x1 After a node is processed, the naive observer placement is guaranteed to be complete for that node and all of its predecessors. There can be future passes which optimize the graph by deduplicating observers, etc. FZremove_duplicatererr|r rN)rK call_method call_functionrErG)rKrrrrvalrKT)9rrIroutput_quantized_indexessetrrrrrlrOrr-_DEFAULT_QUINT8_QCONFIG_FOR_TARGET_DTYPE_INFOr!rDrrZintrrMrnao quantizationr\!_default_fp32_placeholder_qconfigrirmrrLr8rr~rrrrPrQrr2rrrrr rrrrrkeysZreplace_input_withrrrZis_custom_moduler)2rrrrrr^rrrrIinput_quantized_idxsrrrHZinputs_seen_counterZoutputs_seen_counterZplaceholder_node_to_input_indexZoutput_node_to_output_index node_nameZmatch_res_with_qconfigrrrrr\rZis_supported_by_backendrrvZnodes_before_observationZ#custom_module_names_already_swappedZ results_noderZthis_node_dtype_infoZoutput_is_a_tensorZskip_inserting_observersZis_quantized_branchuserZis_user_quantizedrrrZis_input_node_of_the_patternZis_last_node_of_patternrrZmaybe_output_obs_nodeZ orig_usersZ user_nodeZ_is_observer_in_same_graph_rSrSrTrB7sJ<                                         rB)rrrIrrr^rJc Cs|D]\}\}}} } } | dur&qn | s0qt|||| |\} } }}||j}tjjjj}||| || ||d}t |j\}}t |||||||j<qdS)z Runs prepare_fx on each standalone module. Note: this does not modify the graph, it just replaces the unobserved modules with their observed versions. N)rrr^) rrrrQrMrrZ quantize_fxZ_prepare_standalone_module_fxr,r)rrrIrrr^rrrvrrr\Zsm_qconfig_mappingZsm_example_inputsrZsm_backend_configZstandalone_modulerCZobserved_standalone_modulerrrSrSrT%_run_prepare_fx_on_standalone_moduless8    r) observedrnode_name_to_scoper!equalization_node_name_to_qconfigrrrrJc Cs t|||||||d|jd<dS)N)rrrrrrr_observed_graph_module_attrs)r(rl)rrrrrrrrrSrSrT _save_states rF) rrrrrr_equalization_configr^rrJc  Cs|durt}|durt}t|tr:tdt|}t|trXtdt|}t|trvtdt|}t|trtdt|}t|tsJt|tsJt |}t |}i} |durt }t |} t | } t |} t||t||t|} t|| ||rr?r@rA__all__rrrnrrrrrrZ#_default_quint8_placeholder_qconfigrrPrrrUrXrZr`r{rrrrrrrrrr}rrrrrrrrrDrrrrBrrrCrSrSrSrTs     <   ,    "  /    #     5  D       5 -  /  a     % ^      f *