HEX
Server: Apache/2.4.52 (Ubuntu)
System: Linux spn-python 5.15.0-89-generic #99-Ubuntu SMP Mon Oct 30 20:42:41 UTC 2023 x86_64
User: arjun (1000)
PHP: 8.1.2-1ubuntu2.20
Disabled: NONE
Upload Files
File: //snap/certbot/4965/lib/python3.12/site-packages/pycparser/__pycache__/c_generator.cpython-312.pyc
�

M�hlE��&�ddlmZGd�de�Zy)�)�c_astc��eZdZdZd^d�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zid
d�dd�dd�dd�dd�dd�dd�dd�dd�dd�dd�dd �d!d �d"d#�d$d#�d%d&�d'd&�d(d&i�Zd)�Zd*�Zd+�Zd,�Zd^d-�Zd.�Zd/�Zd0�Zd1�Zd2�Zd3�Zd4�Zd5�Zd6�Zd7�Zd8�Zd9�Z d:�Z!d;�Z"d<�Z#d=�Z$d>�Z%d?�Z&d@�Z'dA�Z(dB�Z)dC�Z*dD�Z+dE�Z,dF�Z-dG�Z.dH�Z/dI�Z0dJ�Z1dK�Z2dL�Z3dM�Z4dN�Z5dO�Z6dP�Z7dQ�Z8dR�Z9dS�Z:dT�Z;dU�Z<d^dV�Z=dW�Z>gdXfdY�Z?dZ�Z@d[�ZAd\�ZBy])_�
CGeneratorz� Uses the same visitor pattern as c_ast.NodeVisitor, but modified to
        return a value from each visit method, using string accumulation in
        generic_visit.
    c� �d|_||_y)z� Constructs C-code generator

            reduce_parentheses:
                if True, eliminates needless parentheses on binary operators
        �N)�indent_level�reduce_parentheses)�selfr	s  ��/build/snapcraft-certbot-c9561b03ef7f16aa90eb6754ca5f17a1/parts/certbot/install/lib/python3.12/site-packages/pycparser/c_generator.py�__init__zCGenerator.__init__s�����"4���c� �d|jzS�N� )r)r
s r�_make_indentzCGenerator._make_indents���T�&�&�&�&r
c�n�d|jjz}t|||j�|�S)N�visit_)�	__class__�__name__�getattr�
generic_visit)r
�node�methods   r�visitzCGenerator.visits2���D�N�N�3�3�3��8�w�t�V�T�%7�%7�8��>�>r
c�Z��|�ydj�fd�|j�D��S)N�c3�F�K�|]\}}�j|����y�w�N�r)�.0�c_name�cr
s   �r�	<genexpr>z+CGenerator.generic_visit.<locals>.<genexpr>'s�����J�Y�V�Q�4�:�:�a�=�J�s�!)�join�children)r
rs` rrzCGenerator.generic_visit#s&����<���7�7�J�$�-�-�/�J�J�Jr
c��|jSr)�value�r
�ns  r�visit_ConstantzCGenerator.visit_Constant)s���w�w�r
c��|jSr��namer(s  r�visit_IDzCGenerator.visit_ID,s���v�v�
r
c�F�d}|jr|d|jzz
}|S)Nz#pragmar)�string)r
r)�rets   r�visit_PragmazCGenerator.visit_Pragma/s%�����8�8��3����>�!�C��
r
c��|j|j�}|dz|j|j�zdzS)N�[�])�_parenthesize_unless_simpler-r�	subscript)r
r)�arrrefs   r�visit_ArrayRefzCGenerator.visit_ArrayRef5s7���1�1�!�&�&�9����|�d�j�j����5�5��;�;r
c��|j|j�}||jz|j|j�zSr)r6r-�typer�field)r
r)�srefs   r�visit_StructRefzCGenerator.visit_StructRef9s6���/�/����7���a�f�f�}�t�z�z�!�'�'�2�2�2r
c��|j|j�}|dz|j|j�zdzS)N�(�))r6r-r�args)r
r)�frefs   r�visit_FuncCallzCGenerator.visit_FuncCall=s7���/�/����7���c�z�D�J�J�q�v�v�.�.��4�4r
c��|jdk(rd|j|j�zS|j|j�}|jdk(rd|zS|jdk(rd|zS|j�|��S)N�sizeofz
sizeof(%s)zp++z%s++zp--z%s--)�opr�exprr6)r
r)�operands   r�
visit_UnaryOpzCGenerator.visit_UnaryOpAsw���4�4�8�� �$�*�*�Q�V�V�"4�4�4��6�6�q�v�v�>�G��t�t�u�}���'�'��������'�'�!"���w�/�/r
z||rz&&r�|��^��&�z==�z!=�>�z>=�<z<=z>>�z<<�+��-�*�	�/�%c�����j�j��fd��}�j�j��fd��}|�d�j�d|��S)Nc�����j|�xs]�jxrOt|tj�xr3�j
|j�j
�jk\Sr��_is_simple_noder	�
isinstancer�BinaryOp�precedence_maprG��dr)r
s ��r�<lambda>z+CGenerator.visit_BinaryOp.<locals>.<lambda>ksf���4�/�/��2�M��-�-�M�*�Q����2O�M��)�)�!�$�$�/�4�3F�3F�q�t�t�3L�L�N�r
c�����j|�xs]�jxrOt|tj�xr3�j
|j�j
�jkDSrr_rds ��rrfz+CGenerator.visit_BinaryOp.<locals>.<lambda>wsf���4�/�/��2�L��-�-�L�*�Q����2O�L��)�)�!�$�$�/�$�2E�2E�a�d�d�2K�K�M�r
r)�_parenthesize_if�left�rightrG)r
r)�lval_str�rval_strs``  r�visit_BinaryOpzCGenerator.visit_BinaryOp_sV����(�(�
�F�F�
N�O���(�(�
�G�G�
M�N��
&�q�t�t�X�6�6r
c��|j|jd��}|j|j��d|j�d|��S)Nc�6�t|tj�Sr)rar�
Assignment)r)s rrfz-CGenerator.visit_Assignment.<locals>.<lambda>s��j��E�4D�4D�&E�r
r)rh�rvaluer�lvaluerG)r
r)rls   r�visit_AssignmentzCGenerator.visit_Assignment|s=���(�(��H�H�E�G��"�Z�Z����1�1�4�4��B�Br
c�8�dj|j�Sr)r$�namesr(s  r�visit_IdentifierTypezCGenerator.visit_IdentifierType�s���x�x���� � r
c���t|tj�rd|j|�zdzSt|tj�rd|j|�zdzS|j|�S)N�{�}r@rA)rar�InitListr�ExprListr(s  r�_visit_exprzCGenerator._visit_expr�s\���a����(�����A��&��,�,�
��5�>�>�
*�����A��&��,�,��:�:�a�=� r
c��|r|jn|j|�}|jr!|d|j|j�zz
}|jr!|d|j|j�zz
}|S)Nz : � = )r-�_generate_decl�bitsizer�initr|)r
r)�no_type�ss    r�
visit_DeclzCGenerator.visit_Decl�sh���A�F�F�4�#6�#6�q�#9���9�9�a�5�4�:�:�a�i�i�#8�8�8�a��6�6�
���)�)�!�&�&�1�1�1�A��r
c�����j|jd�}t|j�dkDr-|ddj�fd�|jddD��zz
}|S)Nrr�, c3�D�K�|]}�j|d�����y�w)T)r�N)r��r �declr
s  �rr#z,CGenerator.visit_DeclList.<locals>.<genexpr>�s&�����"=�(,�#'�/�/�$��/�"E�"=�s� )r�decls�lenr$�r
r)r�s`  r�visit_DeclListzCGenerator.visit_DeclList�sa����J�J�q�w�w�q�z�"���q�w�w�<�!��
���	�	�"=�01������"=�=�=�
=�A��r
c��d}|jr!|dj|j�dzz
}||j|j�z
}|S)Nrr)�storager$�_generate_typer;r�s   r�
visit_TypedefzCGenerator.visit_Typedef�sG�����9�9�a�3�8�8�A�I�I�.��4�4�a�	�T�
 �
 ����
(�(���r
c��d|j|jd��zdz}|dz|j|j�zS)Nr@F��
emit_declnamerAr)r��to_typer6rHr�s   r�
visit_CastzCGenerator.visit_Cast�sC���$�%�%�a�i�i�u�%�E�E��K���3�w��9�9�!�&�&�A�A�Ar
c��g}|jD]"}|j|j|���$dj|�S�Nr���exprs�appendr|r$�r
r)�visited_subexprsrHs    r�visit_ExprListzCGenerator.visit_ExprList��D�����G�G�	<�D��#�#�D�$4�$4�T�$:�;�	<��y�y�)�*�*r
c��g}|jD]"}|j|j|���$dj|�Sr�r�r�s    r�visit_InitListzCGenerator.visit_InitList�r�r
c�(�|j|d��S)N�enumr,��_generate_struct_union_enumr(s  r�
visit_EnumzCGenerator.visit_Enum�s���/�/���/�?�?r
c�V�dj|j|j��S)Nz_Alignas({}))�formatr�	alignmentr(s  r�
visit_AlignaszCGenerator.visit_Alignas�s ���$�$�T�Z�Z����%<�=�=r
c��|js+dj|j�|j��Sdj|j�|j|j	|j���S)Nz{indent}{name},
)�indentr-z{indent}{name} = {value},
)r�r-r')r'r�rr-rr(s  r�visit_EnumeratorzCGenerator.visit_Enumerator�sq���w�w�&�-�-��(�(�*��V�V�.��
�
1�7�7��(�(�*��V�V��j�j����)�8��
r
c����j|j�}d�_�j|j�}|jr5dj�fd�|jD��}|dz|zdz|zdzS|dz|zdzS)Nr�;
c3�@�K�|]}�j|����y�wrr)r �pr
s  �rr#z+CGenerator.visit_FuncDef.<locals>.<genexpr>�s�����!G�A�$�*�*�Q�-�!G����
)rr�r�body�param_declsr$)r
r)r�r��knrdeclss`    r�
visit_FuncDefzCGenerator.visit_FuncDef�s�����z�z�!�&�&�!������z�z�!�&�&�!���=�=��z�z�!G����!G�G�H��$�;��)�E�1�D�8�4�?�?��$�;��%��,�,r
c��d}|jD]z}t|tj�r||j	|�z
}�2t|tj
�r||j	|�dzz
}�d||j	|�dzz
}�||S)Nrr�r�)�extrar�FuncDefr�Pragma)r
r)r�r�s    r�
visit_FileASTzCGenerator.visit_FileAST�s}�����5�5�	-�C��#�u�}�}�-��T�Z�Z��_�$���C����.��T�Z�Z��_�t�+�+���T�Z�Z��_�u�,�,��
	-��r
c����j�dz}�xjdz
c_|jr'|dj�fd�|jD��z
}�xjdzc_|�j�dzz
}|S)N�{
rLrc3�@�K�|]}�j|����y�wr��_generate_stmt)r �stmtr
s  �rr#z,CGenerator.visit_Compound.<locals>.<genexpr>�s�����M�t��,�,�T�2�M�r�z}
)rr�block_itemsr$r�s`  r�visit_CompoundzCGenerator.visit_Compound�sy�������%�'�����Q����=�=�
����M�q�}�}�M�M�M�A����Q���	�T�
�
�
 �5�
(�(���r
c��d|j|j�zdz|j|j�zdzS)Nr@z){ry)rr;r�r(s  r�visit_CompoundLiteralz CGenerator.visit_CompoundLiteral�s6���T�Z�Z����'�'�$�.����A�F�F�1C�C�c�I�Ir
c��y)N�;�r(s  r�visit_EmptyStatementzCGenerator.visit_EmptyStatement�s��r
c�L��dj�fd�|jD��S)Nr�c3�@�K�|]}�j|����y�wrr)r �paramr
s  �rr#z-CGenerator.visit_ParamList.<locals>.<genexpr>�s�����A�u����E�*�A�r�)r$�paramsr(s` r�visit_ParamListzCGenerator.visit_ParamList�s����y�y�A����A�A�Ar
c�j�d}|jr!|d|j|j�zz
}|dzS)N�returnrr�)rHrr�s   r�visit_ReturnzCGenerator.visit_Return�s2�����6�6�1��d�j�j����0�0�0�1��3�w�r
c��y)Nzbreak;r�r(s  r�visit_BreakzCGenerator.visit_Break�s��r
c��y)Nz	continue;r�r(s  r�visit_ContinuezCGenerator.visit_Continue�s��r
c���d|j|j�zdz}|d|j|j�zdzz
}|d|j|j�zdzz
}|S)Nr@z) ? z) : rA)r|�cond�iftrue�iffalser�s   r�visit_TernaryOpzCGenerator.visit_TernaryOp�sk��
�4�#�#�A�F�F�+�
+�f�
4��	�S�4�#�#�A�H�H�-�
-��
6�6��	�S�4�#�#�A�I�I�.�
.��
4�4���r
c�,�d}|jr||j|j�z
}|dz
}||j|jd��z
}|jr6||j�dzz
}||j|jd��z
}|S)Nzif (�)
T��
add_indentzelse
)r�rr�r�r�rr�s   r�visit_IfzCGenerator.visit_Ifs������6�6�1��
�
�1�6�6�*�*�1�	�U�
��	�T�
 �
 ����d�
 �
;�;���9�9�
��"�"�$�x�/�/�A�
��$�$�Q�Y�Y�4�$�@�@�A��r
c�p�d}|jr||j|j�z
}|dz
}|jr!|d|j|j�zz
}|dz
}|jr!|d|j|j�zz
}|dz
}||j	|j
d��z
}|S)Nzfor (r�rr�Tr�)r�rr��nextr�r�r�s   r�	visit_ForzCGenerator.visit_For
s������6�6�1��
�
�1�6�6�*�*�1�	�S����6�6�1��d�j�j����0�0�0�1�	�S����6�6�1��d�j�j����0�0�0�1�	�U�
��	�T�
 �
 ����D�
 �
9�9���r
c��d}|jr||j|j�z
}|dz
}||j|jd��z
}|S)N�while (r�Tr�)r�rr�r�r�s   r�visit_WhilezCGenerator.visit_WhilesP�����6�6�1��
�
�1�6�6�*�*�1�	�U�
��	�T�
 �
 ����D�
 �
9�9���r
c���d}||j|jd��z
}||j�dzz
}|jr||j	|j�z
}|dz
}|S)Nzdo
Tr�r�z);)r�r�rr�rr�s   r�
visit_DoWhilezCGenerator.visit_DoWhilesh����	�T�
 �
 ����D�
 �
9�9��	�T�
�
�
 �9�
,�,���6�6�1��
�
�1�6�6�*�*�1�	�T�	���r
c��d}||j|j�z
}|jr#|dz
}||j|j�z
}|dz
}|S)Nz_Static_assert(�,rA)rr��messager�s   r�visit_StaticAssertzCGenerator.visit_StaticAssert$sS����	�T�Z�Z����
����9�9�
��H�A�
����A�I�I�&�&�A�	�S����r
c��d|j|j�zdz}||j|jd��z
}|S)Nzswitch (r�Tr�)rr�r�r�r�s   r�visit_SwitchzCGenerator.visit_Switch-sA������A�F�F�+�+�e�3��	�T�
 �
 ����D�
 �
9�9���r
c��d|j|j�zdz}|jD]}||j|d��z
}�|S)Nzcase �:
Tr�)rrH�stmtsr��r
r)r�r�s    r�
visit_CasezCGenerator.visit_Case2sP���d�j�j����(�(�5�0���G�G�	<�D�
��$�$�T�d�$�;�;�A�	<��r
c�X�d}|jD]}||j|d��z
}�|S)Nz	default:
Tr�)r�r�r�s    r�
visit_DefaultzCGenerator.visit_Default8s9�����G�G�	<�D�
��$�$�T�d�$�;�;�A�	<��r
c�X�|jdz|j|j�zS)Nr�)r-r�r�r(s  r�visit_LabelzCGenerator.visit_Label>s$���v�v��~�� 3� 3�A�F�F� ;�;�;r
c�&�d|jzdzS)Nzgoto r�r,r(s  r�
visit_GotozCGenerator.visit_GotoAs�������#�%�%r
c��y)Nz...r�r(s  r�visit_EllipsisParamzCGenerator.visit_EllipsisParamDs��r
c�&�|j|d�S)N�structr�r(s  r�visit_StructzCGenerator.visit_StructGs���/�/��8�<�<r
c�8�|j|j�Sr)r�r;r(s  r�visit_TypenamezCGenerator.visit_TypenameJs���"�"�1�6�6�*�*r
c�&�|j|d�S)N�unionr�r(s  r�visit_UnionzCGenerator.visit_UnionMs���/�/��7�;�;r
c��d}|jD]I}t|tj�r|d|jzz
}�0|d|j	|�zdzz
}�K|d|j|j�zz
}|S)Nr�.r4r5r~)r-rar�IDrr|rH)r
r)r�r-s    r�visit_NamedInitializerz!CGenerator.visit_NamedInitializerPs|�����F�F�	2�D��$����)��S�4�9�9�_�$���S�4�:�:�d�+�+�c�1�1��		2�
	
�U�T�%�%�a�f�f�-�
-�-���r
c�$�|j|�Sr�r�r(s  r�visit_FuncDeclzCGenerator.visit_FuncDeclZs���"�"�1�%�%r
c�(�|j|d��S�NFr�r	r(s  r�visit_ArrayDeclzCGenerator.visit_ArrayDecl]����"�"�1�E�"�:�:r
c�(�|j|d��Srr	r(s  r�visit_TypeDeclzCGenerator.visit_TypeDecl`rr
c�(�|j|d��Srr	r(s  r�
visit_PtrDeclzCGenerator.visit_PtrDeclcrr
c��|dvr|j}|j}n7|dk(sJ�|j�dn|jj}|j}|dz|j
xsdz}|�h|dz
}||j
�z
}|xjdz
c_|dz
}|||�z
}|xjdzc_||j
�d	zz
}|S)
zq Generates code for structs, unions, and enums. name should be
            'struct', 'union', or 'enum'.
        )r�rr�Nrrr�rLr�ry)r��_generate_struct_union_body�values�enumerators�_generate_enum_bodyr-rr)r
r)r-�members�
body_functionr�s      rr�z&CGenerator._generate_struct_union_enumfs����&�&��g�g�G� �<�<�M��6�>�!�>��h�h�.�d�A�H�H�4H�4H�G� �4�4�M��3�J�!�&�&�,�B�'����
��I�A�
��"�"�$�$�A�����"��
��J�A�
��w�'�'�A�����"��
��"�"�$�s�*�*�A��r
c�8��dj�fd�|D��S)Nrc3�@�K�|]}�j|����y�wrr�r�s  �rr#z9CGenerator._generate_struct_union_body.<locals>.<genexpr>s�����E�T�t�*�*�4�0�E�r��r$�r
rs` rrz&CGenerator._generate_struct_union_body~s����w�w�E�W�E�E�Er
c�D��dj�fd�|D��dddzS)Nrc3�@�K�|]}�j|����y�wrr)r r'r
s  �rr#z1CGenerator._generate_enum_body.<locals>.<genexpr>�s�����>�U�t�z�z�%�(�>�r����r�rrs` rrzCGenerator._generate_enum_body�s$����w�w�>�g�>�>�s��C�d�J�Jr
c��t|�}|r|xjdz
c_|j�}|r|xjdzc_|tjtj
tjtjtjtjtjtjtjtjtjtjtj f
vr||j#|�zdzS|tj$fvr|j#|�S|tj&fvr||j#|�zS||j#|�zdzS)z� Generation from a statement node. This method exists as a wrapper
            for individual visit_* methods to handle different treatment of
            some statements in this context.
        rLr�r�)r;rrr�Declrp�Cast�UnaryOprb�	TernaryOp�FuncCall�ArrayRef�	StructRef�Constantr�Typedefr{r�Compound�If)r
r)r��typr�s     rr�zCGenerator._generate_stmt�s��
�1�g���t�(�(�A�-�(��"�"�$���t�(�(�A�-�(���
�
�E�,�,�e�j�j�%�-�-����������������������5�=�=����	 � ��D�J�J�q�M�)�E�1�1�
�U�^�^�%�
%�
�:�:�a�=� �
�U�X�X�K�
��D�J�J�q�M�)�)��D�J�J�q�M�)�D�0�0r
c�T�d}|jrdj|j�dz}|jr!|dj|j�dzz
}|jr$||j	|jd�dzz
}||j|j�z
}|S)z& Generation from a Decl node.
        rrr)�funcspecr$r��alignrr�r;r�s   rrzCGenerator._generate_decl�s���
���:�:�3�8�8�A�J�J�/�#�5�q��9�9�a�3�8�8�A�I�I�.��4�4�a��7�7�A����A�G�G�A�J�/�#�5�5�A�	�T�
 �
 ����
(�(���r
Tc��t|�}|tjk(�r�d}|jr!|dj	|j�dzz
}||j|j�z
}|jr|r|jnd}t|�D�]d\}}t|tj�r�|dk7r(t||dz
tj�rd|zdz}|dz
}|jr!|dj	|j�dzz
}||j|j�dzz
}��t|tj�rS|dk7r(t||dz
tj�rd|zdz}|d|j|j�zdzz
}��t|tj�s��+|jr)d	dj	|j��|rd|znd��}��`d
|z}��g|r|d|zz
}|S|tjk(r|j!|j�S|tj"k(r|j%|j|��S|tj&k(rdj	|j(�dzS|tjtjtjfvr"|j%|j||gz|��S|j|�S)z� Recursive generation from a type node. n is the type node.
            modifiers collects the PtrDecl, ArrayDecl and FuncDecl modifiers
            encountered on the way down to a TypeDecl, to allow proper
            generation from it.
        rrrrr@rAr4r5z* rYr�)r;r�TypeDecl�qualsr$r�declname�	enumeratera�	ArrayDecl�PtrDecl�	dim_quals�dim�FuncDeclrBr"r�Typenamer��IdentifierTyperu)	r
r)�	modifiersr�r-r��nstr�i�modifiers	         rr�zCGenerator._generate_type�s����1�g���%�.�.� ��A��w�w��S�X�X�a�g�g�.��4�4��
����A�F�F�#�#�A�!"���
�1�:�:�2�D�
 )��3�
*���8��h����8��Q��"�9�Q��U�#3�U�]�]�C�#&��:��#3�D��C�K�D��)�)������);�);� <�s� B�B���D�J�J�x�|�|�4�s�:�:�D���%�.�.�9��Q��"�9�Q��U�#3�U�]�]�C�#&��:��#3�D��C�$�*�*�X�]�]�";�;�c�A�A�D���%�-�-�8��~�~�+.�8�8�H�N�N�+C�9=�3��:�2�+E� G�� #�T�z��'
*�(�Q�#��*�_�Q��H�
�E�J�J�
��&�&�q�v�v�.�.�
�E�N�N�
"��&�&�q�v�v�}�&�M�M�
�E�(�(�
(��8�8�A�G�G�$�s�*�*�
�U�_�_�e�m�m�U�^�^�D�
D��&�&�q�v�v�y�A�3��7D�'�F�
F��:�:�a�=� r
c�H�|j|�}||�rd|zdzS|S)z� Visits 'n' and returns its string representation, parenthesized
            if the condition function applied to the node returns True.
        r@rA)r|)r
r)�	conditionr�s    rrhzCGenerator._parenthesize_if�s.��
���Q����Q�<���7�S�=� ��Hr
c�.���j|�fd��S)z. Common use case for _parenthesize_if
        c�(���j|�Sr)r`)rer
s �rrfz8CGenerator._parenthesize_unless_simple.<locals>.<lambda>�s���d�6J�6J�1�6M�2M�r
)rhr(s` rr6z&CGenerator._parenthesize_unless_simple�s����$�$�Q�(M�N�Nr
c��t|tjtjtjtj
tjf�S)z~ Returns True for nodes that are "simple" - i.e. nodes that always
            have higher precedence than operators.
        )rarr)rr'r(r&r(s  rr`zCGenerator._is_simple_node�s9���!�e�n�n�e�h�h����#�o�o�u�~�~�?�@�	@r
N)F)Cr�
__module__�__qualname__�__doc__rrrrr*r.r2r9r>rDrJrcrmrsrvr|r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrr
r
rrr�rrr�rr�rhr6r`r�r
rrrs.���	5�'�?�K����<�3�5�0�
�	
�a�
�	
�a�	
�
	�Q�
�	�Q�

�	�Q�
�	
�a�
��q�
�	�Q�
��a�
��a�
�"&�q�
�	
�a�
��q�
�	�Q�
��Q�
�	�Q�
��Q�
��Q�
�N�7�:C�!�!����B�+�+�@�>��-�	��J��B��
����	�����
��<�&��=�+�<��&�;�;�;��0F�K�1�<�+-�d�3!�j�O�
@r
rN)rr�objectrr�r
r�<module>rJs���j@��j@r