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
// Copyright 2018 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_ #define ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_ #include #include #include #include #include #include #include "absl/hash/hash.h" #include "absl/hash/internal/weakly_mixed_integer.h" #include "absl/strings/match.h" #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace hash_internal { // SpyHashState is an implementation of the HashState API that simply // accumulates all input bytes in an internal buffer. This makes it useful // for testing AbslHashValue overloads (so long as they are templated on the // HashState parameter), since it can report the exact hash representation // that the AbslHashValue overload produces. // // Sample usage: // EXPECT_EQ(SpyHashState::combine(SpyHashState(), foo), // SpyHashState::combine(SpyHashState(), bar)); template class SpyHashStateImpl : public HashStateBase> { public: SpyHashStateImpl() : error_(std::make_shared>()) { static_assert(std::is_void::value, ""); } // Move-only SpyHashStateImpl(const SpyHashStateImpl&) = delete; SpyHashStateImpl& operator=(const SpyHashStateImpl&) = delete; SpyHashStateImpl(SpyHashStateImpl&& other) noexcept { *this = std::move(other); } SpyHashStateImpl& operator=(SpyHashStateImpl&& other) noexcept { hash_representation_ = std::move(other.hash_representation_); error_ = other.error_; moved_from_ = other.moved_from_; other.moved_from_ = true; return *this; } template SpyHashStateImpl(SpyHashStateImpl&& other) { // NOLINT hash_representation_ = std::move(other.hash_representation_); error_ = other.error_; moved_from_ = other.moved_from_; other.moved_from_ = true; } template static SpyHashStateImpl combine(SpyHashStateImpl s, const A& a, const Args&... args) { // Pass an instance of SpyHashStateImpl when trying to combine `A`. This // allows us to test that the user only uses this instance for combine calls // and does not call AbslHashValue directly. // See AbslHashValue implementation at the bottom. s = SpyHashStateImpl::HashStateBase::combine(std::move(s), a); return SpyHashStateImpl::combine(std::move(s), args...); } static SpyHashStateImpl combine(SpyHashStateImpl s) { if (direct_absl_hash_value_error_) { *s.error_ = "AbslHashValue should not be invoked directly."; } else if (s.moved_from_) { *s.error_ = "Used moved-from instance of the hash state object."; } return s; } static void SetDirectAbslHashValueError() { direct_absl_hash_value_error_ = true; } // Two SpyHashStateImpl objects are equal if they hold equal hash // representations. friend bool operator==(const SpyHashStateImpl& lhs, const SpyHashStateImpl& rhs) { return lhs.hash_representation_ == rhs.hash_representation_; } friend bool operator!=(const SpyHashStateImpl& lhs, const SpyHashStateImpl& rhs) { return !(lhs == rhs); } enum class CompareResult { kEqual, kASuffixB, kBSuffixA, kUnequal, }; static CompareResult Compare(const SpyHashStateImpl& a, const SpyHashStateImpl& b) { const std::string a_flat = absl::StrJoin(a.hash_representation_, ""); const std::string b_flat = absl::StrJoin(b.hash_representation_, ""); if (a_flat == b_flat) return CompareResult::kEqual; if (absl::EndsWith(a_flat, b_flat)) return CompareResult::kBSuffixA; if (absl::EndsWith(b_flat, a_flat)) return CompareResult::kASuffixB; return CompareResult::kUnequal; } // operator<< prints the hash representation as a hex and ASCII dump, to // facilitate debugging. friend std::ostream& operator<<(std::ostream& out, const SpyHashStateImpl& hash_state) { out << "[\n"; for (auto& s : hash_state.hash_representation_) { size_t offset = 0; for (char c : s) { if (offset % 16 == 0) { out << absl::StreamFormat("\n0x%04x: ", offset); } if (offset % 2 == 0) { out << " "; } out << absl::StreamFormat("%02x", c); ++offset; } out << "\n"; } return out << "]"; } // The base case of the combine recursion, which writes raw bytes into the // internal buffer. static SpyHashStateImpl combine_contiguous(SpyHashStateImpl hash_state, const unsigned char* begin, size_t size) { if (size == 0) { return SpyHashStateImpl::combine_raw(std::move(hash_state), 0); } const size_t large_chunk_stride = PiecewiseChunkSize(); // Combining a large contiguous buffer must have the same effect as // doing it piecewise by the stride length, followed by the (possibly // empty) remainder. while (size > large_chunk_stride) { hash_state = SpyHashStateImpl::combine_contiguous( std::move(hash_state), begin, large_chunk_stride); begin += large_chunk_stride; size -= large_chunk_stride; } if (size > 0) { hash_state.hash_representation_.emplace_back( reinterpret_cast(begin), size); hash_state = SpyHashStateImpl::combine_raw(std::move(hash_state), size); } return hash_state; } static SpyHashStateImpl combine_weakly_mixed_integer( SpyHashStateImpl hash_state, WeaklyMixedInteger value) { return combine(std::move(hash_state), value.value); } using SpyHashStateImpl::HashStateBase::combine_contiguous; template static SpyHashStateImpl RunCombineUnordered(SpyHashStateImpl state, CombinerT combiner) { UnorderedCombinerCallback cb; combiner(SpyHashStateImpl{}, std::ref(cb)); std::sort(cb.element_hash_representations.begin(), cb.element_hash_representations.end()); state.hash_representation_.insert(state.hash_representation_.end(), cb.element_hash_representations.begin(), cb.element_hash_representations.end()); if (cb.error && cb.error->has_value()) { state.error_ = std::move(cb.error); } return state; } absl::optional error() const { if (moved_from_) { return "Returned a moved-from instance of the hash state object."; } return *error_; } private: template friend class SpyHashStateImpl; friend struct CombineRaw; struct UnorderedCombinerCallback { std::vector element_hash_representations; std::shared_ptr> error; // The inner spy can have a different type. template void operator()(SpyHashStateImpl& inner) { element_hash_representations.push_back( absl::StrJoin(inner.hash_representation_, "")); if (inner.error_->has_value()) { error = std::move(inner.error_); } inner = SpyHashStateImpl{}; } }; // Combines raw data from e.g. integrals/floats/pointers/etc. static SpyHashStateImpl combine_raw(SpyHashStateImpl state, uint64_t value) { state.hash_representation_.emplace_back( reinterpret_cast(&value), 8); return state; } // This is true if SpyHashStateImpl has been passed to a call of // AbslHashValue with the wrong type. This detects that the user called // AbslHashValue directly (because the hash state type does not match). static bool direct_absl_hash_value_error_; std::vector hash_representation_; // This is a shared_ptr because we want all instances of the particular // SpyHashState run to share the field. This way we can set the error for // use-after-move and all the copies will see it. std::shared_ptr> error_; bool moved_from_ = false; }; template bool SpyHashStateImpl::direct_absl_hash_value_error_; template struct OdrUse { constexpr OdrUse() {} bool& b = B; }; template struct RunOnStartup { static bool run; static constexpr OdrUse kOdrUse{}; }; template bool RunOnStartup::run = (f(), true); template < typename T, typename U, // Only trigger for when (T != U), typename = absl::enable_if_t::value>, // This statement works in two ways: // - First, it instantiates RunOnStartup and forces the initialization of // `run`, which set the global variable. // - Second, it triggers a SFINAE error disabling the overload to prevent // compile time errors. If we didn't disable the overload we would get // ambiguous overload errors, which we don't want. int = RunOnStartup::SetDirectAbslHashValueError>::run> void AbslHashValue(SpyHashStateImpl, const U&); using SpyHashState = SpyHashStateImpl; } // namespace hash_internal ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_HASH_INTERNAL_SPY_HASH_STATE_H_