1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
/*------------------------------------------------------------------------- * * generic.h * Implement higher level operations based on some lower level atomic * operations. * * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * * src/include/port/atomics/generic.h * *------------------------------------------------------------------------- */ /* intentionally no include guards, should only be included by atomics.h */ #ifndef INSIDE_ATOMICS_H # error "should be included via atomics.h" #endif /* * If read or write barriers are undefined, we upgrade them to full memory * barriers. */ #if !defined(pg_read_barrier_impl) # define pg_read_barrier_impl pg_memory_barrier_impl #endif #if !defined(pg_write_barrier_impl) # define pg_write_barrier_impl pg_memory_barrier_impl #endif #ifndef PG_HAVE_SPIN_DELAY #define PG_HAVE_SPIN_DELAY #define pg_spin_delay_impl() ((void)0) #endif /* provide fallback */ #if !defined(PG_HAVE_ATOMIC_FLAG_SUPPORT) && defined(PG_HAVE_ATOMIC_U32_SUPPORT) #define PG_HAVE_ATOMIC_FLAG_SUPPORT typedef pg_atomic_uint32 pg_atomic_flag; #endif #ifndef PG_HAVE_ATOMIC_READ_U32 #define PG_HAVE_ATOMIC_READ_U32 static inline uint32 pg_atomic_read_u32_impl(volatile pg_atomic_uint32 *ptr) { return ptr->value; } #endif #ifndef PG_HAVE_ATOMIC_WRITE_U32 #define PG_HAVE_ATOMIC_WRITE_U32 static inline void pg_atomic_write_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 val) { ptr->value = val; } #endif #ifndef PG_HAVE_ATOMIC_UNLOCKED_WRITE_U32 #define PG_HAVE_ATOMIC_UNLOCKED_WRITE_U32 static inline void pg_atomic_unlocked_write_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 val) { ptr->value = val; } #endif /* * provide fallback for test_and_set using atomic_exchange if available */ #if !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) && defined(PG_HAVE_ATOMIC_EXCHANGE_U32) #define PG_HAVE_ATOMIC_INIT_FLAG static inline void pg_atomic_init_flag_impl(volatile pg_atomic_flag *ptr) { pg_atomic_write_u32_impl(ptr, 0); } #define PG_HAVE_ATOMIC_TEST_SET_FLAG static inline bool pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) { return pg_atomic_exchange_u32_impl(ptr, 1) == 0; } #define PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG static inline bool pg_atomic_unlocked_test_flag_impl(volatile pg_atomic_flag *ptr) { return pg_atomic_read_u32_impl(ptr) == 0; } #define PG_HAVE_ATOMIC_CLEAR_FLAG static inline void pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) { /* XXX: release semantics suffice? */ pg_memory_barrier_impl(); pg_atomic_write_u32_impl(ptr, 0); } /* * provide fallback for test_and_set using atomic_compare_exchange if * available. */ #elif !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_INIT_FLAG static inline void pg_atomic_init_flag_impl(volatile pg_atomic_flag *ptr) { pg_atomic_write_u32_impl(ptr, 0); } #define PG_HAVE_ATOMIC_TEST_SET_FLAG static inline bool pg_atomic_test_set_flag_impl(volatile pg_atomic_flag *ptr) { uint32 value = 0; return pg_atomic_compare_exchange_u32_impl(ptr, &value, 1); } #define PG_HAVE_ATOMIC_UNLOCKED_TEST_FLAG static inline bool pg_atomic_unlocked_test_flag_impl(volatile pg_atomic_flag *ptr) { return pg_atomic_read_u32_impl(ptr) == 0; } #define PG_HAVE_ATOMIC_CLEAR_FLAG static inline void pg_atomic_clear_flag_impl(volatile pg_atomic_flag *ptr) { /* XXX: release semantics suffice? */ pg_memory_barrier_impl(); pg_atomic_write_u32_impl(ptr, 0); } #elif !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) # error "No pg_atomic_test_and_set provided" #endif /* !defined(PG_HAVE_ATOMIC_TEST_SET_FLAG) */ #ifndef PG_HAVE_ATOMIC_INIT_U32 #define PG_HAVE_ATOMIC_INIT_U32 static inline void pg_atomic_init_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 val_) { ptr->value = val_; } #endif #if !defined(PG_HAVE_ATOMIC_EXCHANGE_U32) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_EXCHANGE_U32 static inline uint32 pg_atomic_exchange_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 xchg_) { uint32 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u32_impl(ptr, &old, xchg_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_ADD_U32) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_FETCH_ADD_U32 static inline uint32 pg_atomic_fetch_add_u32_impl(volatile pg_atomic_uint32 *ptr, int32 add_) { uint32 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u32_impl(ptr, &old, old + add_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_SUB_U32) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_FETCH_SUB_U32 static inline uint32 pg_atomic_fetch_sub_u32_impl(volatile pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_fetch_add_u32_impl(ptr, -sub_); } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_AND_U32) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_FETCH_AND_U32 static inline uint32 pg_atomic_fetch_and_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 and_) { uint32 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u32_impl(ptr, &old, old & and_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_OR_U32) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U32) #define PG_HAVE_ATOMIC_FETCH_OR_U32 static inline uint32 pg_atomic_fetch_or_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 or_) { uint32 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u32_impl(ptr, &old, old | or_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_ADD_FETCH_U32) && defined(PG_HAVE_ATOMIC_FETCH_ADD_U32) #define PG_HAVE_ATOMIC_ADD_FETCH_U32 static inline uint32 pg_atomic_add_fetch_u32_impl(volatile pg_atomic_uint32 *ptr, int32 add_) { return pg_atomic_fetch_add_u32_impl(ptr, add_) + add_; } #endif #if !defined(PG_HAVE_ATOMIC_SUB_FETCH_U32) && defined(PG_HAVE_ATOMIC_FETCH_SUB_U32) #define PG_HAVE_ATOMIC_SUB_FETCH_U32 static inline uint32 pg_atomic_sub_fetch_u32_impl(volatile pg_atomic_uint32 *ptr, int32 sub_) { return pg_atomic_fetch_sub_u32_impl(ptr, sub_) - sub_; } #endif #if !defined(PG_HAVE_ATOMIC_READ_MEMBARRIER_U32) && defined(PG_HAVE_ATOMIC_FETCH_ADD_U32) #define PG_HAVE_ATOMIC_READ_MEMBARRIER_U32 static inline uint32 pg_atomic_read_membarrier_u32_impl(volatile pg_atomic_uint32 *ptr) { return pg_atomic_fetch_add_u32_impl(ptr, 0); } #endif #if !defined(PG_HAVE_ATOMIC_WRITE_MEMBARRIER_U32) && defined(PG_HAVE_ATOMIC_EXCHANGE_U32) #define PG_HAVE_ATOMIC_WRITE_MEMBARRIER_U32 static inline void pg_atomic_write_membarrier_u32_impl(volatile pg_atomic_uint32 *ptr, uint32 val) { (void) pg_atomic_exchange_u32_impl(ptr, val); } #endif #if !defined(PG_HAVE_ATOMIC_EXCHANGE_U64) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64) #define PG_HAVE_ATOMIC_EXCHANGE_U64 static inline uint64 pg_atomic_exchange_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 xchg_) { uint64 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u64_impl(ptr, &old, xchg_)) /* skip */; return old; } #endif #ifndef PG_HAVE_ATOMIC_WRITE_U64 #define PG_HAVE_ATOMIC_WRITE_U64 #if defined(PG_HAVE_8BYTE_SINGLE_COPY_ATOMICITY) && \ !defined(PG_HAVE_ATOMIC_U64_SIMULATION) static inline void pg_atomic_write_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 val) { /* * On this platform aligned 64bit writes are guaranteed to be atomic, * except if using the fallback implementation, where can't guarantee the * required alignment. */ AssertPointerAlignment(ptr, 8); ptr->value = val; } #else static inline void pg_atomic_write_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 val) { /* * 64 bit writes aren't safe on all platforms. In the generic * implementation implement them as an atomic exchange. */ pg_atomic_exchange_u64_impl(ptr, val); } #endif /* PG_HAVE_8BYTE_SINGLE_COPY_ATOMICITY && !PG_HAVE_ATOMIC_U64_SIMULATION */ #endif /* PG_HAVE_ATOMIC_WRITE_U64 */ #ifndef PG_HAVE_ATOMIC_READ_U64 #define PG_HAVE_ATOMIC_READ_U64 #if defined(PG_HAVE_8BYTE_SINGLE_COPY_ATOMICITY) && \ !defined(PG_HAVE_ATOMIC_U64_SIMULATION) static inline uint64 pg_atomic_read_u64_impl(volatile pg_atomic_uint64 *ptr) { /* * On this platform aligned 64-bit reads are guaranteed to be atomic. */ AssertPointerAlignment(ptr, 8); return ptr->value; } #else static inline uint64 pg_atomic_read_u64_impl(volatile pg_atomic_uint64 *ptr) { uint64 old = 0; /* * 64-bit reads aren't atomic on all platforms. In the generic * implementation implement them as a compare/exchange with 0. That'll * fail or succeed, but always return the old value. Possibly might store * a 0, but only if the previous value also was a 0 - i.e. harmless. */ pg_atomic_compare_exchange_u64_impl(ptr, &old, 0); return old; } #endif /* PG_HAVE_8BYTE_SINGLE_COPY_ATOMICITY && !PG_HAVE_ATOMIC_U64_SIMULATION */ #endif /* PG_HAVE_ATOMIC_READ_U64 */ #ifndef PG_HAVE_ATOMIC_INIT_U64 #define PG_HAVE_ATOMIC_INIT_U64 static inline void pg_atomic_init_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 val_) { ptr->value = val_; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_ADD_U64) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64) #define PG_HAVE_ATOMIC_FETCH_ADD_U64 static inline uint64 pg_atomic_fetch_add_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_) { uint64 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u64_impl(ptr, &old, old + add_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_SUB_U64) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64) #define PG_HAVE_ATOMIC_FETCH_SUB_U64 static inline uint64 pg_atomic_fetch_sub_u64_impl(volatile pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_fetch_add_u64_impl(ptr, -sub_); } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_AND_U64) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64) #define PG_HAVE_ATOMIC_FETCH_AND_U64 static inline uint64 pg_atomic_fetch_and_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 and_) { uint64 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u64_impl(ptr, &old, old & and_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_FETCH_OR_U64) && defined(PG_HAVE_ATOMIC_COMPARE_EXCHANGE_U64) #define PG_HAVE_ATOMIC_FETCH_OR_U64 static inline uint64 pg_atomic_fetch_or_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 or_) { uint64 old; old = ptr->value; /* ok if read is not atomic */ while (!pg_atomic_compare_exchange_u64_impl(ptr, &old, old | or_)) /* skip */; return old; } #endif #if !defined(PG_HAVE_ATOMIC_ADD_FETCH_U64) && defined(PG_HAVE_ATOMIC_FETCH_ADD_U64) #define PG_HAVE_ATOMIC_ADD_FETCH_U64 static inline uint64 pg_atomic_add_fetch_u64_impl(volatile pg_atomic_uint64 *ptr, int64 add_) { return pg_atomic_fetch_add_u64_impl(ptr, add_) + add_; } #endif #if !defined(PG_HAVE_ATOMIC_SUB_FETCH_U64) && defined(PG_HAVE_ATOMIC_FETCH_SUB_U64) #define PG_HAVE_ATOMIC_SUB_FETCH_U64 static inline uint64 pg_atomic_sub_fetch_u64_impl(volatile pg_atomic_uint64 *ptr, int64 sub_) { return pg_atomic_fetch_sub_u64_impl(ptr, sub_) - sub_; } #endif #if !defined(PG_HAVE_ATOMIC_READ_MEMBARRIER_U64) && defined(PG_HAVE_ATOMIC_FETCH_ADD_U64) #define PG_HAVE_ATOMIC_READ_MEMBARRIER_U64 static inline uint64 pg_atomic_read_membarrier_u64_impl(volatile pg_atomic_uint64 *ptr) { return pg_atomic_fetch_add_u64_impl(ptr, 0); } #endif #if !defined(PG_HAVE_ATOMIC_WRITE_MEMBARRIER_U64) && defined(PG_HAVE_ATOMIC_EXCHANGE_U64) #define PG_HAVE_ATOMIC_WRITE_MEMBARRIER_U64 static inline void pg_atomic_write_membarrier_u64_impl(volatile pg_atomic_uint64 *ptr, uint64 val) { (void) pg_atomic_exchange_u64_impl(ptr, val); } #endif