
    +hq                     T   S SK r S SKJrJrJrJrJr  S SKrS SK	r	SSK
Jr  SSKJr  SSKJr  SSKJr  SS	KJrJr  SS
KJrJrJr  SSKJr  \R4                  " \5      r    S+S\\   S\\\\	R>                  4      S\\\      S\\\       4S jjr!    S,S\S\S\ S\ 4S jjr"S r# S-S\	RH                  S\\	RJ                     S\4S jjr&S r'S r(S\	RH                  S\	RJ                  4S jr)S  r* " S! S"\5      r+ " S# S$\5      r, " S% S&\5      r- " S' S(\5      r. " S) S*\5      r/g).    N)AnyListOptionalTupleUnion   )AutoencoderKL)FlowMatchEulerDiscreteScheduler)logging)randn_tensor   )ModularPipelineBlocksPipelineState)ComponentSpec
InputParamOutputParam   )FluxModularPipelinenum_inference_stepsdevice	timestepssigmasc                    Ub  Ub  [        S5      eUb  S[        [        R                  " U R                  5      R
                  R                  5       5      ;   nU(       d  [        SU R                   S35      eU R                  " S
X2S.UD6  U R                  n[        U5      nX14$ Ub  S[        [        R                  " U R                  5      R
                  R                  5       5      ;   nU(       d  [        SU R                   S35      eU R                  " S
XBS.UD6  U R                  n[        U5      nX14$ U R                  " U4S	U0UD6  U R                  nX14$ )a  
Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.

Args:
    scheduler (`SchedulerMixin`):
        The scheduler to get timesteps from.
    num_inference_steps (`int`):
        The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps`
        must be `None`.
    device (`str` or `torch.device`, *optional*):
        The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
    timesteps (`List[int]`, *optional*):
        Custom timesteps used to override the timestep spacing strategy of the scheduler. If `timesteps` is passed,
        `num_inference_steps` and `sigmas` must be `None`.
    sigmas (`List[float]`, *optional*):
        Custom sigmas used to override the timestep spacing strategy of the scheduler. If `sigmas` is passed,
        `num_inference_steps` and `timesteps` must be `None`.

Returns:
    `Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
    second element is the number of inference steps.
zYOnly one of `timesteps` or `sigmas` can be passed. Please choose one to set custom valuesr   zThe current scheduler class zx's `set_timesteps` does not support custom timestep schedules. Please check whether you are using the correct scheduler.)r   r   r   zv's `set_timesteps` does not support custom sigmas schedules. Please check whether you are using the correct scheduler.)r   r   r    )

ValueErrorsetinspect	signatureset_timesteps
parameterskeys	__class__r   len)	schedulerr   r   r   r   kwargsaccepts_timestepsaccept_sigmass           i/home/james-whalen/.local/lib/python3.13/site-packages/diffusers/modular_pipelines/flux/before_denoise.pyretrieve_timestepsr)   "   s}   > !3tuu'3w/@/@AXAX/Y/d/d/i/i/k+ll .y/B/B.C Da b  	M)MfM''	!)n )) 
	 C(9(9):Q:Q(R(](](b(b(d$ee.y/B/B.C D_ `  	GvGG''	!)n )) 	 3MFMfM''	))    base_seq_lenmax_seq_len
base_shift	max_shiftc                 4    XC-
  X!-
  -  nX5U-  -
  nX-  U-   nU$ Nr   )image_seq_lenr+   r,   r-   r.   mbmus           r(   calculate_shiftr5   ^   s3     
	K$>?A%%A		Q	BIr*   c                    [        U
[        5      (       a*  [        U
5      U:w  a  [        S[        U
5       SU S35      eS[        U R                  R
                  5      S-
  -  nU R                  R                  nS[        U5      US-  -  -  nS[        U5      US-  -  -  nXEXg4n[        XFS-  US-  X5      nUR                  XS9nUR                  S   U:w  a
  [        X*S9nOUnXOR                  S   :  a@  XOR                  S   -  S:X  a+  XOR                  S   -  n[        R                  " U/U-  SS	9nO\XOR                  S   :  a4  XOR                  S   -  S:w  a  [        S
UR                  S    SU S35      e[        R                  " U/SS	9n[        XXS9nUR                  XU5      n[!        UXEXg5      nUU4$ )N/You have passed a list of generators of length +, but requested an effective batch size of @. Make sure the batch size matches the length of the generators.r   r   r   dtype)image	generatorr   dimz'Cannot duplicate `image` of batch size z to z text prompts.r=   r   r;   )
isinstancelistr#   r   configblock_out_channelslatent_channelsint_prepare_latent_image_idstoshape_encode_vae_imagetorchcatr   scale_noise_pack_latents)vaer$   r<   timestep
batch_sizenum_channels_latentsheightwidthr;   r   r=   vae_scale_factorrE   rI   latent_image_idsimage_latentsadditional_image_per_promptnoiselatentss                      r(   prepare_latents_img2imgr[   l   s    )T""s9~'C=c)n=M N"|#ce
 	

 S!>!>?!CDjj00O #f+"2Q"678FU 01 456Ev=E0q[%ST*V\dHHFH0E{{1~()K''**z<O<OPQ<R/RVW/W&04G4G4J&J#		=/4O"OUVW	))!,	,>Q>QRS>T1TXY1Y5m6I6I!6L5MTR\Q]]kl
 	
 		=/q9FPE##MUCGGZvUG$$$r*   encoder_outputr=   sample_modec                    [        U S5      (       a!  US:X  a  U R                  R                  U5      $ [        U S5      (       a   US:X  a  U R                  R                  5       $ [        U S5      (       a  U R                  $ [        S5      e)Nlatent_distsampleargmaxrZ   z3Could not access latents of provided encoder_output)hasattrr_   r`   moderZ   AttributeError)r\   r=   r]   s      r(   retrieve_latentsre      s}     ~}--+2I))00;;		/	/K84K))..00		+	+%%%RSSr*   c                     U R                  XUS-  SUS-  S5      n U R                  SSSSSS5      n U R                  XS-  US-  -  US-  5      n U $ )Nr   r      r   r      )viewpermutereshape)rZ   rQ   rR   rS   rT   s        r(   rN   rN      sc    ll:Vq[!UVWZYZ[GooaAq!Q/GoojQ;5A:*FH\_`H`aGNr*   c                 ,   [         R                  " XS5      nUS   [         R                  " U5      S S 2S 4   -   US'   US   [         R                  " U5      S S S 24   -   US'   UR                  u  pgnUR	                  Xg-  U5      nUR                  X4S9$ )Nr   ).r   ).r   r:   )rK   zerosarangerI   rk   rH   )	rQ   rS   rT   r   r;   rV   latent_image_id_heightlatent_image_id_widthlatent_image_id_channelss	            r(   rG   rG      s    {{6!4/7%,,v:NqRVw:WWV/7%,,u:MdTUg:VVVN^NdNdK3K'//68P f::r*   r<   c                    [        U[        5      (       a\  [        UR                  S   5       Vs/ s H#  n[	        U R                  XUS-    5      X#   S9PM%     nn[        R                  " USS9nO[	        U R                  U5      US9nX@R                  R                  -
  U R                  R                  -  nU$ s  snf )Nr   r   )r=   r>   )rA   rB   rangerI   re   encoderK   rL   rC   shift_factorscaling_factor)rO   r<   r=   irW   s        r(   rJ   rJ      s    )T""\abgbmbmnobp\q
\qWXSZZ!a%(89Y\R\q 	 
 		-Q7(E):iP"ZZ%<%<<

@Y@YYM
s   *B<c
           
         [        U5      U-  S-  [        U5      U-  S-  -  n
Uc  [        R                  " SSU-  U5      OUn[        UR                  S5      (       a  UR                  R
                  (       a  S n[        U
UR                  R                  SS5      UR                  R                  SS5      UR                  R                  S	S
5      UR                  R                  SS5      5      n[        XXUS9u  pU R                  R                  (       a7  [        R                  " S/Xy[        R                  S9nUR                  U5      nOS nXX4$ )Nr   g      ?r   use_flow_sigmasbase_image_seq_len   max_image_seq_len   r-         ?r.   ffffff?)r   r4   r:   )rF   nplinspacerb   rC   ry   r5   getr)   guidance_embedsrK   fullfloat32expand)transformerr$   rQ   rS   rT   rU   r   guidance_scaler   r   r1   r4   r   guidances                 r(   $_get_initial_timesteps_and_optionalsr      s5    [$449c%jL\>\`a>abMOU~R[[a"557JKciFy!233	8H8H8X8X	1370$7\3/[$/
B &8	X^rt%u"I))::qc>V??:.6;;r*   c                       \ rS rSrSr\S\4S j5       r\S\\	   4S j5       r
\S\\   4S j5       rS r\R                  " 5       S\S	\S\4S
 j5       rSrg)FluxInputStep   fluxreturnc                      g)Na  Input processing step that:
  1. Determines `batch_size` and `dtype` based on `prompt_embeds`
  2. Adjusts input tensor shapes based on `batch_size` (number of prompts) and `num_images_per_prompt`

All input tensors are expected to have either batch_size=1 or match the batch_size
of prompt_embeds. The tensors will be duplicated across the batch dimension to
have a final batch_size of batch_size * num_images_per_prompt.r   selfs    r(   descriptionFluxInputStep.description   s    M	
r*   c                 z    [        SSS9[        SS[        R                  SS9[        S[        R                  S	S
9/$ )Nnum_images_per_promptr   defaultprompt_embedsTzGPre-generated text embeddings. Can be generated from text_encoder step.required	type_hintr   pooled_prompt_embedszNPre-generated pooled text embeddings. Can be generated from text_encoder step.r   r   )r   rK   Tensorr   s    r(   inputsFluxInputStep.inputs   sH     .:,,e	 &,,l
 	
r*   c           	          [        S[        SS9[        S[        R                  SS9[        S[        R                  SS9[        S[        R                  S	S9/$ )
NrQ   zdNumber of prompts, the final batch size of model inputs should be batch_size * num_images_per_promptr   r;   z@Data type of model tensor inputs (determined by `prompt_embeds`)r   z2text embeddings used to guide the image generationr   z9pooled text embeddings used to guide the image generation)r   rF   rK   r;   r   r   s    r(   intermediate_outputs"FluxInputStep.intermediate_outputs
  sg      C
 ++^
 ,,P
 &,,W!
 	
r*   c                    UR                   b}  UR                  bo  UR                   R                  S   UR                  R                  S   :w  a:  [        SUR                   R                   SUR                  R                   S35      eg g g )Nr   zx`prompt_embeds` and `pooled_prompt_embeds` must have the same batch size when passed directly, but got: `prompt_embeds` z != `pooled_prompt_embeds` .)r   r   rI   r   )r   
componentsblock_states      r(   check_inputsFluxInputStep.check_inputs$  s    $$0[5U5U5a((..q1[5U5U5[5[\]5^^ --8-F-F-L-L,M N#88>>?qB  _ 6b0r*   r   statec                    U R                  U5      nU R                  X5        UR                  R                  S   Ul        UR                  R
                  Ul        UR                  R                  u  pEnUR                  R                  SUR                  S5      Ul        UR                  R                  UR                  UR                  -  US5      Ul        U R                  X#5        X4$ )Nr   r   )
get_block_stater   r   rI   rQ   r;   repeatr   ri   set_block_state)r   r   r   r   _seq_lens         r(   __call__FluxInputStep.__call__-  s     **51*2!,!:!:!@!@!C'55;;#1177A$/$=$=$D$DQHiHikl$m!$/$=$=$B$B""[%F%FFQS%
! 	U0  r*   r   N)__name__
__module____qualname____firstlineno__
model_namepropertystrr   r   r   r   r   r   rK   no_gradr   r   r   __static_attributes__r   r*   r(   r   r      s    J
S 
 
 
Z( 
 
" 
d3i 
 
2 ]]_!#6 !} !Q^ ! !r*   r   c                       \ rS rSrSr\S\\   4S j5       r\S\	4S j5       r
\S\\   4S j5       r\S\\   4S j5       r\R                   " 5       S\S	\S\4S
 j5       rSrg)FluxSetTimestepsStepi@  r   r   c                 $    [        S[        5      /$ Nr$   r   r
   r   s    r(   expected_components(FluxSetTimestepsStep.expected_componentsC      k+JKLLr*   c                     gNz6Step that sets the scheduler's timesteps for inferencer   r   s    r(   r    FluxSetTimestepsStep.descriptionG      Gr*   c                     [        SSS9[        S5      [        S5      [        SSS9[        S[        R                  S	9[        S
SS9[        S[        S	9[        S[        S	9[        SS[        SS9/	$ )Nr   2   r   r   r   r         @rZ   r   r   r   rS   rT   rQ   TNumber of prompts, the final batch size of model inputs should be `batch_size * num_images_per_prompt`. Can be generated in input step.r   )r   rK   r   rF   r   s    r(   r   FluxSetTimestepsStep.inputsK  sx     ,b9{#x '5yELL9.:x3/w#. f	
 	
r*   c                     [        S[        R                  SS9[        S[        SS9[        S[        R                  SS9/$ )Nr   "The timesteps to use for inferencer   r   :The number of denoising steps to perform at inference timer   Optional guidance to be used.r   rK   r   rF   r   s    r(   r   )FluxSetTimestepsStep.intermediate_outputs^  sC     u||Imn%X
 
ellHgh
 	
r*   r   r   c                    U R                  U5      nUR                  Ul        UR                  nUR                  nUR
                  UR                  -  n[        UUUUR                  UR                  UR                  UR                  UR                  UR                  UR                  5
      u  pxpXsl        Xl        Xl        Xl        U R!                  X#5        X4$ r0   )r   _execution_devicer   r$   r   rQ   r   r   rS   rT   rU   r   r   r   r   r   r   r   r   r   r   r$   r   rQ   r   r   r   r   s              r(   r   FluxSetTimestepsStep.__call__j  s    **51'99((	 ,, ++k.O.OO
;_''++&&<
8	 !**='#'U0  r*   r   N)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rK   r   r   r   r   r   r   r*   r(   r   r   @  s    JMT-%8 M M HS H H 
Z( 
 
$ 	
d;&7 	
 	
 ]]_!#6 !} !Q^ ! !r*   r   c                       \ rS rSrSr\S\\   4S j5       r\S\	4S j5       r
\S\\   4S j5       r\S\\   4S j5       r\S 5       r\R$                  " 5       S	\S
\S\4S j5       rSrg)FluxImg2ImgSetTimestepsStepi  r   r   c                 $    [        S[        5      /$ r   r   r   s    r(   r   /FluxImg2ImgSetTimestepsStep.expected_components  r   r*   c                     gr   r   r   s    r(   r   'FluxImg2ImgSetTimestepsStep.description  r   r*   c                     [        SSS9[        S5      [        S5      [        SSS9[        SS	S9[        S
SS9[        S[        S9[        S[        S9[        SS[        SS9/	$ )Nr   r   r   r   r   strengthg333333?r   r   r   r   rS   r   rT   rQ   Tr   r   )r   rF   r   s    r(   r   "FluxImg2ImgSetTimestepsStep.inputs  st     ,b9{#x z3/'5.:x3/w#. f	
 	
r*   c           	          [        S[        R                  SS9[        S[        SS9[        S[        R                  SS9[        S[        R                  S	S9/$ )
Nr   r   r   r   r   latent_timestepzRThe timestep that represents the initial noise level for image-to-image generationr   r   r   r   s    r(   r   0FluxImg2ImgSetTimestepsStep.intermediate_outputs  sZ     u||Imn%X
 !,,p
 
ellHgh
 	
r*   c                     [        X-  U5      n[        [        X-
  S5      5      nU R                  XPR                  -  S  n[        U S5      (       a  U R                  XPR                  -  5        XaU-
  4$ )Nr   set_begin_index)minrF   maxr   orderrb   r   )r$   r   r   r   init_timestept_startr   s          r(   get_timesteps)FluxImg2ImgSetTimestepsStep.get_timesteps  su     /:<OPc-=qAB''//(A(CD	9/00%%g&?@777r*   r   r   c                 >   U R                  U5      nUR                  Ul        UR                  nUR                  nUR
                  UR                  -  n[        UUUUR                  UR                  UR                  UR                  UR                  UR                  UR                  5
      u  pxpU R                  XHUR                  UR                  5      u  pxXsl        Xl        Xl        Xl        US S R%                  U5      Ul        U R)                  X#5        X4$ )Nr   )r   r   r   r$   r   rQ   r   r   rS   rT   rU   r   r   r   r   r   r   r   r   r   r   r   s              r(   r   $FluxImg2ImgSetTimestepsStep.__call__  s   **51'99((	 ,, ++k.O.OO
;_''++&&<
8	 *.););K,@,@+BTBT*
&	 !**='#'&/m&:&::&F#U0  r*   r   N)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   staticmethodr   rK   r   r   r   r   r   r   r*   r(   r   r     s    JMT-%8 M M HS H H 
Z( 
 
$ 
d;&7 
 
  	8 	8 ]]_!#6 !} !Q^ ! !r*   r   c                       \ rS rSrSr\S\\   4S j5       r\S\	4S j5       r
\S\\   4S j5       r\S\\   4S j5       r\S 5       r\ SS
 j5       r\R&                  " 5       S\S\S\4S j5       rSrg	)FluxPrepareLatentsStepi  r   r   c                     / $ r0   r   r   s    r(   r   *FluxPrepareLatentsStep.expected_components  s    	r*   c                     g)NzWPrepare latents step that prepares the latents for the text-to-image generation processr   r   s    r(   r   "FluxPrepareLatentsStep.description  s    hr*   c                     [        S[        S9[        S[        S9[        S[        [        R                     S9[        S[        SS9[        S5      [        S	S
[        SS9[        S[        R
                  SS9/$ )NrS   r   rT   rZ   r   r   r   r   r=   rQ   Tr   r   r;   The dtype of the model inputsr   r   rF   r   rK   r   r;   r   s    r(   r   FluxPrepareLatentsStep.inputs  st     x3/w#.yHU\\,BC.#qI{# f	 w%++Cbc
 	
r*   c                 f    [        S[        R                  SS9[        S[        R                  SS9/$ NrZ   z4The initial latents to use for the denoising processr   rV   z4IDs computed from the image sequence needed for RoPEr   rK   r   r   s    r(   r   +FluxPrepareLatentsStep.intermediate_outputs  9     U\\?u ",,R		
 		
r*   c           	      6   UR                   b   UR                   U R                  S-  -  S:w  d-  UR                  b_  UR                  U R                  S-  -  S:w  a>  [        R	                  SU R                   SUR                    SUR                   S35        g g g )Nr   r   z-`height` and `width` have to be divisible by z	 but are z and r   )rS   rU   rT   loggerwarning)r   r   s     r(   r   #FluxPrepareLatentsStep.check_inputs  s    *{/A/AZE`E`cdEd/eij/j)k.?.?:C^C^abCb.cgh.hNN?
@[@[?\\efqfxfxeyy~  @K  @Q  @Q  R  RS  T /i)r*   Nc	                    S[        U5      U R                  S-  -  -  nS[        U5      U R                  S-  -  -  nXX44n	Ub$  [        XS-  US-  Xe5      n
UR                  XeS9U
4$ [	        U[
        5      (       a*  [        U5      U:w  a  [        S[        U5       SU S35      e[        XXeS9n[        XX#U5      n[        XS-  US-  Xe5      n
X4$ )Nr   r:   r7   r8   r9   r@   )
rF   rU   rG   rH   rA   rB   r#   r   r   rN   )comprQ   rR   rS   rT   r;   r   r=   rZ   rI   rV   s              r(   prepare_latents&FluxPrepareLatentsStep.prepare_latents  s   $ c&kd&;&;a&?@ASZD$9$9A$=>?6A8q[RW[\R\^dl::V:9;KKKi&&3y>Z+GA#i.AQ R&<'gi 
 u&V5ISXY4Z1eWXjZ`h((r*   r   r   c                 v   U R                  U5      nUR                  =(       d    UR                  Ul        UR                  =(       d    UR                  Ul        UR
                  Ul        [        R                  Ul	        UR                  Ul
        U R                  X5        UR                  UR                  -  nU R                  UUUR                  UR                  UR                  UR                  UR                  UR                  UR                   5	      u  Ul        Ul        U R%                  X#5        X4$ r0   )r   rS   default_heightrT   default_widthr   r   rK   bfloat16r;   rR   r   rQ   r   r  r=   rZ   rV   r   r   r   r   r   rQ   s        r(   r   FluxPrepareLatentsStep.__call__@  s	   **51(//L:3L3L'--I1I1I'99!NN+5+J+J(*2 ++k.O.OO
<@<P<P,,!!
=
9[9 	U0  r*   r   r0   )r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rK   r   r   r   r   r   r   r*   r(   r   r     s    JT-%8   iS i i 
Z( 
 
  

d;&7 

 

    %) %)N ]]_!#6 !} !Q^ ! !r*   r   c                       \ rS rSrSr\S\\   4S j5       r\S\	4S j5       r
\S\\\	\4      4S j5       r\S\\   4S j5       r\R"                  " 5       S\S	\S\4S
 j5       rSrg)FluxImg2ImgPrepareLatentsStepi]  r   r   c                 B    [        S[        5      [        S[        5      /$ )NrO   r$   )r   r	   r
   r   s    r(   r   1FluxImg2ImgPrepareLatentsStep.expected_components`  s    e]3];Po5pqqr*   c                     g)NzHStep that prepares the latents for the image-to-image generation processr   r   s    r(   r   )FluxImg2ImgPrepareLatentsStep.descriptiond  s    Yr*   c                 Z   [        S[        S9[        S[        S9[        S[        [        R                     S9[        S[        SS9[        S5      [        S	S
[        R                  SS9[        SS
[        R                  SS9[        SS
[        SS9[        SS
[        R
                  SS9/	$ )NrS   r   rT   rZ   r   r   r   r=   rW   Tz{The latents representing the reference image for image-to-image/inpainting generation. Can be generated in vae_encode step.r   r   zThe timestep that represents the initial noise level for image-to-image/inpainting generation. Can be generated in set_timesteps step.rQ   zNumber of prompts, the final batch size of model inputs should be batch_size * num_images_per_prompt. Can be generated in input step.r;   r   r   r   s    r(   r   $FluxImg2ImgPrepareLatentsStep.inputsh  s     x3/w#.yHU\\,BC.#qI{#,, Z	 !,, e	  d	 wRqr1
 	
r*   c                 f    [        S[        R                  SS9[        S[        R                  SS9/$ r   r   r   s    r(   r   2FluxImg2ImgPrepareLatentsStep.intermediate_outputs  r  r*   r   r   c                 ,   U R                  U5      nUR                  =(       d    UR                  Ul        UR                  =(       d    UR                  Ul        UR
                  Ul        [        R                  Ul	        UR                  Ul
        UR                  b  UR                  OUR                  R                  Ul	        UR
                  Ul        UR                  UR                  -  nUR                  c  [        UR                  UR                   UR"                  UR$                  UUR                  UR                  UR                  UR                  UR                  UR&                  5      u  Ul        Ul        U R+                  X#5        X4$ r0   )r   rS   r  rT   r  r   r   rK   r  r;   rR   rO   rQ   r   rZ   r[   r$   rW   r   r=   rV   r   r  s        r(   r   &FluxImg2ImgPrepareLatentsStep.__call__  sP   **51(//L:3L3L'--I1I1I'99!NN+5+J+J(1<1B1B1NK--T^TbTbThTh'99 !++k.O.OO
&@W$$))++00""!!!!""%%A=K!= 	U0  r*   r   N)r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rK   r   r   r   r   r   r   r*   r(   r  r  ]  s    JrT-%8 r r ZS Z Z 
U38_- 
 
8 

d;&7 

 

 ]]_!#6 !} !Q^ ! !r*   r  )NNNN)r{   r}   r~   r   )Nr`   )0r   typingr   r   r   r   r   numpyr   rK   modelsr	   
schedulersr
   utilsr   utils.torch_utilsr   modular_pipeliner   r   modular_pipeline_utilsr   r   r   r   
get_loggerr   r  rF   r   r   floatr)   r5   r[   r   	Generatorre   rN   rG   rJ   r   r   r   r   r   r  r   r*   r(   <module>r'     s    4 4   # 9  - C K K 1 
		H	% *.15%)$(8*!#8* U3,-.8* S	"	8*
 T%[!8*| 

 
 	

 
&%V ck
TLL
T-5eoo-F
T\_
T;%,, 5?? <DS!) S!lE!0 E!P[!"7 [!|t!2 t!nT!$9 T!r*   