SILENT KILLERPanel

Current Path: > > lib > .build-id > 45


Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

Files and Folders in: //lib/.build-id/45


Warning: filesize(): stat failed for //lib/.build-id/45/33828c59bb1d9031a7edd97b8ea694c4bde5b5 in /home/codekrsu/techflix.lk/cmd2.php on line 136

Warning: filemtime(): stat failed for //lib/.build-id/45/33828c59bb1d9031a7edd97b8ea694c4bde5b5 in /home/codekrsu/techflix.lk/cmd2.php on line 137

Warning: filesize(): stat failed for //lib/.build-id/45/bfda90f2a83a0d82378cd70c24439702e371d9 in /home/codekrsu/techflix.lk/cmd2.php on line 136

Warning: filemtime(): stat failed for //lib/.build-id/45/bfda90f2a83a0d82378cd70c24439702e371d9 in /home/codekrsu/techflix.lk/cmd2.php on line 137
NameTypeSizeLast ModifiedActions
1407a9496cbc55ed6eed7f5cbf2b3f5563dacd File 165656 bytes October 14 2023 13:43:48.
142789c798a066a6c9c7e8190426da8a38d297 File 1019200 bytes November 20 2019 12:04:12.
21a5b26cc6252dd28796a74d128561b79246e1 File 16496 bytes April 02 2024 18:37:43.
2b52e18c5d17591def117dc981dec94ee4f04c File 20056 bytes April 24 2025 07:53:53.
2d91a6b259799a74df966f851e927b17783fe4 File 48736 bytes April 01 2025 13:15:58.
33828c59bb1d9031a7edd97b8ea694c4bde5b5 File bytes January 01 1970 00:00:00.
3607ca30089c087341b77f534bb06935c57334 File 122216 bytes May 29 2025 13:39:54.
3915a979cd37bd9b1123611d0b083e9cd9f572 File 11808 bytes April 24 2025 07:53:53.
414e253b6ba6f9b25516e1296fe650d17a691f File 39296 bytes May 12 2020 18:50:37.
4a9aaa592f61df22b64fd4f3cb90d124fe41ca File 26192 bytes April 17 2024 17:10:40.
553e26fa671bde48299cde2bc03cde77b81e74 File 905312 bytes July 07 2023 17:56:55.
5955e1d651340a577265dd73d30379b5843fff File 121968 bytes June 09 2025 20:31:29.
5dbb05fc132150b7ff6c42f776779bd6d9360d File 87328 bytes September 02 2023 22:23:52.
64e969df6698feaff398cb7c0851a656cd234f File 122376 bytes July 26 2023 14:39:37.
6c4bbe74cf2f9d5bbeaf0d7ae5033456b704ef File 122232 bytes July 26 2023 15:03:21.
76a7383cb0ff03607febebb22ed85e20c8cd93 File 24176 bytes July 28 2025 08:07:20.
7f0eb8982d5a84593845a10fb3cb7fc81f4ee0 File 16048 bytes October 17 2023 18:13:14.
836fc4ce176ee3d5ef6e7bba54d06ec1d7f8eb File 12296 bytes April 22 2025 01:58:57.
931a08e124e3be85787d556bcfbf4ba8906075 File 11776 bytes May 14 2025 12:43:45.
a46ed3d64cf1c501ee8cba1675a4627e52a387 File 12080 bytes April 02 2024 18:37:43.
b475375b0d9667fd2efbb43f7c0f67be0b4d87 File 19976 bytes April 01 2025 13:15:58.
bd922615e90fdb017ee38c33b073a024a19287 File 49392 bytes March 31 2025 10:38:33.
bfda90f2a83a0d82378cd70c24439702e371d9 File bytes January 01 1970 00:00:00.
cfc1b8359e26851a970d754ecca912d133edb0 File 23528 bytes May 31 2024 13:52:42.
d07243410f844ea0cfa7191aca71366ab2896a File 25048 bytes July 26 2023 13:48:04.
dce6fb65cfeae2596b2b53d68089da109d4ddc File 24544 bytes July 04 2025 13:31:17.
ea5445bd550e2302733cd228097711f3ce1fc3 File 11824 bytes May 29 2025 13:39:54.
eadd32bae2bb25d417c9c1c246cf6fba760ba6 File 46232 bytes October 12 2019 00:47:15.

Reading File: //lib/.build-id/45/cfc1b8359e26851a970d754ecca912d133edb0

ELF>�@�T@8	@PP 0-0- 0- �� H-H- H- 888$$000  S�td000  P�td��Q�tdR�td0-0- 0- ��GNUE��5�&��
uN̩�3��@ �BE���|�qX��l ��n��U� �!��6, F"x M �(M  M ��__gmon_start___ITM_deregisterTMCloneTable_ITM_registerTMCloneTable__cxa_finalizePyObject_RichCompareBoolPyExc_RuntimeErrorPyErr_SetStringPyExc_IndexErrorPyArg_UnpackTuplePyExc_TypeError__stack_chk_failPyList_SetSlice_Py_NoneStructPyList_AppendPyInit__heapqPyModule_Create2PyUnicode_DecodeUTF8PyModule_AddObjectlibpython3.5m.so.1.0libpthread.so.0libc.so.6_edata__bss_start_endGLIBC_2.2.5GLIBC_2.4/opt/alt/python35/lib64:/opt/alt/sqlite/usr/lib64nui	�ii
�0- �
8- @
@- @- �K ��K �B �K L L �L �L  K  L t(L �8L  H @L �HL XL �J `L KhL pxL I �L ��L ��L �G �L ��L ��L �G �L ��L P�L �G �L ��L ��L pG �/ �/ �/ �/ 	�/ 
�/ �/ �/ p/ x/ �/ �/ �/ �/ 
�/ �/ �/ �/ ��H��H�i$ H��t��H����5�# �%�# ��h�������h��������h�������h�������h�������h�������h�������h��q������h��a������h	��Q�������%5# D���%-# D���%%# D���%# D���%# D���%
# D���%# D���%�" D���%�" D���%�" DH�=I@ H�B@ H9�tH��" H��t	�����H�=@ H�5@ H)�H��H��H��?H�H�tH��" H��t��fD�����=�? u+UH�=�" H��tH�=� �Y����d�����? ]������w������AWAVAUATUSH��L�oI9��bM��I��H��H�OI��?M�I�L9��1I���#@H�J��H��I��H�0L�L�H�2L9�}QK�$H�XH��H��L9�}�H�4�H�<�1��A���������H�M9n��H��I�N�M�fL9���H�0H9�:�fDM;fub����I�~H��I�L��I�UH�0I�uH�L9�}iL�{�1�I�J�<�N�,������y�H�������[]A\A]A^A_��H��  H�5�	H�8�j���H�������[]A\A]A^A_�fDH��1�[]A\A]A^A_�H��  H�5	H�8�)�����AWAVAUATUSH��L�oI9���I��H�WI��I��J�<�I9�1�eDM9our��tVI�WJ��H�*I��H�0H�9H�8H�1I9�}6I�\$�H�H�4�1�H�,������y������H��[]A\A]A^A_�H��1�[]A\A]A^A_��H�� H�5�H�8�Z���H�������[]A\A]A^A_�H�� H�5 H�8�0���������f���AWAVAUATUSH��L�oI9���M��I��H��H�OI��?M�I�L9�}gI���H�J��I��H�0H�:H�8H�2L9�}IK�$H�XH��H��L9�}�H�4�H�<�1������x@��H�M9ouLH��I�O�H��H��H��H��L��[]A\A]A^A_�?���������H��[]A\A]A^A_�@H�� H�5�H�8�*���H�������[]A\A]A^A_�H�� H�5�H�8����������f�U�H���SH�5�H��(dH�%(H�D$1�L�L$L�D$�����tcH�D$H�P���tYH�xtrH�PH�D$1�H�H�H�H�|$�Յ�uH�L$dH3%(H��uYH��([]�H�+u
H�CH��P01���@H�� H�5A1�H�8�0����fDH�� H�51�H�8��������f���H��H�52������ff.�f���H��H�5��������ff.�f���SH����H�5�H�� dH�%(H�D$1�L�L$L�D$�������H�D$H�P�����H�xH�\$u*H�H�L$dH3%(H����H�� [�f�H�@1�H��H�8�/�����xKtYH�D$H�xt}H�PH�D$1�H�H�H�H�|$������t�H�+uH�CH��P0f.�1��s���f�H�\$�\���fDH�) H�5�1�H�8����=���H�! H�5j1�H�8�x��������^���ff.�AVAUATUSH�G�����H�oH��H��tkH�GI��1�H�u�H��L�d�I�$�����upM��H��tH�C1�H��L�(L� A�օ�u[L��]A\A]A^�DI�mtqE1�[]L��A\A]A^�f�H�a E1�H�5�H�8���[L��]A\A]A^�I�,$u�I�D$L��E1�P0또H�	 H�5�E1�H�8�w����y���f�I�EL��P0������H��H�5�������ff.�f���H��H�5�������ff.�f�AWAVAUATUSH��H�G����1H�GH��I��H=�	oH��H��?H�H�H��y�?f.�H��H���t+H��H��A�ԅ�t�1�H��[]A\A]A^A_�I��M9���H�$ H�H��[]A\A]A^A_ÐI��1�I�M�o@I���I��u�I��H��M�u�L9�?H�@�H�D$L���fD��tH�H��H��A�ԅ�t��m���fDI��L;t$u�I��I��M9��i���L�������G���H�H��H��A�ԅ�t��!���f.�H�I H�5�H�8���1������H��H�5���}���ff.�f���H��H�5b����]���ff.�f���H��(H����dH�%(H�D$1�L�L$L�D$H�5j�e�����t_H�|$H�G���t7H�t$�5�����u?H�|$1�H�GH�P�������u'H�� H��@H�a H�5�H�8���1�H�L$dH3%(uH��(���fD��S��H�=�3 ���H��H��tbH�
; H�΋H����������!�%����t������D�H�VHD��@�H�= H��1�H)���H�5tH��H����H��[���H��H���index out of rangeheapreplaceheap argument must be a listheappushpopheappush__about___heapqheappopheapify_heappop_max_heapreplace_max_heapify_maxlist changed size during iteration;���0�����0���l0����`���dP����p������������@���T0���h�����������������zRx�$��FJw�?:*3$"DP�x\��F�B�B �B(�A0�A8�D@
8F0A(B BBBHZ
8F0A(B BBBGD
8C0A(B BBBAx���B�B�B �B(�A0�A8�D@|
8A0A(B BBBDD
8C0A(B BBBHZ
8F0A(B BBBAxT@���'F�B�B �B(�A0�A8�D@�
8J0A(B BBBLI
8A0A(B BBBEZ
8F0A(B BBBA(���A�N�K@s
AAA�������� $���RE�X0h
AJ`H����B�B�B �A(�A0�`
(D BBBFK
(A EBBCZ
(D BBBD����������`�����mB�B�B �B(�A0�A8�DP_
8A0A(B BBBA\
8A0A(B BBBB8���L���`���H0�
A|�����E�GNU��
@
@- I^n�`
(0- 8- ���o`��
�X/ �p
��	���o���o����o�o����oH- ������� Heap queues

[explanation by François Pinard]

Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0.  For the sake of comparison,
non-existing elements are considered to be infinite.  The interesting
property of a heap is that a[0] is always its smallest element.

The strange invariant above is meant to be an efficient memory
representation for a tournament.  The numbers below are `k', not a[k]:

                                   0

                  1                                 2

          3               4                5               6

      7       8       9       10      11      12      13      14

    15 16   17 18   19 20   21 22   23 24   25 26   27 28   29 30


In the tree above, each cell `k' is topping `2*k+1' and `2*k+2'.  In
a usual binary tournament we see in sports, each cell is the winner
over the two cells it tops, and we can trace the winner down the tree
to see all opponents s/he had.  However, in many computer applications
of such tournaments, we do not need to trace the history of a winner.
To be more memory efficient, when a winner is promoted, we try to
replace it by something else at a lower level, and the rule becomes
that a cell and the two cells it tops contain three different items,
but the top cell "wins" over the two topped cells.

If this heap invariant is protected at all time, index 0 is clearly
the overall winner.  The simplest algorithmic way to remove it and
find the "next" winner is to move some loser (let's say cell 30 in the
diagram above) into the 0 position, and then percolate this new 0 down
the tree, exchanging values, until the invariant is re-established.
This is clearly logarithmic on the total number of items in the tree.
By iterating over all items, you get an O(n ln n) sort.

A nice feature of this sort is that you can efficiently insert new
items while the sort is going on, provided that the inserted items are
not "better" than the last 0'th element you extracted.  This is
especially useful in simulation contexts, where the tree holds all
incoming events, and the "win" condition means the smallest scheduled
time.  When an event schedule other events for execution, they are
scheduled into the future, so they can easily go into the heap.  So, a
heap is a good structure for implementing schedulers (this is what I
used for my MIDI sequencer :-).

Various structures for implementing schedulers have been extensively
studied, and heaps are good for this, as they are reasonably speedy,
the speed is almost constant, and the worst case is not much different
than the average case.  However, there are other representations which
are more efficient overall, yet the worst cases might be terrible.

Heaps are also very useful in big disk sorts.  You most probably all
know that a big sort implies producing "runs" (which are pre-sorted
sequences, which size is usually related to the amount of CPU memory),
followed by a merging passes for these runs, which merging is often
very cleverly organised[1].  It is very important that the initial
sort produces the longest runs possible.  Tournaments are a good way
to that.  If, using all the memory available to hold a tournament, you
replace and percolate items that happen to fit the current run, you'll
produce runs which are twice the size of the memory for random input,
and much better for input fuzzily ordered.

Moreover, if you output the 0'th item on disk and get an input which
may not fit in the current tournament (because the value "wins" over
the last output value), it cannot fit in the heap, so the size of the
heap decreases.  The freed memory could be cleverly reused immediately
for progressively building a second heap, which grows at exactly the
same rate the first heap is melting.  When the first heap completely
vanishes, you switch heaps and start a new run.  Clever and quite
effective!

In a word, heaps are useful memory structures to know.  I use them in
a few applications, and I think it is good to keep a `heap' module
around. :-)

--------------------
[1] The disk balancing algorithms which are current, nowadays, are
more annoying than clever, and this is a consequence of the seeking
capabilities of the disks.  On devices which cannot seek, like big
tape drives, the story was quite different, and one had to be very
clever to ensure (far in advance) that each tape movement will be the
most effective possible (that is, will best participate at
"progressing" the merge).  Some tapes were even able to read
backwards, and this was also used to avoid the rewinding time.
Believe me, real good tape sorts were quite spectacular to watch!
From all times, sorting has always been a Great Art! :-)
Heap queue algorithm (a.k.a. priority queue).

Heaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for
all k, counting elements from 0.  For the sake of comparison,
non-existing elements are considered to be infinite.  The interesting
property of a heap is that a[0] is always its smallest element.

Usage:

heap = []            # creates an empty heap
heappush(heap, item) # pushes a new item on the heap
item = heappop(heap) # pops the smallest item from the heap
item = heap[0]       # smallest item on the heap without popping it
heapify(x)           # transforms list into a heap, in-place, in linear time
item = heapreplace(heap, item) # pops and returns smallest item, and adds
                               # new item; the heap size is unchanged

Our API differs from textbook heap algorithms as follows:

- We use 0-based indexing.  This makes the relationship between the
  index for a node and the indexes for its children slightly less
  obvious, but is more suitable since Python uses 0-based indexing.

- Our heappop() method returns the smallest item, not the largest.

These two make it possible to view the heap as a regular Python list
without surprises: heap[0] is the smallest item, and heap.sort()
maintains the heap invariant!
Maxheap variant of heapify.Maxheap variant of heapreplaceMaxheap variant of heappop.Transform list into a heap, in-place, in O(len(heap)) time.heappushpop(heap, item) -> value. Push item on the heap, then pop and return the smallest item
from the heap. The combined action runs more efficiently than
heappush() followed by a separate call to heappop().heapreplace(heap, item) -> value. Pop and return the current smallest value, and add the new item.

This is more efficient than heappop() followed by heappush(), and can be
more appropriate when using a fixed-size heap.  Note that the value
returned may be larger than item!  That constrains reasonable uses of
this routine unless written as part of a conditional replacement:

    if item > heap[0]:
        item = heapreplace(heap, item)
Pop the smallest item off the heap, maintaining the heap invariant.heappush(heap, item) -> None. Push item onto heap, maintaining the heap invariant.��B ��������L �� K t� H ��J KpI ���G ���G �P�G ��pG GA$3a1`5GA$3p1113�
%GA*GA$annobin gcc 8.5.0 20210514GA$plugin name: annobinGA$running gcc 8.5.0 20210514GA*GA*GA!
GA*FORTIFYGA+GLIBCXX_ASSERTIONSGA*GOW*�GA*cf_protectionGA+omit_frame_pointerGA+stack_clashGA!stack_realign
GA*FORTIFY�
)GA+GLIBCXX_ASSERTIONS_heapq.cpython-35m-x86_64-linux-gnu.so-3.5.9-7.el8.x86_64.debug�7j�7zXZ�ִF!t/���]?�E�h=��ڊ�2N�`ca ��)����t�q��F&y�~�V������eE�Ι����ևʱ�IXG��C�]CÊ�L܌]Rm�R;--K0H�
78
W�R��?е��Aݓ%��wD-}��C��e��]+�6Q��!�2�"a�0���tB'	@�2ZdK8�$�klU��x���f���tа�|�Jv�"w�U��ۥQW�4p��b؞"̝r�̝k]��WӺ;(�c�7��z�η�6O��-��V������+-��mX]ot�[�s� �5�~T��E��+�郵�mS�uX�n���s��A�k�ux}3O-X]Z��{�%���m�ߪ�R!�#C�۪���já�� ��;RD;�I����ͅ`��'R��H"j�9�㳜��#8枀��
�P}Qܐ�)Z��,�o��������f���6�#<לqg7���v~d�{"�y�S��՞��#I
~G�B�/��X�<�njX_�홀y�׃�`��a���(���\]3®�J`��;j���2O=��*4Ǥ��Q钞�o}��.
@s�_��%�V
�r�v�l*�:)fA9�õ���-���=>/�i�"�s��pc�+�V�H����۩!S0�D�W��]�jc�O��9lк����O�2ĕنDk�΋Qb;n��0�= ԺOV���]��Zc�e��J*B "�<z���x>!?"z18E��6�&ԭE�1�<����k���Ϻ�`�D�����y6���<�e��s�1�f#4��hФ�"ƿ���v��Lx�H\���iR�\lcCE �ޮ�����gh:�
�e��j��b]�C���
Ƕ�(�<{��Ռ�ף�x������2��%��;'
@ܢg�Ur<�f��Zq��)u\Y��!��S�冷�� �z���g�YZ.shstrtab.note.gnu.build-id.gnu.hash.dynsym.dynstr.gnu.version.gnu.version_r.rela.dyn.rela.plt.init.plt.sec.text.fini.rodata.eh_frame_hdr.eh_frame.note.gnu.property.init_array.fini_array.data.rel.ro.dynamic.got.data.bss.gnu.build.attributes.gnu_debuglink.gnu_debugdata88$���o``4(��0���8���o��,E���o��0T���^Bp
p
�h``c���n00�w��U}((
�288��������00 �0- 0-�8- 8-�@- @-�H- H-�X/ X/��0 0  � M  M�(M` MD
dOD�O��S(

SILENT KILLER Tool