h SSKJrJr SSKJr SSKJr SSKJrJ r J r J r J r SSK rSSKrSSKJr SSKrSSKJrJr SSKJr \ "S\\5rS \\\\4S \S S4S jrS \\\4S \ 4Sjr!S)S \\\\\\44S\S\ \\ \\ 4S \\\44Sjjr"S)S \\\\\\44S\S\ \\ \\ 4S\S \\\44 Sjjr#S\\\\\\\44S \\\\\\\444Sjr$S*S\S\ \S\ \S \4Sjjr%S*S\S\ \S\ \S \4Sjjr&S \\\4S \\\44Sjr'S \\\4S \\\44Sjr("SS5r)S\RTS\S \RT4S jr+S\RTS\S \RT4S!jr,S+S\S\S"\S#\ \\\4S \4 S$jjr-S)S\S%\S#\ \\\4S \4S&jjr.S \\\4S \ 4S'jr/S \\\4S \\\44S(jr0g),) defaultdictdeque)Sequence) takewhile)AnyCallableOptionalTypeVarUnionN)Dataset DatasetDict)PreTrainedTokenizerBase DatasetTypemessages num_imagesreturncSnUHnUSS:Xa([US[5(aSUSS./US'M2M4USS:Xak[US[5(a"U(dSS 0/U-n/UQSUSS.PUS'S nMw[US[5(aU(aSUSS./US'MMMUSS :Xa([US[5(aSUSS./US'MM[S USS 35e g)a Convert messages into a structured multimodal format if needed. Each message's content is transformed from a raw string into a list of typed parts. The first user message is prefixed with an image placeholder, while all other user and assistant messages are wrapped as text entries. Args: messages (`list[dict[str, Any]]`): Messages with `"role"` and `"content"`. Content may be a raw string before transformation. num_images (`int`): Number of images to include in the first user message. This is used to determine how many image placeholders to add. Example: ```python # Input [ {"role": "user", "content": "What's in this image?"}, {"role": "assistant", "content": "It looks like a cat."}, ] # Output (num_images=1) [ {"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What's in this image?"}]}, {"role": "assistant", "content": [{"type": "text", "text": "It looks like a cat."}]}, ] ``` Frolesystemcontenttext)typeruserrimageT assistantzInvalid role in message: z,. Expected 'user', 'assistant', or 'system'.N) isinstancestr ValueError)rrimage_includedmessage placeholderss H/home/james-whalen/.local/lib/python3.13/site-packages/trl/data_utils.pyprepare_multimodal_messagesr#s.:N 6?h &'),c22/5wy?Q&R%S "3 V_ &'),c22>!' 12Z? %b|%bfgV_N`5a%b "!%GI.44/5wy?Q&R%S ":H4 V_ +'),c22/5wy?Q&R%S "388IIuvw wexamplec/SQnUR5Vs1sH o"U;dM UiM nnU(aPUR5nXn[U[5(a'USn[U[5(a SU;aSU;aggs snf)a  Check if the example is in a conversational format. Args: example (`dict[str, Any]`): A single data entry of a dataset. The example can have different keys depending on the dataset type. Returns: `bool`: `True` if the data is in a conversational format, `False` otherwise. Examples: ```python >>> example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]} >>> is_conversational(example) True >>> example = {"prompt": "The sky is"} >>> is_conversational(example) False ``` )promptchosenrejected completionrrrrTF)keyspoprlistdict)r%supported_keyskey example_keysmaybe_messages maybe_messages r"is_conversationalr4Os0PN#*<<>K>CN5JC>LK   nd + +*1-M-..6]3Jy\iOi Ls BB tokenizertoolsc /SQnUR5Vs1sH oUU;dM UiM nnUS1S1SS11SkSS11Sk4;a[S U35eSU;aUR"US4US S .UD6nSU;aJUSS S nUS:XaSn S n OUS:XaS n Sn O[SU35eUR"US4UU S U S.UD6n SU;Ga'SU;aZUR"USUS-4US S .UD6n SR S[ S[ W U 5555n U [U 5Sn SU;a`SU;aZUR"USUS-4US S .UD6nSR S[ S[ W U5555n U[U 5SnSU;aZUR"USUS-4US S .UD6nSR S[ S[ W U5555n U[U 5SnO>SU;aUR"US4US S .UD6n SU;aUR"US4US S .UD6n0nSU;aWUS'SU;aW US'SU;aW US'SU;aWUS'SU;aWUS'SU;aUSUS'U$s snf)z Apply a chat template to a conversational example along with the schema for a list of functions in `tools`. For more details, see [`maybe_apply_chat_template`]. )r'r(r)r*rlabelrr'r*>r(r'r)r(r)>r8r'r*zInvalid keys in the example: F)r6tokenizerrTrz"Invalid role in the last message: )r6continue_final_messager9add_generation_promptc3*# UH upUv M g7fN.0x_s r" &apply_chat_template..si+h41Q+hcUSUS:H$Nrr@rCs r"%apply_chat_template..qtqt|r$Nc3*# UH upUv M g7fr?r@rAs r"rErFsk+j41Q+jrGcUSUS:H$rIr@rKs r"rLrMrNr$c3*# UH upUv M g7fr?r@rAs r"rErFsm+l41Q+lrGcUSUS:H$rIr@rKs r"rLrMrNr$rr8)r+KeyErrorapply_chat_templaterjoinrziplen)r%r5r6template_kwargsr/r0r1r last_roler<r;r' prompt_chosenr(prompt_rejectedr)prompt_completionr*outputs r"rTrTxspYN#*<<>K>CN5JC>LK   < ( :) 6|nEFFW001DuE\auetu7H%b)&1  $( !%* " + %$) !%) "A)MN N.. H  #9"7    7 w %99!GH$55=BUVeM WWi95KSQWYfMg+hiiF"3v;=1F  X%8';;!GJ$77?DuXgOWWk95KSQWYhMi+jkkF&s6{}5H 7 " ) = =!GL$99!AFQV!Zi! WWm95KSQWYjMk+lmmF*3v;=9J w 22783DuE\auetuF   44 #+05DSH FW!v7!x7!xW%zw)|'!'*w MiLs I4I4rXc @[U5(a [XU40UD6$U$)a& If the example is in a conversational format, apply a chat template to it. Args: example (`dict[str, list[dict[str, str]]`): Dictionary representing a single data entry of a conversational dataset. Each data entry can have different keys depending on the dataset type. The supported dataset types are: - Language modeling dataset: `"messages"`. - Prompt-only dataset: `"prompt"`. - Prompt-completion dataset: `"prompt"` and `"completion"`. - Preference dataset: `"prompt"`, `"chosen"`, and `"rejected"`. - Preference dataset with implicit prompt: `"chosen"` and `"rejected"`. - Unpaired preference dataset: `"prompt"`, `"completion"`, and `"label"`. For keys `"messages"`, `"prompt"`, `"chosen"`, `"rejected"`, and `"completion"`, the values are lists of messages, where each message is a dictionary with keys `"role"` and `"content"`. tokenizer (`PreTrainedTokenizerBase`): Tokenizer to apply the chat template with. tools (`list[Union[dict, Callable]]` or `None`, *optional*, defaults to `None`): A list of tools (callable functions) that will be accessible to the model. If the template does not support function calling, this argument will have no effect. **template_kwargs (`Any`, *optional*): Additional kwargs to pass to the template renderer. Will be accessible by the chat template. Returns: `dict[str, str]`: Formatted example with the chat template applied. Notes: - This function does not alter the keys, except for Language modeling dataset, where `"messages"` is replaced by `"text"`. - In case of prompt-only data, if the last role is `"user"`, the generation prompt is added to the prompt. Else, if the last role is `"assistant"`, the final message is continued. Example: ```python >>> from transformers import AutoTokenizer >>> tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-128k-instruct") >>> example = { ... "prompt": [{"role": "user", "content": "What color is the sky?"}], ... "completion": [{"role": "assistant", "content": "It is blue."}], ... } >>> apply_chat_template(example, tokenizer) {'prompt': '<|user|>\nWhat color is the sky?<|end|>\n<|assistant|>\n', 'completion': 'It is blue.<|end|>\n'} ``` )r4rT)r%r5r6rXs r"maybe_apply_chat_templater_s'p!!"7uPPPr$examplesc|[US5nUSUS-S/U-S/U--S.nSU;aUSUS-US'U$)Nr(r)TF)r*r8r')rW)r` batch_sizenew_rowss r" _unpair_rowrdshXh'(Jx(8J+??*$w';;H8%h/(82DD Or$datasetnum_procdescc2UR[SSS/XS9$)a Unpair a preference dataset. Args: dataset (`Dataset` or `DatasetDict`): Preference dataset to unpair. The dataset must have columns `"chosen"`, `"rejected"` and optionally `"prompt"`. num_proc (`int` or `None`, *optional*, defaults to `None`): Number of processes to use for processing the dataset. desc (`str` or `None`, *optional*, defaults to `None`): Meaningful description to be displayed alongside with the progress bar while mapping examples. Returns: `Dataset`: The unpaired preference dataset. Example: ```python >>> from datasets import Dataset >>> dataset_dict = { ... "prompt": ["The sky is", "The sun is"], ... "chosen": [" blue.", "in the sky."], ... "rejected": [" green.", " in the sea."], ... } >>> dataset = Dataset.from_dict(dataset_dict) >>> dataset = unpair_preference_dataset(dataset) >>> dataset Dataset({ features: ['prompt', 'completion', 'label'], num_rows: 4 }) >>> dataset[0] {'prompt': 'The sky is', 'completion': ' blue.', 'label': True} ``` Tr(r))batchedremove_columnsrfrg)maprd)rerfrgs r"unpair_preference_datasetrl%s"P ;;{D(JAWbj; vvr$c[U[5(a*U[UR55SRnO URnSU;aSU;a [ XUS9$U$)aj Unpair a preference dataset if it is paired. Args: dataset (`Dataset` or `DatasetDict`): Preference dataset to unpair. The dataset must have columns `"chosen"`, `"rejected"` and optionally `"prompt"`. num_proc (`int` or `None`, *optional*, defaults to `None`): Number of processes to use for processing the dataset. desc (`str` or `None`, *optional*, defaults to `None`): Meaningful description to be displayed alongside with the progress bar while mapping examples. Returns: `Dataset` or `DatasetDict`: The unpaired preference dataset if it was paired, otherwise the original dataset. Example: ```python >>> from datasets import Dataset >>> dataset_dict = { ... "prompt": ["The sky is", "The sun is"], ... "chosen": [" blue.", "in the sky."], ... "rejected": [" green.", " in the sea."], ... } >>> dataset = Dataset.from_dict(dataset_dict) >>> dataset = unpair_preference_dataset(dataset) >>> dataset Dataset({ features: ['prompt', 'completion', 'label'], num_rows: 4 }) >>> dataset[0] {'prompt': 'The sky is', 'completion': ' blue.', 'label': True} ``` rr(r))rfrg)rr r-r+ column_namesrl)rerfrgrns r"maybe_unpair_preference_datasetroPs^P';''tGLLN3A67DD ++ <J,$>($OOr$c [[[US5[US555H+nUSUUSU:wdMUSUS- S:XaUS-n O USSWUSUSUSUSS.$)z Extracts the shared prompt from a preference data example, where the prompt is implicit within both the chosen and rejected completions. For more details, see [`maybe_extract_prompt`]. r(r)rJ N)r'r(r))rangeminrW)r%idxs r"extract_promptrusSWX./WZ5H1IJK 8 S !WZ%8%= =x q)S0q  L (#DS)(#CD)J'- r$cSU;dSU;aU$SU;a>[SUS05n[SUS05nU(aU(dU(d U(dU$[USUSS.5$)a Extracts the shared prompt from a preference data example, where the prompt is implicit within both the chosen and rejected completions. If the example already contains a `"prompt"` key, the function returns the example as is. Else, the function identifies the longest common sequence (prefix) of conversation turns between the "chosen" and "rejected" completions and extracts this as the prompt. It then removes this prompt from the respective "chosen" and "rejected" completions. Args: example (`dict[str, list]`): A dictionary representing a single data entry in the preference dataset. It must contain the keys `"chosen"` and `"rejected"`, where each value is either conversational or standard (`str`). Returns: `dict[str, list]`: A dictionary containing: - `"prompt"`: The longest common prefix between the "chosen" and "rejected" completions. - `"chosen"`: The remainder of the "chosen" completion, with the prompt removed. - `"rejected"`: The remainder of the "rejected" completion, with the prompt removed. Examples: ```python >>> example = { ... "chosen": [ ... {"role": "user", "content": "What color is the sky?"}, ... {"role": "assistant", "content": "It is blue."}, ... ], ... "rejected": [ ... {"role": "user", "content": "What color is the sky?"}, ... {"role": "assistant", "content": "It is green."}, ... ], ... } >>> extract_prompt(example) {'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}], 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]} ``` Or, with the `map` method of `datasets.Dataset`: ```python >>> from trl import extract_prompt >>> from datasets import Dataset >>> dataset_dict = { ... "chosen": [ ... [ ... {"role": "user", "content": "What color is the sky?"}, ... {"role": "assistant", "content": "It is blue."}, ... ], ... [ ... {"role": "user", "content": "Where is the sun?"}, ... {"role": "assistant", "content": "In the sky."}, ... ], ... ], ... "rejected": [ ... [ ... {"role": "user", "content": "What color is the sky?"}, ... {"role": "assistant", "content": "It is green."}, ... ], ... [ ... {"role": "user", "content": "Where is the sun?"}, ... {"role": "assistant", "content": "In the sea."}, ... ], ... ], ... } >>> dataset = Dataset.from_dict(dataset_dict) >>> dataset = dataset.map(extract_prompt) >>> dataset[0] {'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}], 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]} ``` r(r)r')r(r))r4ru)r% chosen_conv prompt_convs r"maybe_extract_promptrysqdw*G";7'783D(EF '783D(EF K[N WX%6GJDWX YYr$c8\rSrSrSrS\4SjrSrSrSr Sr g ) _SegmentTreeia A segment tree data structure that, when initialized as `_SegmentTree(maxval)`, efficiently finds the next larger value for a given input within the range [1, maxval]. See [Fewer Truncations Improve Language Modeling](https://arxiv.org/abs/2404.10830) for more details. maxvalcvXlSUS- R5-UlS/SUR--Ulg)NrJr)r| bit_length tree_sizetree)selfr|s r"__init___SegmentTree.__init__s7 vz5577C1t~~-. r$cSUs=:aUR::de eURU-S- nXRU'US:aJUS-nURUS-URUS-S-pCX4:aUOUURU'US:aMIggrIr|rrrvalileftrights r"add_SegmentTree.adds3%$++%%%%% NNS 1 $ ! !e !GA))AF+TYYQ!|-D%#'=4eDIIaL !er$cSUs=:aUR::de eURU-S- nSURU'US:aJUS-nURUS-URUS-S-pCX4:aUOUURU'US:aMIggrIrrs r"remove_SegmentTree.remove s3%$++%%%%% NNS 1 $ ! !e !GA))AF+TYYQ!|-D%#'=4eDIIaL !er$cSUs=:aUR::de eSnX R:a5URUS-U:aUS-nOUS-S-nX R:aM5URU$rIr)rrrs r"search_SegmentTree.searchsu3%$++%%%%% .. yya C'F!VqL .. yy|r$)r|rrN) __name__ __module__ __qualname____firstlineno____doc__intrrrr__static_attributes__r@r$r"r{r{s"/s/ <<r$r{ seq_lengthc  /nSn[UR5HupE[RR UR 5(d.[RR UR 5(a[R"USU5nUcUnURU5 M [RRX RS9n[R"[!U55nUce[R""X5R%5nUR'SU5n[R("Xv5nUR+SSS9n[-U5nUR/U5 [1[25n /n [5UR7S5R95UR7S5R955HupUR;U 5n X:aXR=5n O/SS.n U RU 5 U S RU5 U S ==U - ss'X:aX(dUR?U 5 X- n XRU 5 U S:dMUR/U 5 M [R@"X V Vs/sHoS HoPM M snn 5n[RB"S/U V s/sHoS PM sn -5n[RD"U5n[GS UR55(deUSRHSnURKS5n[RLR[RD"S/U V s/sHn [!U S 5PM sn -[RNS 9U5n/nURHnURHSn[RR UR 5(d.[RR UR 5(aXURPR RS5n[ U5RURUU5URV5nURU5 M [RRX'/-URS/-S9$s snn fs sn fs sn f) zEPack sequences in a pyarrow Table using Best Fit Decreasing strategy.Nrnames seq_lengths descending)byrJ)idslengthrrc3># UHoRS:Hv M g7f)rJN) num_chunks)rBcolumns r"rE_pack_bfd..Qs-=6Q-=sdtype), enumeratecolumnspyarrowtypesis_listr is_large_listpc list_sliceappendpaTable from_arraysrnnparangerWlist_value_lengthcombine_chunks append_column make_structsortr{rrrrVfieldto_numpyrpopleftrtakearraycumsumallchunks drop_columns ListArrayint32offsetsto_pandas_dtypeastypevalues)r`rrlist_column_idxrtrrlengths segment_tree space_to_binbinsrspacebinid_rrs r" _pack_bfdrsGO !1!12  ==  - -1L1LV[[1Y1Y]]61j9F&"%v 3 xx##G3H3H#IH ))CM "C  && &""8#<=LLNG%%mW=HnnW*Gll -Sc /nURGHJn[RRUR5(d.[RR UR5(a[ U[R5(aUR5nURURpTXTSR5USR5n[U5nURR5n[R "SXaUS9n[R""XF/45n[ U5R%XE5nUR'U5 GMM [R(R%X R*S9$)z;Pack sequences in a pyarrow Table using a wrapped strategy.rr:rr)rrrrrrrr ChunkedArrayrrras_pyrWrrr concatenaterrrrn)r`rrrrr num_elementsrs r" _pack_wrappedrcsG"" ==  - -1L1LV[[1Y1Y&"//22..0$nnfmmVAJ,,.1B1B1DEFv;LLL002Eii<5IGnng~%>?G&\--g>Fv# 88  /D/D  EEr$strategy map_kwargscUc0nURS5nUS:XaUR"[4SSU0S.UD6nO2US:XaUR"[4SSU0S.UD6nO[ SUS 35eURS5nU$) a Pack sequences in a dataset into chunks of size `seq_length`. Args: dataset (`Dataset` or `DatasetDict`): Dataset to pack seq_length (`int`): Target sequence length to pack to. strategy (`str`, *optional*, defaults to `"bfd"`): Packing strategy to use. Can be either: - `"bfd"` (Best Fit Decreasing): Slower but preserves sequence boundaries. Sequences are never cut in the middle. - `"wrapped"`: Faster but more aggressive. Ignores sequence boundaries and will cut sequences in the middle to completely fill each packed sequence with data. map_kwargs (`dict` or `None`, *optional*, defaults to `None`): Additional keyword arguments to pass to the dataset's map method when packing examples. Returns: `Dataset` or `DatasetDict`: The dataset with packed sequences. The number of examples may decrease as sequences are combined. Example: ```python >>> from datasets import Dataset >>> from trl import pack_dataset >>> examples = { ... "input_ids": [[1, 2, 3], [4, 5], [6, 7, 8], [9]], ... "attention_mask": [[1, 1, 0], [1, 0], [1, 0, 0], [1]], ... } >>> dataset = Dataset.from_dict(examples) >>> packed_dataset = pack_dataset(dataset, seq_length=4, strategy="bfd") >>> packed_dataset[:] {'input_ids': [[1, 2, 3, 9], [6, 7, 8], [4, 5]], 'attention_mask': [[1, 1, 0, 1], [1, 0, 0], [1, 0]], 'seq_lengths': [[3, 1], [3], [2]]} ``` NarrowbfdTr)ri fn_kwargswrappedzInvalid packing strategy: z. Use 'bfd' or 'wrapped'.) with_formatrkrrr)rerrrs r" pack_datasetrusT !!'*G5++ij,PZA[j_ij Y ++mnTlT^E_ncmn5hZ?XYZZ!!$'G Nr$ max_lengthc^Uc0n[U[5(a?U4SjnURS5nUR"U4SS0UD6nURS5nU$U4SjnUR"U4SS0UD6nU$)a\ Truncate sequences in a dataset to a specified `max_length`. Args: dataset (`Dataset` or `DatasetDict`): Dataset to truncate. max_length (`int`): Maximum sequence length to truncate to. map_kwargs (`dict` or `None`, *optional*, defaults to `None`): Additional keyword arguments to pass to the dataset's map method when truncating examples. Returns: `Dataset` or `DatasetDict`: The dataset with truncated sequences. Example: ```python >>> from datasets import Dataset >>> examples = { ... "input_ids": [[1, 2, 3], [4, 5, 6, 7], [8]], ... "attention_mask": [[0, 1, 1], [0, 0, 1, 1], [1]], ... } >>> dataset = Dataset.from_dict(examples) >>> truncated_dataset = truncate_dataset(dataset, max_length=2) >>> truncated_dataset[:] {'input_ids': [[1, 2], [4, 5], [8]], 'attention_mask': [[0, 1], [0, 0], [1]]} ``` Nc>/nURHn[RRUR5(d.[RR UR5(a[ R"UST5nURU5 M [RRXRS9$)Nrr) rrrrrrrrrrrrrn)r`truncated_columnsrrs r"truncate"truncate_dataset..truncates " "**==((559T9TU[U`U`9a9a]]61jAF!((0+88''(9AVAV'W Wr$rriTc>0nUR5H<up#U(a,[US[5(aUVs/sHoDSTPM nnX1U'M> U$s snf)Nr)itemsrr-)r`truncated_examplesr0rrrs r"rrs^!# '~~/ jD99:@A&3+:.&FA*03' 0& %BsA)rr rrk)rerrrs ` r"truncate_datasetrs@ '7## X%%g.++hCC C%%d+ N &++     Nr$cURS5n[U[5(a'USn[U[5(a SU;aSU;agg)a Check if the example is in a conversational format (from/value). Note that this format isn't recommended. Prefer the ChatML format (role/content) Args: example (`dict[str, Any]`): A single data entry of a dataset. The example can have different keys depending on the dataset type. Returns: `bool`: `True` if the data is in a conversational Chatformat, `False` otherwise. Examples: ```python >>> example = {"conversations": [{"from": "user", "value": "What color is the sky?"}]} >>> is_conversational_from_value(example) True >>> example = {"conversations": [{"role": "user", "content": "What color is the sky?"}]} >>> is_conversational_from_value(example) False >>> example = {"conversations": "The sky is"} >>> is_conversational_from_value(example) False ``` conversationsrfromvalueTF)getrr-r.)r%r2r3s r"is_conversational_from_valuersK:[[1N.$''&q) mT * *v/F7VcKc r$c@SH}nX;dM [X[5(dM#XnUHPn[U[5(dMSU;aURS5US'SU;dM<URS5US'MR M SU;aURS5US'U$)a Convert a conversational dataset with fields `from` and `value` to ChatML format. This function modifies conversational data to align with OpenAI's ChatML format: - Replaces the key `"from"` with `"role"` in message dictionaries. - Replaces the key `"value"` with `"content"` in message dictionaries. - Renames `"conversations"` to `"messages"` for consistency with ChatML. Args: example (`dict[str, list]`): A single data entry containing a list of messages. Returns: `dict[str, list]`: Example reformatted to ChatML style. Example: ```python >>> from trl import maybe_convert_to_chatml >>> example = { ... "conversations": [ ... {"from": "user", "value": "What color is the sky?"}, ... {"from": "assistant", "value": "It is blue."}, ... ] ... } >>> maybe_convert_to_chatml(example) {'messages': [{'role': 'user', 'content': 'What color is the sky?'}, {'role': 'assistant', 'content': 'It is blue.'}]} ``` )r'r*r(r)rrrrrrrr)rr-r.r,)r%r0rr s r"maybe_convert_to_chatmlrsB[ >jt<<|H#gt,,(*1++f*=')-4[[-A * $['!%kk/:  Nr$r?)NN)rN)1 collectionsrrcollections.abcr itertoolsrtypingrrr r r numpyrrrpyarrow.computecomputer pyarrow.typesdatasetsr r transformersrrr-r.rrr#boolr4rTr_rdrlroruryr{rrrrrrrr@r$r"rs}+$::)0mWk: -x$tCH~*>-xC-xTX-x`&tCH~&$&X48a #tDcN++ ,a&a DtX~./ 0a  #s(^ aN48; #tDcN++ ,;&; DtX~./ 0; ;  #s(^ ;|$tCd38n)=$=>?DcSWX\]`be]eXfSgNgIhDiQU(w (w$,SM(w@H (w(wXQU/ /$,SM/@H //dDh/Dh4G&ZZ$sDy/ZZd39oZZz**ZAdAdcAdbhhAdHFBHHF#F"((F&jn5 5&)5585NVW[\_ad\dWeNf55rSW> >&)>7?S#X7O>>B%$sCx.%T%P/T#t)_/c4i/r$