ELF@@8@~~PPP```$$PtdyyyQtdRtdPPPGNUQ) b'Sh$o11kzl x wF"L-F3| [ Mg_qj@U, .!Y `1__gmon_start___ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalizePyCapsule_GetPointerPyEval_SaveThreadLZ4F_freeDecompressionContextPyEval_RestoreThread__stack_chk_guardPyArg_ParseTupleAndKeywordsLZ4F_createDecompressionContextLZ4F_isErrorLZ4F_getFrameInfoPyBuffer_ReleasePyExc_RuntimeErrorPyErr_FormatLZ4F_getErrorNameLZ4_versionNumber_Py_TrueStruct_Py_FalseStructPy_BuildValue__stack_chk_failPyCapsule_SetPointer_Py_NoneStructLZ4F_resetDecompressionContextPyExc_ValueErrorPyErr_SetStringPyCapsule_NewPyMem_MallocLZ4F_createCompressionContextPyErr_NoMemoryLZ4F_freeCompressionContextPyMem_FreeLZ4F_decompressPyMem_ReallocPyBytes_FromStringAndSizePyByteArray_FromStringAndSizeLZ4F_compressBoundLZ4F_flushLZ4F_compressEndLZ4F_compressUpdateLZ4F_compressFrameBoundLZ4F_compressBeginLZ4F_compressFramePyInit__framePyModule_Create2PyModule_AddIntConstantliblz4.so.1libc.so.6ld-linux-aarch64.so.1GLIBC_2.17 PX@H I0I8H@PIHH`HhHp8II(IHIHHIIHDC`DCIHHH D(C0`D8C@HHH`I@JhI0 xI. mI@,0` I()8]@IH'XW`Ihx@TIPSIpRJT&N(JP%pJ #'-x      (08 @!H"P$X%`&h(p)x*+,./0 {{_{:G9    >G9 BG: FG": JGB: NGb: RG: VG: ZG: ^G: bG; fG"; jGB; nGb; rG; vG; zG; ~G; G< G"< GB< Gb< G< G< G< G< G= G"= GB= Gb= G= G= G= G= G> G"> GB> Gb> G> G@_    ! ?T!Ga_ ! !"A !ABGb_ { `L9@7G@Q R` 9 @{¨_     ?#{!S]SA{¨#$?#cG{ CSb@gc@B 4[ RC^p 5+@#?@cG@'<f5+@/\5[@q@TTq@Tzr`TG*!` @`[O!Gg@"@cT{MSN#_+@!G3@'! B[OR_@B4R_q!Tc@45R_k TERk-Tw@4$R_kaTg@4%R_k T!GqG7@qc qqB!@ **`c!@[Og@R5Rc@6RB5RRqTu!G3@! [OR!G3@! [OwR4RG! @[OlG! @[OdG!@[O\G! @[OT[|?#ЄG{c@@c@CB 4 @!`S|ERkT@E R#b|@s`5@v5SCG!G@"@cT{B#_j@G!@@!G3@;! VSC@ G!@SCS ?#G{CS@2 R 5@B&!'!G@"@cT{ASB#_@A!G3@!  ?#{ S R5@SA{è#B! {è#Ռ`@p!G3@!@SA@{è#_?#{! S`@NSA{¨#M?#G{)+S [ 6c *@?5 @t@- k #s  @?#@<R!/$@zK@#Jp 5C9 TaT @@{S@@~+ dtӽ@c"L`5@7@s@`_*@R/@53` 5'@@5 #@4+@`5kLsM@!G3@!*kLsMG?@@B T{HSI[JcK#_@4RG!@GqG@`kLsM@@kLsMG! @kLsM!G3@! ykLsMW!G3@! k s ?#CG{Sc@7c@cBC#+4@!AR@R@,G7@@B!T{GSHC#_G!@/P?#G{Sc@c@7c@3B#)@4Kb RC>P5A$R@A)O @ K@G7@@BAT{GSH#_ @!G3@! 4K@K  ?#G'R{Sc@@c#B3C)  4@4 @!  @ [a" `@`@c5s5 @4ls[EG@@BT{CSD#_ּERk,TG!@s_`[EG!@@^;!G3@!Ҩ[E[p?#G{S c@c@[ c@?3CB`  4 @! [@@@va.@?qa"T}ke@`@J5@ 5[@G?@@BT{HSI[J#_0G!@@6[@[@G!@"[@!G3@! [@[@[  ?#G{ COS C@G(Rc@cB#`` =)#)b 47@?@q?q )ERk;@T 5 D?@! 3qW@a @` =a@[" = @d553@ 4.[@GG@@BT{ISJ#_qo-.[@G!@@-!G3@]!x[@G! @[8?#CG{ COSC(R@gc@cB`` =))? 47@?@q?q)$ERkT;@ 5[/@+@qS'1`#@53@4[OGg@@BT{MSN@C#_;@[q[OyG!@[Od!G3@!` [On[OG! @l[?#{@ ~R  !!.!`!)!!$! "!" @{¨#_ 3@ {{__frame.LZ4F_dctxy*LZ4F_createDecompressionContext failed with code: %sLZ4F_getFrameInfo failed with code: %sLZ4F_freeDecompressionContext failed with code: %sUnrecognized blockSizeID in get_frame_info: %dUnrecognized blockMode in get_frame_info: %dUnrecognized contentChecksumFlag in get_frame_info: %dUnrecognized blockChecksumFlag in get_frame_info: %dUnrecognized frameType in get_frame_info: %dcontent_checksumblock_linkedblock_size_idblock_size{s:I,s:I,s:O,s:O,s:O,s:O,s:K}content_sizeskippableblock_checksumONo valid decompression context suppliedPyCapsule_SetPointer failed with code: %sLZ4F_createCompressionContext failed with code: %s_frame.LZ4F_cctxLZ4F_decompress failed with code: %sFailed to resize bufferFrame incomplete. LZ4F_decompress returned: %zuNiNiOOy*|npy*|ppO|ppFlush without ending a frame is not supported with this version of the LZ4 libraryNo compression context suppliedLZ4F_compressEnd failed with code: %sOy*|pinput data could require %zu bytes, which is larger than the maximum supported size of %zd bytesLZ4F_compressUpdate failed with code: %sO|kiipppppblock_checksum specified but not supported by LZ4 library versionNo valid compression context suppliedLZ4F_compressBegin failed with code: %sy*|iipppppInput data could require %zu bytes, which is larger than the maximum supported size of %zd bytesLZ4F_compressFrame failed with code: %sBLOCKSIZE_DEFAULTBLOCKSIZE_MAX64KBBLOCKSIZE_MAX256KBBLOCKSIZE_MAX1MBBLOCKSIZE_MAX4MBdatacompression_levelstore_sizereturn_bytearraycontextsource_sizeauto_flushend_framereturn_bytes_readmax_length_framecreate_compression_contextcompresscompress_begincompress_chunkcompress_flushget_frame_infocreate_decompression_contextreset_decompression_contextdecompressdecompress_chunkA Python wrapper for the LZ4 frame protocoldecompress_chunk(context, data, max_length=-1) Decompresses part of a frame of compressed data. The returned uncompressed data should be concatenated with the data returned from previous calls to `lz4.frame.decompress_chunk` Args: context (dCtx): decompression context data (str, bytes or buffer-compatible object): part of a LZ4 frame of compressed data Keyword Args: max_length (int): if non-negative this specifies the maximum number of bytes of uncompressed data to return. Default is ``-1``. return_bytearray (bool): If ``True`` a bytearray object will be returned.If ``False``, a string of bytes is returned. The default is ``False``. Returns: tuple: uncompressed data, bytes read, end of frame indicator This function returns a tuple consisting of: - The uncompressed data as a ``bytes`` or ``bytearray`` object - The number of bytes consumed from input ``data`` as an ``int`` - The end of frame indicator as a ``bool``. The end of frame indicator is ``True`` if the end of the compressed frame has been reached, or ``False`` otherwise decompress(data, return_bytearray=False, return_bytes_read=False) Decompresses a frame of data and returns it as a string of bytes. Args: data (str, bytes or buffer-compatible object): data to decompress. This should contain a complete LZ4 frame of compressed data. Keyword Args: return_bytearray (bool): If ``True`` a bytearray object will be returned. If ``False``, a string of bytes is returned. The default is ``False``. return_bytes_read (bool): If ``True`` then the number of bytes read from ``data`` will also be returned. Default is ``False`` Returns: bytes/bytearray or tuple: Uncompressed data and optionally the number of bytes read If the ``return_bytes_read`` argument is ``True`` this function returns a tuple consisting of: - bytes or bytearray: Uncompressed data - int: Number of bytes consumed from ``data`` reset_decompression_context(context) Resets a decompression context object. This is useful for recovering from an error or for stopping an unfinished decompression and starting a new one with the same context Args: context (dCtx): A decompression context create_decompression_context() Creates a decompression context object. A decompression context is needed for decompression operations. Returns: dCtx: A decompression context get_frame_info(frame) Given a frame of compressed data, returns information about the frame. Args: frame (str, bytes or buffer-compatible object): LZ4 compressed frame Returns: dict: Dictionary with keys: - ``block_size`` (int): the maximum size (in bytes) of each block - ``block_size_id`` (int): identifier for maximum block size - ``content_checksum`` (bool): specifies whether the frame contains a checksum of the uncompressed content - ``content_size`` (int): uncompressed size in bytes of frame content - ``block_linked`` (bool): specifies whether the frame contains blocks which are independently compressed (``False``) or linked linked (``True``) - ``block_checksum`` (bool): specifies whether each block contains a checksum of its contents - ``skippable`` (bool): whether the block is skippable (``True``) or not (``False``) compress_flush(context, end_frame=True, return_bytearray=False) Flushes any buffered data held in the compression context. This flushes any data buffed in the compression context, returning it as compressed data. The returned data should be appended to the output of previous calls to ``lz4.frame.compress_chunk``. The ``end_frame`` argument specifies whether or not the frame should be ended. If this is ``True`` and end of frame marker will be appended to the returned data. In this case, if ``content_checksum`` was ``True`` when calling `lz4.frame.compress_begin`, then a checksum of the uncompressed data will also be included in the returned data. If the ``end_frame`` argument is ``True``, the compression context will be reset and can be re-used. Args: context (cCtx): Compression context Keyword Args: end_frame (bool): If ``True`` the frame will be ended. Default is ``True``. return_bytearray (bool): If ``True`` a ``bytearray`` object will be returned. If ``False``, a ``bytes`` object is returned. The default is ``False``. Returns: bytes or bytearray: compressed data. Notes: If ``end_frame`` is ``False`` but the underlying LZ4 library does not support flushing without ending the frame, a ``RuntimeError`` will be raised. compress_chunk(context, data) Compresses blocks of data and returns the compressed data. The returned data should be concatenated with the data returned from `lz4.frame.compress_begin` and any subsequent calls to `lz4.frame.compress_chunk`. Args: context (cCtx): compression context data (str, bytes or buffer-compatible object): data to compress Keyword Args: return_bytearray (bool): If ``True`` a bytearray object will be returned. If ``False``, a string of bytes is returned. The default is False. Returns: bytes or bytearray: Compressed data. Notes: If auto flush is disabled (``auto_flush=False`` when calling `lz4.frame.compress_begin`) this function may buffer and retain some or all of the compressed data for future calls to `lz4.frame.compress`. compress_begin(context, source_size=0, compression_level=0, block_size=0, content_checksum=0, content_size=1, block_linked=0, frame_type=0, auto_flush=1) Creates a frame header from a compression context. Args: context (cCtx): A compression context. Keyword Args: block_size (int): Sepcifies the maximum blocksize to use. Options: - `lz4.frame.BLOCKSIZE_DEFAULT`: the lz4 library default - `lz4.frame.BLOCKSIZE_MAX64KB`: 64 kB - `lz4.frame.BLOCKSIZE_MAX256KB`: 256 kB - `lz4.frame.BLOCKSIZE_MAX1MB`: 1 MB - `lz4.frame.BLOCKSIZE_MAX4MB`: 4 MB If unspecified, will default to `lz4.frame.BLOCKSIZE_DEFAULT` which is currently equal to `lz4.frame.BLOCKSIZE_MAX64KB`. block_linked (bool): Specifies whether to use block-linked compression. If ``True``, the compression ratio is improved, particularly for small block sizes. Default is ``True``. compression_level (int): Specifies the level of compression used. Values between 0-16 are valid, with 0 (default) being the lowest compression (0-2 are the same value), and 16 the highest. Values below 0 will enable "fast acceleration", proportional to the value. Values above 16 will be treated as 16. The following module constants are provided as a convenience: - `lz4.frame.COMPRESSIONLEVEL_MIN`: Minimum compression (0, the default) - `lz4.frame.COMPRESSIONLEVEL_MINHC`: Minimum high-compression mode (3) - `lz4.frame.COMPRESSIONLEVEL_MAX`: Maximum compression (16) content_checksum (bool): Specifies whether to enable checksumming of the uncompressed content. If True, a checksum is stored at the end of the frame, and checked during decompression. Default is ``False``. block_checksum (bool): Specifies whether to enable checksumming of the uncompressed content of each block. If `True` a checksum of the uncompressed data in each block in the frame is stored at the end of each block. If present, these checksums will be used to validate the data during decompression. The default is ``False`` meaning block checksums are not calculated and stored. This functionality is only supported if the underlying LZ4 library has version >= 1.8.0. Attempting to set this value to ``True`` with a version of LZ4 < 1.8.0 will cause a ``RuntimeError`` to be raised. return_bytearray (bool): If ``True`` a ``bytearray`` object will be returned. If ``False``, a string of bytes is returned. The default is ``False``. auto_flush (bool): Enable or disable autoFlush. When autoFlush is disabled the LZ4 library may buffer data internally until a block is full. Default is ``False`` (autoFlush disabled). source_size (int): This optionally specifies the uncompressed size of the data to be compressed. If specified, the size will be stored in the frame header for use during decompression. Default is ``True`` return_bytearray (bool): If ``True`` a bytearray object will be returned. If ``False``, a string of bytes is returned. Default is ``False``. Returns: bytes or bytearray: Frame header. compress(data, compression_level=0, block_size=0, content_checksum=0, block_linked=True, store_size=True, return_bytearray=False) Compresses ``data`` returning the compressed data as a complete frame. The returned data includes a header and endmark and so is suitable for writing to a file. Args: data (str, bytes or buffer-compatible object): data to compress Keyword Args: block_size (int): Sepcifies the maximum blocksize to use. Options: - `lz4.frame.BLOCKSIZE_DEFAULT`: the lz4 library default - `lz4.frame.BLOCKSIZE_MAX64KB`: 64 kB - `lz4.frame.BLOCKSIZE_MAX256KB`: 256 kB - `lz4.frame.BLOCKSIZE_MAX1MB`: 1 MB - `lz4.frame.BLOCKSIZE_MAX4MB`: 4 MB If unspecified, will default to `lz4.frame.BLOCKSIZE_DEFAULT` which is currently equal to `lz4.frame.BLOCKSIZE_MAX64KB`. block_linked (bool): Specifies whether to use block-linked compression. If ``True``, the compression ratio is improved, particularly for small block sizes. Default is ``True``. compression_level (int): Specifies the level of compression used. Values between 0-16 are valid, with 0 (default) being the lowest compression (0-2 are the same value), and 16 the highest. Values below 0 will enable "fast acceleration", proportional to the value. Values above 16 will be treated as 16. The following module constants are provided as a convenience: - `lz4.frame.COMPRESSIONLEVEL_MIN`: Minimum compression (0, the default) - `lz4.frame.COMPRESSIONLEVEL_MINHC`: Minimum high-compression mode (3) - `lz4.frame.COMPRESSIONLEVEL_MAX`: Maximum compression (16) content_checksum (bool): Specifies whether to enable checksumming of the uncompressed content. If True, a checksum is stored at the end of the frame, and checked during decompression. Default is ``False``. block_checksum (bool): Specifies whether to enable checksumming of the uncompressed content of each block. If `True` a checksum of the uncompressed data in each block in the frame is stored at the end of each block. If present, these checksums will be used to validate the data during decompression. The default is ``False`` meaning block checksums are not calculated and stored. This functionality is only supported if the underlying LZ4 library has version >= 1.8.0. Attempting to set this value to ``True`` with a version of LZ4 < 1.8.0 will cause a ``RuntimeError`` to be raised. return_bytearray (bool): If ``True`` a ``bytearray`` object will be returned. If ``False``, a string of bytes is returned. The default is ``False``. store_size (bool): If ``True`` then the frame will include an 8-byte header field that is the uncompressed size of data included within the frame. Default is ``True``. Returns: bytes or bytearray: Compressed data create_compression_context() Creates a compression context object. The compression object is required for compression operations. Returns: cCtx: A compression context ;0`D@0dX4|zRx t0,< @HA BNd$|DA-A DIA-tA-ADCLlKA-A-Q A ~ A ] A M A J A G A G A GBHDA-A@ETUKA-A@-GHO B IC(hA-A0CB] A-A TXA-A0EBLBBA-D0-AA-A0-OBAA-$ԤLA-A DKA-A-AC E BBSCw\V AA OANA-A  -\ BA G BA G AA MAOA,PA-ADDj A-A @$TA-ADENZKA-A-QCH0<$A-A`DRNeK A-A LKINB`|dA-ADGRrLA-A-PBE A L A N A CB<tA-ADD}^K A-A DGILJX PA-ADDCimL A-A BM A KBN A CJ$|A-A F^A-@  BPXo  `8 P oo oo oD00000000000000000000000000000000000000`HIIHPIHHH8II(IHIHHIIHDC`DCIHHHDC`DCHH`I@JhI0 xI. mI@,0`I)]I'WI@TIPSIpRJT&N(JP%pJ/usr/lib/debug/.dwz/aarch64-linux-gnu/python3-lz4.debugOkSL&29a90a846227c0825368d524c86fd5cdfc8bd0.debug.shstrtab.note.gnu.build-id.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.rela.plt.init.text.fini.rodata.eh_frame_hdr.eh_frame.init_array.fini_array.dynamic.got.data.bss.gnu_debugaltlink.gnu_debuglink $o$( 08o dEo @T8 8 P^Bhc00nP)tBBz B B7yy@z@zPPXX````    Ll4