o
    ¸ôj‹  ã                   @   sŽ  d Z ddlmZ ddlZddlmZ ddlZddlZddlm	Z	m
Z
mZmZmZ ejdkZdd	„ Zd
d„ Zeƒ \ZZZddlmZ ddlmZ e d¡Ze d¡Ze d¡ZddddddddœZedƒD ]Ze  e!eƒdef ¡ qd[e"Z#e$dƒZ%e$dƒZ&dd„ Z'ejdkr‹e(e)fZ*ne(Z*ed fd!d"„Z+efd#d$„Z,ep�e,Z-ep¡e+Z.G d%d&„ d&e/ƒZ0G d'd(„ d(e0ƒZ1ee2ede(e*e$e3ee4e5e6e7e8fd)d*„Z9dS )+zImplementation of JSONEncoder
é    )Úabsolute_importN)Ú
itemgetteré   )Úbinary_typeÚ	text_typeÚstring_typesÚinteger_typesÚPY3)é   é   c                 G   s>   t rz|  |t|ƒjf|  ¡ W d S  ty   Y d S w d S ©N)Ú_HAS_ADD_NOTEÚadd_noteÚtypeÚ__name__ÚBaseException)ÚexcZnote_formatÚobjÚargs© r   úe/var/www/html/academy/tools/voices/clone/cosy-venv/lib/python3.10/site-packages/simplejson/encoder.pyÚ_annotate_exception   s    þýr   c                  C   s4   zddl m}  | j| j| jfW S  ty   Y dS w )Nr   ©Ú	_speedups)NNN)Ú r   Úencode_basestring_asciiÚencode_basestringÚmake_encoderÚImportErrorr   r   r   r   Ú_import_speedups   s   þÿr   )ÚPosInf)ÚRawJSONz[\x00-\x1f\\"]z([\\"]|[^\ -~])z[\x80-\xff]z\\z\"z\bz\fz\nz\rz\t)ú\ú"úúÚ
úú	é    ú\u%04xÚnanÚinfc                 C   sl   t | ƒ}|dd… }|dkr|dd… n|}d|  kr!dkr"|S  |dkr2||dkr/t ƒS tƒS |tƒS )ag  Return the JSON representation of a ``Decimal``.

    Finite Decimals are stringified as-is, preserving precision and trailing
    zeros.  Non-finite Decimals (``NaN``, ``sNaN``, ``Infinity``) are routed
    through the same ``allow_nan``/``ignore_nan`` handling as floats so they
    never emit invalid JSON (see #149).

    ``str(Decimal)`` yields a leading ``-`` sign at most (never ``+``); a
    finite value's first significant character is always a digit, while a
    non-finite value's is a letter (``N``, ``s`` or ``I``).  So a single
    ``str()`` plus a one/two character check distinguishes the two.
    Nr   ú-é   Ú0Ú9ÚI)ÚstrÚ	_INFINITYÚ_NAN)ÚdÚ	_floatstrÚsZc0Úcr   r   r   Ú_encode_decimal<   s   þr9   )r
   é   r#   c                 C   s¦   |rt | tƒrt| dƒ} n8t| ƒturt | ¡} n,t | tƒr+t | ¡dur+t| dƒ} nt| ƒttfvrEt | tƒr>t | ¡} nt | ¡d } dd„ }|t	 
|| ¡ | S )z5Return a JSON representation of a Python string

    úutf-8Nr   c                 S   s   t |  d¡ S )Nr   )Ú
ESCAPE_DCTÚgroup)Úmatchr   r   r   Úreplacer   s   z%py_encode_basestring.<locals>.replace)Ú
isinstanceÚbytesr2   r   Ú__str__ÚHAS_UTF8ÚsearchÚunicodeÚ__getnewargs__ÚESCAPEÚsub)r7   Ú_PY3Z_qr?   r   r   r   Úpy_encode_basestring\   s   

€
rJ   c                 C   sª   |rt | tƒrt| dƒ} n8t| ƒturt | ¡} n,t | tƒr+t | ¡dur+t| dƒ} nt| ƒttfvrEt | tƒr>t | ¡} nt | ¡d } dd„ }dtt	 
|| ¡ƒ d S )zAReturn an ASCII-only JSON representation of a Python string

    r;   Nr   c                 S   sv   |   d¡}zt| W S  ty:   t|ƒ}|dk r d|f  Y S |d8 }d|d? d@ B }d|d@ B }d||f  Y S w )	Nr   i   r*   i Ø  é
   iÿ  i Ü  z\u%04x\u%04x)r=   r<   ÚKeyErrorÚord)r>   r7   ÚnÚs1Ús2r   r   r   r?   �   s   

÷z+py_encode_basestring_ascii.<locals>.replacer#   )r@   rA   r2   r   rB   rC   rD   rE   rF   ÚESCAPE_ASCIIrH   )r7   rI   r?   r   r   r   Úpy_encode_basestring_asciiw   s   

€
rR   c                   @   sH   e Zd ZdZdZdZ							ddd	„Zd
d„ Zdd„ Zdd„ Z	dS )ÚJSONEncoderaZ  Extensible JSON <http://json.org> encoder for Python data structures.

    Supports the following objects and types by default:

    +-------------------+---------------+
    | Python            | JSON          |
    +===================+===============+
    | dict, namedtuple  | object        |
    +-------------------+---------------+
    | list, tuple       | array         |
    +-------------------+---------------+
    | str, unicode      | string        |
    +-------------------+---------------+
    | int, long, float  | number        |
    +-------------------+---------------+
    | True              | true          |
    +-------------------+---------------+
    | False             | false         |
    +-------------------+---------------+
    | None              | null          |
    +-------------------+---------------+

    To extend this to recognize other objects, subclass and implement a
    ``.default()`` method with another method that returns a serializable
    object for ``o`` if possible, otherwise it should call the superclass
    implementation (to raise ``TypeError``).

    z, z: FTNr;   c                 C   s°   || _ || _|| _|| _|| _|
| _|| _|| _|| _|| _	|| _
|| _|| _|| _|dur7t|tƒs7|d }|| _|durE|\| _| _n|durLd| _|	durS|	| _|| _dS )aþ  Constructor for JSONEncoder, with sensible defaults.

        If skipkeys is false, then it is a TypeError to attempt
        encoding of keys that are not str, int, long, float or None.  If
        skipkeys is True, such items are simply skipped.

        If ensure_ascii is true, the output is guaranteed to be str
        objects with all incoming unicode characters escaped.  If
        ensure_ascii is false, the output will be unicode object.

        If check_circular is true, then lists, dicts, iterables encoded with
        iterable_as_array, and custom encoded objects will be checked for
        circular references during encoding to prevent an infinite recursion
        (which would cause a RecursionError, or RuntimeError on Python 2).
        Otherwise, no such check takes place.

        If allow_nan is true (default: False), then out of range float
        values (nan, inf, -inf) will be serialized to
        their JavaScript equivalents (NaN, Infinity, -Infinity)
        instead of raising a ValueError. See
        ignore_nan for ECMA-262 compliant behavior.

        If sort_keys is true, then the output of dictionaries will be
        sorted by key; this is useful for regression tests to ensure
        that JSON serializations can be compared on a day-to-day basis.

        If indent is a string, then JSON array elements and object members
        will be pretty-printed with a newline followed by that string repeated
        for each level of nesting. ``None`` (the default) selects the most compact
        representation without any newlines. For backwards compatibility with
        versions of simplejson earlier than 2.1.0, an integer is also accepted
        and is converted to a string with that many spaces.

        If specified, separators should be an (item_separator, key_separator)
        tuple.  The default is (', ', ': ') if *indent* is ``None`` and
        (',', ': ') otherwise.  To get the most compact JSON representation,
        you should specify (',', ':') to eliminate whitespace.

        If specified, default is a function that gets called for objects
        that can't otherwise be serialized.  It should return a JSON encodable
        version of the object or raise a ``TypeError``.

        If encoding is not None, then all input strings will be
        transformed into unicode using that encoding prior to JSON-encoding.
        The default is UTF-8.

        If use_decimal is true (default: ``True``), ``decimal.Decimal`` will
        be supported directly by the encoder. For the inverse, decode JSON
        with ``parse_float=decimal.Decimal``.

        If namedtuple_as_object is true (the default), objects with
        ``_asdict()`` methods will be encoded as JSON objects.

        If tuple_as_array is true (the default), tuple (and subclasses) will
        be encoded as JSON arrays.

        If *iterable_as_array* is true (default: ``False``),
        any object not in the above table that implements ``__iter__()``
        will be encoded as a JSON array.

        If bigint_as_string is true (not the default), ints 2**53 and higher
        or lower than -2**53 will be encoded as strings. This is to avoid the
        rounding that happens in Javascript otherwise.

        If int_as_string_bitcount is a positive number (n), then int of size
        greater than or equal to 2**n or lower than or equal to -2**n will be
        encoded as strings.

        If specified, item_sort_key is a callable used to sort the items in
        each dictionary. This is useful if you want to sort items other than
        in alphabetical order by key.

        If for_json is true (not the default), objects with a ``for_json()``
        method will use the return value of that method for encoding as JSON
        instead of the object.

        If *ignore_nan* is true (default: ``False``), then out of range
        :class:`float` values (``nan``, ``inf``, ``-inf``) will be serialized
        as ``null`` in compliance with the ECMA-262 specification. If true,
        this will override *allow_nan*.

        Nú ú,)ÚskipkeysÚensure_asciiÚcheck_circularÚ	allow_nanÚ	sort_keysÚuse_decimalÚnamedtuple_as_objectÚtuple_as_arrayÚiterable_as_arrayÚbigint_as_stringÚitem_sort_keyÚfor_jsonÚ
ignore_nanÚint_as_string_bitcountr@   r   ÚindentÚitem_separatorÚkey_separatorÚdefaultÚencoding)ÚselfrV   rW   rX   rY   rZ   rd   Ú
separatorsrh   rg   r[   r\   r]   r_   r`   ra   rb   rc   r^   r   r   r   Ú__init__Ä   s0   Z
zJSONEncoder.__init__c                 C   s   t d|jj ƒ‚)a$  Implement this method in a subclass such that it returns
        a serializable object for ``o``, or calls the base implementation
        (to raise a ``TypeError``).

        For example, to support arbitrary iterators, you could
        implement default like this::

            def default(self, o):
                try:
                    iterable = iter(o)
                except TypeError:
                    pass
                else:
                    return list(iterable)
                return JSONEncoder.default(self, o)

        z*Object of type %s is not JSON serializable)Ú	TypeErrorÚ	__class__r   )ri   Úor   r   r   rg   7  s   ÿzJSONEncoder.defaultc                 C   s„   t |tƒr| j}|dur|dkst||ƒ}t |tƒr%| jr!t|ƒS t|ƒS |  |¡}t |t	t
fƒs5t	|ƒ}| jr=d |¡S d |¡S )zÕReturn a JSON string representation of a Python data structure.

        >>> from simplejson import JSONEncoder
        >>> JSONEncoder().encode({"foo": ["bar", "baz"]})
        '{"foo": ["bar", "baz"]}'

        Nr;   r   )r@   r   rh   r   r   rW   r   r   Ú
iterencodeÚlistÚtupleÚjoin)ri   rn   Ú	_encodingÚchunksr   r   r   ÚencodeL  s   
	




zJSONEncoder.encodec                 C   s2  | j ri }nd}| jrt}nt}| jdkr"| jdur"|| jfdd„}| j| jttt fdd„}i }| j	r6dn| j
}tduret|| j|| j| j| j| j| j| j|| j| j| j|| j| j| j| jtj| jƒ}n$t|| j|| j|| j| j| j| j| j| j| j|| j| j| j| jtjd�}z
||d	ƒW | ¡  S | ¡  w )
zØEncode the given object and yield each string
        representation as available.

        For example::

            for chunk in JSONEncoder().iterencode(bigobject):
                mysocket.write(chunk)

        Nr;   c                 S   s   t | tƒr
t| |ƒ} || ƒS r   )r@   r   r   )rn   Z_orig_encoderrs   r   r   r   Ú_encoder|  s   

z(JSONEncoder.iterencode.<locals>._encoderc                 S   sj   | | krd}n| |krd}n| |krd}nt | ƒtkrt| ƒ} || ƒS |r)d}|S |s3tdt| ƒ ƒ‚|S )NÚNaNÚInfinityz	-InfinityÚnullz2Out of range float values are not JSON compliant: )r   ÚfloatÚ
ValueErrorÚrepr)rn   rY   rb   Ú_reprÚ_infÚ_neginfÚtextr   r   r   Úfloatstr�  s&   ûÿÿz(JSONEncoder.iterencode.<locals>.floatstré5   )ÚDecimalr   )rX   rW   r   r   rh   rY   rb   Ú
FLOAT_REPRr    r_   rc   Úc_make_encoderrg   rd   rf   re   rZ   rV   r[   r\   r]   r`   ra   Údecimalrƒ   r^   Ú_make_iterencodeÚclear)ri   rn   Úmarkersrv   r�   Úkey_memorc   Ú_iterencoder   r   r   ro   i  sH   

ÿÿù	ù
zJSONEncoder.iterencode)FTTFFNNr;   NTTTFNFFNF)
r   Ú
__module__Ú__qualname__Ú__doc__re   rf   rk   rg   ru   ro   r   r   r   r   rS   ¤   s    
úsrS   c                       s(   e Zd ZdZdd„ Z‡ fdd„Z‡  ZS )ÚJSONEncoderForHTMLa3  An encoder that produces JSON safe to embed in HTML.

    To embed JSON content in, say, a script tag on a web page, the
    characters &, < and > should be escaped. They cannot be escaped
    with the usual entities (e.g. &amp;) because they are not expanded
    within <script> tags.

    This class also escapes the line separator and paragraph separator
    characters U+2028 and U+2029, irrespective of the ensure_ascii setting,
    as these characters are not valid in JavaScript strings (see
    http://timelessrepo.com/json-isnt-a-javascript-subset).
    c                 C   s$   |   |¡}| jrd |¡S d |¡S )Nr   )ro   rW   rr   )ri   rn   rt   r   r   r   ru   Å  s   


zJSONEncoderForHTML.encodec                 #   sh   � t t| ƒ |¡}|D ]&}| dd¡}| dd¡}| dd¡}| js.| dd¡}| d	d
¡}|V  qd S )Nú&z\u0026ú<z\u003cú>z\u003eu   â€¨z\u2028u   â€©z\u2029)Úsuperr�   ro   r?   rW   )ri   rn   rt   Úchunk©rm   r   r   ro   Î  s   €÷zJSONEncoderForHTML.iterencode)r   rŒ   r�   rŽ   ru   ro   Ú__classcell__r   r   r•   r   r�   ·  s    	r�   c                    s~  ˆr	ˆ d u r	t j‰ ˆd urtˆƒstdƒ‚|rˆd u rtdƒ‰ˆd ur0ˆdks,ˆˆˆƒs0tdƒ‚dd„ ‰‡‡‡"fdd„‰‡‡‡!fdd	„‰d‡ ‡‡‡‡‡‡‡‡	‡
‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡ ‡!‡#‡$fd
d„	‰‡ ‡‡‡‡‡‡‡‡‡"‡#fdd„‰‡ ‡‡‡‡‡‡‡‡	‡
‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡ ‡!‡#‡$fdd„‰d‡ ‡‡‡‡‡‡‡‡‡	‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡‡ ‡!‡#‡$fdd„	‰ˆS )Nz&item_sort_key must be None or callabler   z1int_as_string_bitcount must be a positive integerc                 S   s8   t | |d ƒ}t|ƒrz|ƒ fW S  ty   Y d S w d S r   )ÚgetattrÚcallablerl   )r   Úmethod_nameÚmethodr   r   r   Úcall_methodþ  s   
þz%_make_iterencode.<locals>.call_methodc                    sL   ˆ d u pˆ dk }t | ƒˆvrt| ƒ} |s|  ¡ ˆ krˆ| ƒS dˆ| ƒ d S )Nr   r#   )r   ÚintÚ
bit_length)ÚvalueZskip_quoting)Ú_int_as_string_bitcountr   r2   r   r   Ú_encode_int  s   ýÿz%_make_iterencode.<locals>._encode_intc                 3   s€   � ˆd urˆ| ƒ}|ˆv rˆ dƒ‚| ˆ|< z|||ƒD ]}|V  qW n t y4   ˆd ur3ˆ |d ¡ ‚ w ˆd ur>ˆ|= d S d S )NúCircular reference detected)r   Úpop)r   ÚresultÚ_current_indent_levelru   Úmarkeridr”   )r{   Úidr‰   r   r   Ú_iterencode_method  s$   €ÿù
ÿz,_make_iterencode.<locals>._iterencode_methodc                 3   s  � |d u r| sdV  d S | }ˆd ur"ˆ|ƒ}|ˆv rˆdƒ‚|ˆ|< �zHd}ˆ	d ur=|d7 }dˆ	|  }ˆ
| }||7 }nd }ˆ
}d}t | ƒD �]\}}	|rQd}n|}zçˆ|	ˆƒra|ˆ|	ƒ V  nØˆrtˆ|	tƒrtˆd urt|ˆ|	ƒ V  nÅˆ|	tƒr€||	j V  n¹|	d u rŠ|d V  n¯|	du r”|d	 V  n¥|	du rž|d
 V  n›ˆ|	ˆƒr«|ˆ|	ƒ V  nŽˆ|	ˆƒr¸|ˆ|	ƒ V  n�ˆrÈˆ|	ˆ ƒrÈ|t|	ˆƒ V  nq|V  ˆoÑˆ|	dƒ}
|
rÞˆ|	|
d |ˆƒ}nRˆoäˆ|	dƒ}|�r|d }ˆ|ˆƒsûtdt|ƒjf ƒ‚ˆ|	||ˆƒ}n-ˆ|	ˆƒ�rˆ|	|ƒ}n!ˆ�rˆ|	ˆƒ�rˆ|	|ƒ}nˆ|	ˆƒ�r*ˆ|	|ƒ}nˆ|	|dƒ}|D ]}|V  �q2W qG t�yO } zt	|d||ƒ ‚ d }~ww |�rWdV  n|d u�rg|d8 }dˆ	|  V  dV  W n t�y   ˆd u�r~ˆ 
|d ¡ ‚ w ˆd u�rŠˆ|= d S d S )Nz[]r¡   Ú[r   r&   TFry   ÚtrueÚfalsera   r   Ú_asdictú$_asdict() must return a dict, not %szwhen serializing %s item %dÚ])Ú	enumeraterA   r!   Úencoded_jsonr9   rl   r   r   r   r   r¢   )Úlstr¤   Z_originr¥   ÚbufÚnewline_indentÚ	separatorÚfirstÚirž   ra   rt   r«   Údctr”   r   )rƒ   r{   rI   Ú_dict_typesr    rv   rs   r6   Ú	_for_jsonÚ_indentÚ_item_separatorr‹   Ú_iterencode_dictÚ_iterencode_listr§   Ú_namedtuple_as_objectÚ_tuple_as_arrayÚ_use_decimalr›   Údictrz   r¦   r   r@   rp   r‰   r   rq   r   r   r¼   +  s¶   €





ÿ
ÿ
€þ€ü
€
ý

ÿz*_make_iterencode.<locals>._iterencode_listc                    sÜ   ˆ| ˆ
ƒr	 | S ˆrˆ| t ƒrˆd urˆ	| ˆƒ} | S ˆ| ˆƒr%ˆ| ƒ} | S | du r-d} | S | du r5d} | S | d u r=d} | S ˆ| ˆƒrRt| ƒˆvrLt| ƒ} ˆ	| ƒ} | S ˆr`ˆ| ˆ ƒr`t| ˆƒ} | S ˆrfd } | S td| jj ƒ‚)NTr©   Frª   ry   z2keys must be str, int, float, bool or None, not %s)rA   r   rœ   r9   rl   rm   r   ©Úkey)rƒ   rI   rs   r6   Ú	_skipkeysr¿   rz   r   r@   r2   r   r   r   Ú_stringify_keyŒ  s@   
ê

ìîðò
ôù
ûþÿz(_make_iterencode.<locals>._stringify_keyc                 3   s‚  � | sdV  d S ˆd urˆ| ƒ}|ˆv rˆdƒ‚| ˆ|< �zƒdV  ˆ	d ur7|d7 }dˆ	|  }ˆ
| }|V  nd }ˆ
}d}ˆrD|   ¡ }n|  ¡ }ˆd ursg }|   ¡ D ]\}}	ˆ|ˆƒsdˆ|ƒ}|d u rdqR| ||	f¡ qR|jˆd� n|}|D �]\}
}ˆd u rŽˆ|
ˆƒsŽˆ|
ƒ}
|
d u rŽqw|r“d}n|V  ˆ|
ƒV  ˆV  zØˆ|ˆƒrªˆ|ƒV  nËˆr»ˆ|tƒr»ˆd ur»ˆ|ƒV  nºˆ|tƒrÅ|jV  n°|d u rÍd	V  n¨|du rÕd
V  n |du rÝdV  n˜ˆ|ˆƒrèˆ|ƒV  n�ˆ|ˆƒróˆ|ƒV  n‚ˆ�rˆ|ˆ ƒ�rt|ˆƒV  nrˆ�o
ˆ|dƒ}|�rˆ||d |ˆƒ}nTˆ�oˆ|dƒ}|�r?|d }ˆ|ˆƒ�s7tdt	|ƒj
f ƒ‚ˆ|||ˆƒ}n-ˆ|ˆƒ�rKˆ||ƒ}n!ˆ�rZˆ|ˆƒ�rZˆ||ƒ}nˆ|ˆƒ�rfˆ||ƒ}nˆ||dƒ}|D ]}|V  �qnW qw t�y‹ } zt|d| |
ƒ ‚ d }~ww |d u�rœ|d8 }dˆ	|  V  dV  W n t�y´   ˆd u�r³ˆ |d ¡ ‚ w ˆd u�r¿ˆ|= d S d S )Nz{}r¡   Ú{r   r&   TrÁ   Fry   r©   rª   ra   r   r«   r¬   zwhen serializing %s item %rÚ})ÚitemsÚ	iteritemsÚappendÚsortrA   r!   r¯   r9   rl   r   r   r   r   r¢   )r¶   r¤   r¥   r²   re   r´   rÈ   rÇ   ÚkÚvrÂ   rž   ra   rt   r«   Z
asdict_dctr”   r   )rƒ   r{   rI   r·   r    rv   rs   r6   r¸   r¹   rº   Ú_item_sort_keyr‹   r»   r¼   r§   Ú_key_separatorr½   rÄ   r¾   r¿   r›   rÀ   rz   r¦   r   r@   rp   r‰   r   rq   r   r   r»   §  sÐ   €








ÿÿ
€þ€ü


ý

ÿz*_make_iterencode.<locals>._iterencode_dictFc           
   
   3   sì  � ˆ| ˆƒrˆ| ƒV  d S ˆrˆ| t ƒrˆd urˆ| ƒV  d S ˆ| tƒr*| jV  d S | d u r3dV  d S | du r<dV  d S | du rEdV  d S ˆ| ˆƒrQˆ| ƒV  d S ˆ| ˆƒr]ˆ| ƒV  d S ˆ	of| ofˆ| dƒ}|rzˆ| |d |ˆƒD ]}|V  qrd S ˆoƒ| oƒˆ| dƒ}|r¨|d }ˆ|ˆƒs™td	t|ƒjf ƒ‚ˆ| ||ˆƒD ]}|V  q d S ˆ| ˆƒrºˆ| |ƒD ]}|V  q²d S ˆrÎˆ| ˆƒrÎˆ| |ƒD ]}|V  qÆd S ˆ| ˆƒràˆ| |ƒD ]}|V  qØd S ˆrïˆ| ˆ ƒrït| ˆƒV  d S ˆ
�r"ˆd u�rˆ| ƒˆv �rˆd
ƒ‚zˆ| ƒ}W n
 t�y   Y nw ˆ||| ƒD ]}|V  �qd S ˆd u�r8ˆ| ƒ}|ˆv �r4ˆd
ƒ‚| ˆ|< zˆ| ƒ} ˆ| |ƒD ]}|V  �qBW n t�yi }	 zˆd u�r^ˆ |d ¡ t	|	d| ƒ ‚ d }	~	ww ˆd u�rtˆ|= d S d S )Nry   Tr©   Frª   ra   r   r«   r¬   r¡   zwhen serializing %s object)
rA   r!   r¯   rl   r   r   r9   r   r¢   r   )
rn   r¤   Z_methods_triedra   r”   r«   r¶   Úiteratorr¥   r   )rƒ   r{   rI   Ú_defaultr·   r    rv   rs   r6   r¸   Ú_iterable_as_arrayr‹   r»   r¼   r§   r½   r¾   r¿   r›   rÀ   rz   r¦   r   r@   Úiterrp   r‰   r   rq   r   r   r‹     s°   €







ÿ
ÿþ
ÿ
ÿþ
ÿÿ
ÿÿþ



ÿ
ÿ€û

ÿz%_make_iterencode.<locals>._iterencoder   )F)r†   rƒ   r˜   rl   r   )r‰   rÐ   rv   r¹   r6   rÎ   rº   Ú
_sort_keysrÃ   r¿   r½   r¾   rŸ   rÍ   rs   r¸   rÑ   rI   r{   r   rƒ   rÀ   r·   rz   r¦   r   r@   rp   r2   rq   rÒ   r   )%rƒ   r{   rI   rÐ   r·   r    rv   rs   r6   r¸   r¹   rŸ   rº   rÍ   rÑ   r‹   r»   r¼   r§   rÎ   r½   rÃ   rÄ   r¾   r¿   r›   rÀ   rz   r¦   r   r@   rÒ   rp   r‰   r2   r   rq   r   r‡   Ü  s&   ÿ	D aHFkQr‡   ):rŽ   Ú
__future__r   ÚreÚoperatorr   r†   ÚsysÚcompatr   r   r   r   r	   Úversion_infor   r   r   Úc_encode_basestring_asciiÚc_encode_basestringr…   Údecoderr    Úraw_jsonr!   ÚcompilerG   rQ   rC   r<   Úrangerµ   Ú
setdefaultÚchrr|   r„   rz   r4   r3   r9   rÀ   Z
frozendictr·   rJ   rR   r   r   ÚobjectrS   r�   r{   r¦   r@   rp   r2   rq   rÒ   r‡   r   r   r   r   Ú<module>   sx    
		ÿ


ù	

(ÿÿ  ,ì