
    qig              	          d Z ddlZddlZddlmZ ddlmZ ddlmZmZ ddl	m
Z
 ddlmZmZ d	d
lmZ  ej                   e      Zd5dej&                  dededej&                  fdZ G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d dej.                        Z G d  d!ej.                        Z e G d" d#e
             Z!e G d$ d%e!             Z" G d& d'ej.                        Z# G d( d)ej.                        Z$ G d* d+ej.                        Z% G d, d-ej.                        Z& G d. d/ej.                        Z' ed01       G d2 d3e!             Z(g d4Z)y)6zPyTorch GLPN model.    N)nn   )ACT2FN)BaseModelOutputDepthEstimatorOutput)PreTrainedModel)auto_docstringlogging   )
GLPNConfiginput	drop_probtrainingreturnc                    |dk(  s|s| S d|z
  }| j                   d   fd| j                  dz
  z  z   }|t        j                  || j                  | j
                        z   }|j                          | j                  |      |z  }|S )zc
    Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).

            r   r   )r   )dtypedevice)shapendimtorchrandr   r   floor_div)r   r   r   	keep_probr   random_tensoroutputs          X/opt/pipecat/venv/lib/python3.12/site-packages/transformers/models/glpn/modeling_glpn.py	drop_pathr       s    
 CxII[[^

Q 77E

5ELL YYMYYy!M1FM    c                   x     e Zd ZdZd	dedz  ddf fdZdej                  dej                  fdZde	fdZ
 xZS )
GLPNDropPathzXDrop paths (Stochastic Depth) per sample (when applied in main path of residual blocks).Nr   r   c                 0    t         |           || _        y N)super__init__r   )selfr   	__class__s     r   r&   zGLPNDropPath.__init__3   s    "r    hidden_statesc                 D    t        || j                  | j                        S r$   )r   r   r   )r'   r)   s     r   forwardzGLPNDropPath.forward7   s    FFr    c                      d| j                    S )Nzp=)r   )r'   s    r   
extra_reprzGLPNDropPath.extra_repr:   s    DNN#$$r    r$   )__name__
__module____qualname____doc__floatr&   r   Tensorr+   strr-   __classcell__r(   s   @r   r"   r"   0   sG    b#%$, #$ #GU\\ Gell G%C %r    r"   c                   (     e Zd ZdZ fdZd Z xZS )GLPNOverlapPatchEmbeddingsz+Construct the overlapping patch embeddings.c                     t         |           t        j                  |||||dz        | _        t        j
                  |      | _        y )N   kernel_sizestridepadding)r%   r&   r   Conv2dproj	LayerNorm
layer_norm)r'   
patch_sizer=   num_channelshidden_sizer(   s        r   r&   z#GLPNOverlapPatchEmbeddings.__init__B   sC    II"!O
	 ,,{3r    c                     | j                  |      }|j                  \  }}}}|j                  d      j                  dd      }| j	                  |      }|||fS )Nr:   r   )r@   r   flatten	transposerB   )r'   pixel_values
embeddings_heightwidths         r   r+   z"GLPNOverlapPatchEmbeddings.forwardN   s^    YY|,
(..1fe  ''*44Q:
__Z0
65((r    r.   r/   r0   r1   r&   r+   r5   r6   s   @r   r8   r8   ?   s    5
4)r    r8   c                   ,     e Zd ZdZ fdZ	 ddZ xZS )GLPNEfficientSelfAttentionzSegFormer's efficient self-attention mechanism. Employs the sequence reduction process introduced in the [PvT
    paper](https://huggingface.co/papers/2102.12122).c                 8   t         |           || _        || _        | j                  | j                  z  dk7  r&t	        d| j                   d| j                   d      t        | j                  | j                  z        | _        | j                  | j                  z  | _        t        j                  | j                  | j                        | _
        t        j                  | j                  | j                        | _        t        j                  | j                  | j                        | _        t        j                  |j                        | _        || _        |dkD  r9t        j"                  ||||      | _        t        j&                  |      | _        y y )Nr   zThe hidden size (z6) is not a multiple of the number of attention heads ()r   )r<   r=   )r%   r&   rE   num_attention_heads
ValueErrorintattention_head_sizeall_head_sizer   LinearquerykeyvalueDropoutattention_probs_dropout_probdropoutsr_ratior?   srrA   rB   r'   configrE   rS   sequence_reduction_ratior(   s        r   r&   z#GLPNEfficientSelfAttention.__init__]   sT   &#6 d666!;#D$4$4#5 622316 
 $'t'7'7$:R:R'R#S !558P8PPYYt//1C1CD
99T--t/A/ABYYt//1C1CD
zz&"E"EF0#a'ii[6NWoDG !ll;7DO	 (r    c                    |j                   \  }}}| j                  |      j                  |d| j                  | j                        j                  dd      }| j                  dkD  r{|j                   \  }}	}
|j                  ddd      j                  ||
||      }| j                  |      }|j                  ||
d      j                  ddd      }| j                  |      }| j                  |      j                  |d| j                  | j                        j                  dd      }| j                  |      j                  |d| j                  | j                        j                  dd      }t        j                  ||j                  dd            }|t        j                   | j                        z  }t"        j$                  j'                  |d      }| j)                  |      }t        j                  ||      }|j                  dddd      j+                         }|j-                         d d | j.                  fz   }|j                  |      }|r||f}|S |f}|S )Nr   r:   r   dimr   )r   rY   viewrS   rV   rH   r_   permutereshaper`   rB   rZ   r[   r   matmulmathsqrtr   
functionalsoftmaxr^   
contiguoussizerW   )r'   r)   rL   rM   output_attentions
batch_size
seq_lengthrK   query_layerseq_lenrD   	key_layervalue_layerattention_scoresattention_probscontext_layernew_context_layer_shapeoutputss                     r   r+   z"GLPNEfficientSelfAttention.forwardx   s7    %2$7$7!
JJJ}%T*b$":":D<T<TUYq!_ 	 ==10=0C0C-J)11!Q:BB:|]cejkM GGM2M)11*lBOWWXY[\^_`M OOM:M HH]#T*b$":":D<T<TUYq!_ 	 JJ}%T*b$":":D<T<TUYq!_ 	 !<<Y5H5HR5PQ+dii8P8P.QQ --//0@b/I ,,7_kB%--aAq9DDF"/"4"4"6s";t?Q?Q>S"S%**+BC6G=/2 O\M]r    FrN   r6   s   @r   rP   rP   Y   s    98@  7r    rP   c                   $     e Zd Z fdZd Z xZS )GLPNSelfOutputc                     t         |           t        j                  ||      | _        t        j
                  |j                        | _        y r$   )r%   r&   r   rX   denser\   hidden_dropout_probr^   )r'   rb   rE   r(   s      r   r&   zGLPNSelfOutput.__init__   s6    YY{K8
zz&"<"<=r    c                 J    | j                  |      }| j                  |      }|S r$   )r   r^   )r'   r)   input_tensors      r   r+   zGLPNSelfOutput.forward   s$    

=1]3r    r.   r/   r0   r&   r+   r5   r6   s   @r   r   r      s    >
r    r   c                   &     e Zd Z fdZddZ xZS )GLPNAttentionc                 n    t         |           t        ||||      | _        t	        ||      | _        y )N)rb   rE   rS   rc   )rE   )r%   r&   rP   r'   r   r   ra   s        r   r&   zGLPNAttention.__init__   s6    .# 3%=	
	 %VEr    c                 j    | j                  ||||      }| j                  |d   |      }|f|dd  z   }|S )Nr   r   )r'   r   )r'   r)   rL   rM   rs   self_outputsattention_outputr~   s           r   r+   zGLPNAttention.forward   sE    yy?PQ;;|AF#%QR(88r    r   r   r6   s   @r   r   r      s    Fr    r   c                   &     e Zd Zd fd	Zd Z xZS )
GLPNDWConvc           	      d    t         |           t        j                  ||dddd|      | _        y )Nr   r   T)biasgroups)r%   r&   r   r?   dwconv)r'   rh   r(   s     r   r&   zGLPNDWConv.__init__   s*    iiS!QSIr    c                     |j                   \  }}}|j                  dd      j                  ||||      }| j                  |      }|j	                  d      j                  dd      }|S )Nr   r:   )r   rH   ri   r   rG   )r'   r)   rL   rM   rt   rw   rD   s          r   r+   zGLPNDWConv.forward   sj    ,9,?,?)
G\%//15:::|U[]bcM2%--a0::1a@r    )i   r   r6   s   @r   r   r      s    Jr    r   c                   &     e Zd Zd fd	Zd Z xZS )
GLPNMixFFNc                    t         |           |xs |}t        j                  ||      | _        t        |      | _        t        |j                  t              rt        |j                     | _        n|j                  | _        t        j                  ||      | _        t        j                  |j                        | _        y r$   )r%   r&   r   rX   dense1r   r   
isinstance
hidden_actr4   r   intermediate_act_fndense2r\   r   r^   )r'   rb   in_featureshidden_featuresout_featuresr(   s        r   r&   zGLPNMixFFN.__init__   s    #2{ii_= 1f''-'-f.?.?'@D$'-'8'8D$ii>zz&"<"<=r    c                     | j                  |      }| j                  |||      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }|S r$   )r   r   r   r^   r   )r'   r)   rL   rM   s       r   r+   zGLPNMixFFN.forward   sb    M2M65A00?]3M2]3r    )NNr   r6   s   @r   r   r      s    
>r    r   c                   *     e Zd ZdZ fdZddZ xZS )	GLPNLayerzCThis corresponds to the Block class in the original implementation.c                 F   t         |           t        j                  |      | _        t        ||||      | _        |dkD  rt        |      nt        j                         | _	        t        j                  |      | _
        t        ||z        }t        |||      | _        y )N)rE   rS   rc   r   )r   r   )r%   r&   r   rA   layer_norm_1r   	attentionr"   Identityr   layer_norm_2rU   r   mlp)	r'   rb   rE   rS   r   rc   	mlp_ratiomlp_hidden_sizer(   s	           r   r&   zGLPNLayer.__init__   s    LL5&# 3%=	
 5>Oi0LL5kI56f+_r    c                 
   | j                  | j                  |      |||      }|d   }|dd  }| j                  |      }||z   }| j                  | j	                  |      ||      }| j                  |      }||z   }	|	f|z   }|S )N)rs   r   r   )r   r   r   r   r   )
r'   r)   rL   rM   rs   self_attention_outputsr   r~   
mlp_outputlayer_outputs
             r   r+   zGLPNLayer.forward  s    !%m,/	 "0 "
 2!4(,  >>*:;(=8XXd//>N
 ^^J/
!M1/G+r    r   rN   r6   s   @r   r   r      s    M`r    r   c                   ,     e Zd Z fdZ	 	 	 ddZ xZS )GLPNEncoderc                    t         
|           || _        t        j                  d|j
                  t        |j                        d      D cg c]  }|j                          }}g }t        |j                        D ]h  }|j                  t        |j                  |   |j                  |   |dk(  r|j                  n|j                   |dz
     |j                   |                j t#        j$                  |      | _        g }d}t        |j                        D ]  }g }|dk7  r||j                  |dz
     z  }t        |j                  |         D ]\  }	|j                  t)        ||j                   |   |j*                  |   |||	z      |j,                  |   |j.                  |                ^ |j                  t#        j$                  |              t#        j$                  |      | _        t#        j$                  t        |j                        D cg c]$  }t#        j2                  |j                   |         & c}      | _        y c c}w c c}w )Nr   cpu)r   r   )rC   r=   rD   rE   )rE   rS   r   rc   r   )r%   r&   rb   r   linspacedrop_path_ratesumdepthsitemrangenum_encoder_blocksappendr8   patch_sizesstridesrD   hidden_sizesr   
ModuleListpatch_embeddingsr   rS   	sr_ratios
mlp_ratiosblockrA   rB   )r'   rb   xdprrJ   iblockscurlayersjr(   s             r   r&   zGLPNEncoder.__init__'  s    "'63H3H#fmmJ\ej!klAqvvxll 
v001 	A*%11!4!>>!,89Q!4!4FDWDWXY\]X]D^ & 3 3A 6		 !#j 9 v001 	1AFAvv}}QU++6==+, 
$*$7$7$:,2,F,Fq,I"%cAg,171A1A!1D"("3"3A"6	
 MM"--/0!	1$ ]]6*
 --;@AZAZ;[\aR\\&--a01\
O mP ]s   I)Ic                 
   |rdnd }|rdnd }|j                   d   }|}t        t        | j                  | j                  | j
                              D ]  \  }	}
|
\  }}} ||      \  }}}t        |      D ]!  \  }} |||||      }|d   }|s||d   fz   }#  ||      }|j                  |||d      j                  dddd      j                         }|s||fz   } |st        d |||fD              S t        |||      S )	N r   r   re   r   r:   c              3   &   K   | ]	  }||  y wr$   r   ).0vs     r   	<genexpr>z&GLPNEncoder.forward.<locals>.<genexpr>v  s     mq_`_lms   last_hidden_stater)   
attentions)r   	enumeratezipr   r   rB   rk   rj   rq   tupler   )r'   rI   rs   output_hidden_statesreturn_dictall_hidden_statesall_self_attentionsrt   r)   idxr   embedding_layerblock_layer
norm_layerrL   rM   r   blklayer_outputss                      r   r+   zGLPNEncoder.forwardW  sL    #7BD$5b4!''*
$D$9$94::t WX 	IFC784O[*+:=+I(M65#K0 T3 #M65BS T -a 0$*=qAQ@S*S'	T '}5M)11*feRPXXYZ\]_`bcdooqM#$58H$H!	I" m]4EGZ$[mmm++*
 	
r    )FFTr   r6   s   @r   r   r   &  s    .
f  "$
r    r   c                   (    e Zd ZU eed<   dZdZdZg Zy)GLPNPreTrainedModelrb   glpnrI   )imageN)	r.   r/   r0   r   __annotations__base_model_prefixmain_input_nameinput_modalities_no_split_modulesr   r    r   r   r   ~  s    $O!r    r   c                   x     e Zd Z fdZe	 	 	 d	dej                  dedz  dedz  dedz  dee	z  f
d       Z
 xZS )
	GLPNModelc                 r    t         |   |       || _        t        |      | _        | j                          y r$   )r%   r&   rb   r   encoder	post_initr'   rb   r(   s     r   r&   zGLPNModel.__init__  s1      #6* 	r    NrI   rs   r   r   r   c                 ,   ||n| j                   j                  }||n| j                   j                  }||n| j                   j                  }| j	                  ||||      }|d   }|s	|f|dd  z   S t        ||j                  |j                        S )Nrs   r   r   r   r   r   )rb   rs   r   use_return_dictr   r   r)   r   )r'   rI   rs   r   r   kwargsencoder_outputssequence_outputs           r   r+   zGLPNModel.forward  s     2C1N-TXT_T_TqTq$8$D $++JjJj 	 &1%<k$++B]B],,/!5#	 ' 
 *!,#%(;;;-)77&11
 	
r    )NNN)r.   r/   r0   r&   r	   r   FloatTensorboolr   r   r+   r5   r6   s   @r   r   r     sn     
 *.,0#'
''
  $;
 #Tk	

 D[
 
	 
 
r    r   c                   *     e Zd ZdZd fd	Zd Z xZS )GLPNSelectiveFeatureFusionz
    Selective Feature Fusion module, as explained in the [paper](https://huggingface.co/papers/2201.07436) (section 3.4). This
    module adaptively selects and integrates local and global features by attaining an attention map for each feature.
    c           	      V   t         |           t        j                  t        j                  t        |dz        |ddd      t        j                  |      t        j                               | _        t        j                  t        j                  |t        |dz        ddd      t        j                  t        |dz              t        j                               | _	        t        j                  t        |dz        dddd      | _
        t        j                         | _        y )Nr:   r   r   )in_channelsout_channelsr<   r=   r>   )r%   r&   r   
Sequentialr?   rU   BatchNorm2dReLUconvolutional_layer1convolutional_layer2convolutional_layer3Sigmoidsigmoid)r'   
in_channelr(   s     r   r&   z#GLPNSelectiveFeatureFusion.__init__  s    $&MMII#j1n"5J\]fgqrsNN:&GGI%
! %'MMII*3zA~;N\]fgqrsNN3zA~./GGI%
! %'IIJN+!ST^_%
! zz|r    c                 F   t        j                  ||fd      }| j                  |      }| j                  |      }| j	                  |      }| j                  |      }||d d dd d d d f   j                  d      z  ||d d dd d d d f   j                  d      z  z   }|S )Nr   rg   r   )r   catr   r   r  r  	unsqueeze)r'   local_featuresglobal_featuresfeaturesattnhybrid_featuress         r   r+   z"GLPNSelectiveFeatureFusion.forward  s    99no>AF,,X6,,X6,,X6||H%(41a
+;+E+Ea+HH?]aq!QJ^

)A,L  r    )@   rN   r6   s   @r   r   r     s    
$*r    r   c                   &     e Zd Z fdZddZ xZS )GLPNDecoderStagec                     t         |           ||k(  }|st        j                  ||d      nt        j                         | _        t        |      | _        t        j                  ddd      | _	        y )Nr   )r<   r:   bilinearFscale_factormodealign_corners)
r%   r&   r   r?   r   convolutionr   fusionUpsampleupsample)r'   r   r   should_skipr(   s       r   r&   zGLPNDecoderStage.__init__  s\    !\1Va299[,ANgigrgrgt0>SXYr    c                 r    | j                  |      }|| j                  ||      }| j                  |      }|S r$   )r  r  r  )r'   hidden_stateresiduals      r   r+   zGLPNDecoderStage.forward  s<    ''5;;|X>L}}\2r    r$   r   r6   s   @r   r  r    s    Z	r    r  c                   b     e Zd Z fdZdeej                     deej                     fdZ xZS )GLPNDecoderc           	      .   t         |           |j                  d d d   }|j                  }t	        j
                  |D cg c]  }t        ||       c}      | _        d | j                  d   _        t	        j                  ddd      | _
        y c c}w )Nre   r   r:   r  Fr  )r%   r&   r   decoder_hidden_sizer   r   r  stagesr  r  final_upsample)r'   rb   reserved_hidden_sizesr   rE   r(   s        r   r&   zGLPNDecoder.__init__  s     & 3 3DbD 911mmLab[k<8b
 !%A kkqzY^_ cs   Br)   r   c                     g }d }t        |d d d   | j                        D ]  \  }} |||      }|j                  |       ! | j                  |      |d<   |S )Nre   )r   r"  r   r#  )r'   r)   stage_hidden_statesstage_hidden_stater  stages         r   r+   zGLPNDecoder.forward  sr     !#&}TrT':DKK#H 	;L%!&|5G!H&&'9:	; #'"5"56H"IB""r    	r.   r/   r0   r&   listr   r3   r+   r5   r6   s   @r   r  r    s.    `	#T%,,%7 	#D<N 	#r    r  c                   *     e Zd ZdZd fd	Zd Z xZS )	SiLogLossz
    Implements the Scale-invariant log scale loss [Eigen et al., 2014](https://huggingface.co/papers/1406.2283).

    $$L=\frac{1}{n} \sum_{i} d_{i}^{2}-\frac{1}{2 n^{2}}\left(\sum_{i} d_{i}^{2}\right)$$ where $d_{i}=\log y_{i}-\log
    y_{i}^{*}$.

    c                 0    t         |           || _        y r$   )r%   r&   lambd)r'   r.  r(   s     r   r&   zSiLogLoss.__init__  s    
r    c                 `   |dkD  j                         }t        j                  ||         t        j                  ||         z
  }t        j                  t        j                  |d      j                         | j                  t        j                  |j                         d      z  z
        }|S )Nr   r:   )detachr   logrn   powmeanr.  )r'   predtarget
valid_maskdiff_loglosss         r   r+   zSiLogLoss.forward  s    qj((*
99VJ/0599T*=M3NNzz%))Ha0557$**uyyQYQ^Q^Q`bcGd:dder    )g      ?rN   r6   s   @r   r,  r,    s    r    r,  c                   \     e Zd Z fdZdeej                     dej                  fdZ xZS )GLPNDepthEstimationHeadc                    t         |           || _        |j                  }t	        j
                  t	        j                  ||ddd      t	        j                  d      t	        j                  |dddd            | _        y )Nr   r   r;   F)inplace)	r%   r&   rb   r!  r   r   r?   r   head)r'   rb   channelsr(   s      r   r&   z GLPNDepthEstimationHead.__init__'  sd    --MMIIha1MGGE"IIhqAF
	r    r)   r   c                     || j                   j                     }| j                  |      }t        j                  |      | j                   j
                  z  }|j                  d      }|S )Nr   rg   )rb   head_in_indexr=  r   r  	max_depthsqueeze)r'   r)   predicted_depths      r   r+   zGLPNDepthEstimationHead.forward3  sZ    %dkk&?&?@		-0--69N9NN)11a18r    r)  r6   s   @r   r:  r:  &  s(    

	T%,,%7 	ELL 	r    r:  zg
    GLPN Model transformer with a lightweight depth estimation head on top e.g. for KITTI, NYUv2.
    )custom_introc                        e Zd Z fdZe	 	 	 	 d
dej                  dej                  dz  dedz  dedz  dedz  deej                     e
z  fd	       Z xZS )GLPNForDepthEstimationc                     t         |   |       t        |      | _        t	        |      | _        t        |      | _        | j                          y r$   )	r%   r&   r   r   r  decoderr:  r=  r   r   s     r   r&   zGLPNForDepthEstimation.__init__E  s@     f%	"6*+F3	 	r    NrI   labelsrs   r   r   r   c                    ||n| j                   j                  }||n| j                   j                  }| j                  ||d|      }|r|j                  n|d   }| j                  |      }	| j                  |	      }
d}|t               } ||
|      }|s|r
|
f|dd z   }n	|
f|dd z   }||f|z   S |S t        ||
|r|j                  nd|j                        S )a  
        labels (`torch.FloatTensor` of shape `(batch_size, height, width)`, *optional*):
            Ground truth depth estimation maps for computing the loss.

        Examples:

        ```python
        >>> from transformers import AutoImageProcessor, GLPNForDepthEstimation
        >>> import torch
        >>> import numpy as np
        >>> from PIL import Image
        >>> import httpx
        >>> from io import BytesIO

        >>> url = "http://images.cocodataset.org/val2017/000000039769.jpg"
        >>> with httpx.stream("GET", url) as response:
        ...     image = Image.open(BytesIO(response.read()))

        >>> image_processor = AutoImageProcessor.from_pretrained("vinvino02/glpn-kitti")
        >>> model = GLPNForDepthEstimation.from_pretrained("vinvino02/glpn-kitti")

        >>> # prepare image for the model
        >>> inputs = image_processor(images=image, return_tensors="pt")

        >>> with torch.no_grad():
        ...     outputs = model(**inputs)

        >>> # interpolate to original size
        >>> post_processed_output = image_processor.post_process_depth_estimation(
        ...     outputs,
        ...     target_sizes=[(image.height, image.width)],
        ... )

        >>> # visualize the prediction
        >>> predicted_depth = post_processed_output[0]["predicted_depth"]
        >>> depth = predicted_depth * 255 / predicted_depth.max()
        >>> depth = depth.detach().cpu().numpy()
        >>> depth = Image.fromarray(depth.astype("uint8"))
        ```NTr   r   r:   )r8  rC  r)   r   )
rb   r   r   r   r)   rH  r=  r,  r   r   )r'   rI   rI  rs   r   r   r   r~   r)   outrC  r8  loss_fctr   s                 r   r+   zGLPNForDepthEstimation.forwardO  s   b &1%<k$++B]B]$8$D $++JjJj 	 ))/!%#	  
 2=--'!*ll=)))C. {HOV4D#)+gabk9)+gabk9)-)9TGf$EvE#+3G'//T))	
 	
r    )NNNN)r.   r/   r0   r&   r	   r   r   r   r   r3   r   r+   r5   r6   s   @r   rF  rF  ?  s      ,0)-,0#'R
''R
 !!D(R
  $;	R

 #TkR
 D[R
 
u||	3	3R
 R
r    rF  )rF  r   r   r   )r   F)*r1   rm   r   r   activationsr   modeling_outputsr   r   modeling_utilsr   utilsr	   r
   configuration_glpnr   
get_loggerr.   loggerr3   r2   r   r   Moduler"   r8   rP   r   r   r   r   r   r   r   r   r   r  r  r,  r:  rF  __all__r   r    r   <module>rV     s       ! E - , * 
		H	%U\\ e T V[VbVb  %299 %) )4V Vt	RYY 	BII (  0(		 (VU
")) U
p /   +
# +
 +
\) )Xryy (#")) #6		 *bii 2 
^
0 ^

^
B Vr    