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 2020 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_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ #define ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_ #include #include #include #include "absl/base/attributes.h" #include "absl/base/nullability.h" #include "absl/meta/type_traits.h" #include "absl/status/status.h" #include "absl/strings/string_view.h" #include "absl/utility/utility.h" namespace absl { ABSL_NAMESPACE_BEGIN template class ABSL_MUST_USE_RESULT StatusOr; namespace internal_statusor { // Detects whether `U` has conversion operator to `StatusOr`, i.e. `operator // StatusOr()`. template struct HasConversionOperatorToStatusOr : std::false_type {}; template void test(char (*absl_nullable)[sizeof( std::declval().operator absl::StatusOr())]); template struct HasConversionOperatorToStatusOr(0))> : std::true_type {}; // Detects whether `T` is equality-comparable. template struct IsEqualityComparable : std::false_type {}; template struct IsEqualityComparable< T, std::enable_if_t() == std::declval()), bool>::value>> : std::true_type {}; // Detects whether `T` is constructible or convertible from `StatusOr`. template using IsConstructibleOrConvertibleFromStatusOr = absl::disjunction&>, std::is_constructible&>, std::is_constructible&&>, std::is_constructible&&>, std::is_convertible&, T>, std::is_convertible&, T>, std::is_convertible&&, T>, std::is_convertible&&, T>>; // Detects whether `T` is constructible or convertible or assignable from // `StatusOr`. template using IsConstructibleOrConvertibleOrAssignableFromStatusOr = absl::disjunction, std::is_assignable&>, std::is_assignable&>, std::is_assignable&&>, std::is_assignable&&>>; // Detects whether direct initializing `StatusOr` from `U` is ambiguous, i.e. // when `U` is `StatusOr` and `T` is constructible or convertible from `V`. template struct IsDirectInitializationAmbiguous : public absl::conditional_t< std::is_same, U>::value, std::false_type, IsDirectInitializationAmbiguous>> {}; template struct IsDirectInitializationAmbiguous> : public IsConstructibleOrConvertibleFromStatusOr {}; // Checks whether the conversion from U to T can be done without dangling // temporaries. // REQUIRES: T and U are references. template using IsReferenceConversionValid = absl::conjunction< // std::is_reference, std::is_reference, // The references are convertible. This checks for // lvalue/rvalue compatibility. std::is_convertible, // The pointers are convertible. This checks we don't have // a temporary. std::is_convertible*, std::remove_reference_t*>>; // Checks against the constraints of the direction initialization, i.e. when // `StatusOr::StatusOr(U&&)` should participate in overload resolution. template using IsDirectInitializationValid = absl::disjunction< // Short circuits if T is basically U. std::is_same>, // std::conditional_t< std::is_reference_v, // IsReferenceConversionValid, absl::negation, absl::remove_cvref_t>, std::is_same>, std::is_same>, IsDirectInitializationAmbiguous>>>>; // This trait detects whether `StatusOr::operator=(U&&)` is ambiguous, which // is equivalent to whether all the following conditions are met: // 1. `U` is `StatusOr`. // 2. `T` is constructible and assignable from `V`. // 3. `T` is constructible and assignable from `U` (i.e. `StatusOr`). // For example, the following code is considered ambiguous: // (`T` is `bool`, `U` is `StatusOr`, `V` is `bool`) // StatusOr s1 = true; // s1.ok() && s1.ValueOrDie() == true // StatusOr s2 = false; // s2.ok() && s2.ValueOrDie() == false // s1 = s2; // ambiguous, `s1 = s2.ValueOrDie()` or `s1 = bool(s2)`? template struct IsForwardingAssignmentAmbiguous : public absl::conditional_t< std::is_same, U>::value, std::false_type, IsForwardingAssignmentAmbiguous>> {}; template struct IsForwardingAssignmentAmbiguous> : public IsConstructibleOrConvertibleOrAssignableFromStatusOr {}; // Checks against the constraints of the forwarding assignment, i.e. whether // `StatusOr::operator(U&&)` should participate in overload resolution. template using IsForwardingAssignmentValid = absl::disjunction< // Short circuits if T is basically U. std::is_same>, absl::negation, absl::remove_cvref_t>, std::is_same>, std::is_same>, IsForwardingAssignmentAmbiguous>>>; template using Equality = std::conditional_t>; template using IsConstructionValid = absl::conjunction< Equality, type_traits_internal::IsLifetimeBoundAssignment>>, IsDirectInitializationValid, std::is_constructible, Equality>, absl::disjunction< std::is_same>, absl::conjunction< std::conditional_t< Explicit, absl::negation>, absl::negation>>, absl::negation< internal_statusor::HasConversionOperatorToStatusOr>>>>; template using IsAssignmentValid = absl::conjunction< Equality, type_traits_internal::IsLifetimeBoundAssignment>>, std::conditional_t, IsReferenceConversionValid, absl::conjunction, std::is_assignable>>, absl::disjunction< std::is_same>, absl::conjunction< absl::negation>, absl::negation>>>, IsForwardingAssignmentValid>; template using IsConstructionFromStatusValid = absl::conjunction< absl::negation, absl::remove_cvref_t>>, absl::negation>>, absl::negation>>, Equality>, std::is_constructible, absl::negation>>; template using IsConstructionFromStatusOrValid = absl::conjunction< absl::negation>, // If `T` is a reference, then U must be a compatible one. absl::disjunction>, IsReferenceConversionValid>, Equality>, std::is_constructible, Equality>, absl::negation>>; template using IsStatusOrAssignmentValid = absl::conjunction< absl::negation>>, Equality>, std::is_constructible, std::is_assignable, absl::negation>>>; template using IsValueOrValid = absl::conjunction< // If `T` is a reference, then U must be a compatible one. absl::disjunction>, IsReferenceConversionValid>, Equality, type_traits_internal::IsLifetimeBoundAssignment>>>; class Helper { public: // Move type-agnostic error handling to the .cc. static void HandleInvalidStatusCtorArg(Status* absl_nonnull); [[noreturn]] static void Crash(const absl::Status& status); }; // Construct an instance of T in `p` through placement new, passing Args... to // the constructor. // This abstraction is here mostly for the gcc performance fix. template ABSL_ATTRIBUTE_NONNULL(1) void PlacementNew(void* absl_nonnull p, Args&&... args) { new (p) T(std::forward(args)...); } template class Reference { public: constexpr explicit Reference(T ref ABSL_ATTRIBUTE_LIFETIME_BOUND) : payload_(std::addressof(ref)) {} Reference(const Reference&) = default; Reference& operator=(const Reference&) = default; Reference& operator=(T value) { payload_ = std::addressof(value); return *this; } operator T() const { return static_cast(*payload_); } // NOLINT T get() const { return *this; } private: std::remove_reference_t* absl_nonnull payload_; }; // Helper base class to hold the data and all operations. // We move all this to a base class to allow mixing with the appropriate // TraitsBase specialization. template class StatusOrData { template friend class StatusOrData; decltype(auto) MaybeMoveData() { if constexpr (std::is_reference_v) { return data_.get(); } else { return std::move(data_); } } public: StatusOrData() = delete; StatusOrData(const StatusOrData& other) { if (other.ok()) { MakeValue(other.data_); MakeStatus(); } else { MakeStatus(other.status_); } } StatusOrData(StatusOrData&& other) noexcept { if (other.ok()) { MakeValue(other.MaybeMoveData()); MakeStatus(); } else { MakeStatus(std::move(other.status_)); } } template explicit StatusOrData(const StatusOrData& other) { if (other.ok()) { MakeValue(other.data_); MakeStatus(); } else { MakeStatus(other.status_); } } template explicit StatusOrData(StatusOrData&& other) { if (other.ok()) { MakeValue(other.MaybeMoveData()); MakeStatus(); } else { MakeStatus(std::move(other.status_)); } } template explicit StatusOrData(absl::in_place_t, Args&&... args) : data_(std::forward(args)...) { MakeStatus(); } template ::value, int> = 0> explicit StatusOrData(U&& v) : status_(std::forward(v)) { EnsureNotOk(); } StatusOrData& operator=(const StatusOrData& other) { if (this == &other) return *this; if (other.ok()) Assign(other.data_); else AssignStatus(other.status_); return *this; } StatusOrData& operator=(StatusOrData&& other) { if (this == &other) return *this; if (other.ok()) Assign(other.MaybeMoveData()); else AssignStatus(std::move(other.status_)); return *this; } ~StatusOrData() { if (ok()) { status_.~Status(); if constexpr (!std::is_trivially_destructible_v) { data_.~T(); } } else { status_.~Status(); } } template void Assign(U&& value) { if (ok()) { data_ = std::forward(value); } else { MakeValue(std::forward(value)); status_ = OkStatus(); } } template void AssignStatus(U&& v) { Clear(); status_ = static_cast(std::forward(v)); EnsureNotOk(); } bool ok() const { return status_.ok(); } protected: // status_ will always be active after the constructor. // We make it a union to be able to initialize exactly how we need without // waste. // Eg. in the copy constructor we use the default constructor of Status in // the ok() path to avoid an extra Ref call. union { Status status_; }; // data_ is active iff status_.ok()==true struct Dummy {}; union { // When T is const, we need some non-const object we can cast to void* for // the placement new. dummy_ is that object. Dummy dummy_; std::conditional_t, Reference, T> data_; }; void Clear() { if constexpr (!std::is_trivially_destructible_v) { if (ok()) data_.~T(); } } void EnsureOk() const { if (ABSL_PREDICT_FALSE(!ok())) Helper::Crash(status_); } void EnsureNotOk() { if (ABSL_PREDICT_FALSE(ok())) Helper::HandleInvalidStatusCtorArg(&status_); } // Construct the value (ie. data_) through placement new with the passed // argument. template void MakeValue(Arg&&... arg) { internal_statusor::PlacementNew(&dummy_, std::forward(arg)...); } // Construct the status (ie. status_) through placement new with the passed // argument. template void MakeStatus(Args&&... args) { internal_statusor::PlacementNew(&status_, std::forward(args)...); } template T ValueOrImpl(U&& default_value) const& { if (ok()) { return data_; } return std::forward(default_value); } template T ValueOrImpl(U&& default_value) && { if (ok()) { return std::move(data_); } return std::forward(default_value); } }; [[noreturn]] void ThrowBadStatusOrAccess(absl::Status status); template struct OperatorBase { auto& self() const { return static_cast&>(*this); } auto& self() { return static_cast&>(*this); } const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND { self().EnsureOk(); return self().data_; } T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND { self().EnsureOk(); return self().data_; } const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND { self().EnsureOk(); return std::move(self().data_); } T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND { self().EnsureOk(); return std::move(self().data_); } const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND { if (!self().ok()) internal_statusor::ThrowBadStatusOrAccess(self().status_); return self().data_; } T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND { if (!self().ok()) internal_statusor::ThrowBadStatusOrAccess(self().status_); return self().data_; } const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND { if (!self().ok()) { internal_statusor::ThrowBadStatusOrAccess(std::move(self().status_)); } return std::move(self().data_); } T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND { if (!self().ok()) { internal_statusor::ThrowBadStatusOrAccess(std::move(self().status_)); } return std::move(self().data_); } const T* absl_nonnull operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND { return std::addressof(**this); } T* absl_nonnull operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND { return std::addressof(**this); } }; template struct OperatorBase { auto& self() const { return static_cast&>(*this); } T& operator*() const { self().EnsureOk(); return self().data_; } T& value() const { if (!self().ok()) internal_statusor::ThrowBadStatusOrAccess(self().status_); return self().data_; } T* absl_nonnull operator->() const { return std::addressof(**this); } }; // Helper base classes to allow implicitly deleted constructors and assignment // operators in `StatusOr`. For example, `CopyCtorBase` will explicitly delete // the copy constructor when T is not copy constructible and `StatusOr` will // inherit that behavior implicitly. template ::value> struct CopyCtorBase { CopyCtorBase() = default; CopyCtorBase(const CopyCtorBase&) = default; CopyCtorBase(CopyCtorBase&&) = default; CopyCtorBase& operator=(const CopyCtorBase&) = default; CopyCtorBase& operator=(CopyCtorBase&&) = default; }; template struct CopyCtorBase { CopyCtorBase() = default; CopyCtorBase(const CopyCtorBase&) = delete; CopyCtorBase(CopyCtorBase&&) = default; CopyCtorBase& operator=(const CopyCtorBase&) = default; CopyCtorBase& operator=(CopyCtorBase&&) = default; }; template ::value> struct MoveCtorBase { MoveCtorBase() = default; MoveCtorBase(const MoveCtorBase&) = default; MoveCtorBase(MoveCtorBase&&) = default; MoveCtorBase& operator=(const MoveCtorBase&) = default; MoveCtorBase& operator=(MoveCtorBase&&) = default; }; template struct MoveCtorBase { MoveCtorBase() = default; MoveCtorBase(const MoveCtorBase&) = default; MoveCtorBase(MoveCtorBase&&) = delete; MoveCtorBase& operator=(const MoveCtorBase&) = default; MoveCtorBase& operator=(MoveCtorBase&&) = default; }; template ::value && std::is_copy_assignable::value) || std::is_reference_v> struct CopyAssignBase { CopyAssignBase() = default; CopyAssignBase(const CopyAssignBase&) = default; CopyAssignBase(CopyAssignBase&&) = default; CopyAssignBase& operator=(const CopyAssignBase&) = default; CopyAssignBase& operator=(CopyAssignBase&&) = default; }; template struct CopyAssignBase { CopyAssignBase() = default; CopyAssignBase(const CopyAssignBase&) = default; CopyAssignBase(CopyAssignBase&&) = default; CopyAssignBase& operator=(const CopyAssignBase&) = delete; CopyAssignBase& operator=(CopyAssignBase&&) = default; }; template ::value && std::is_move_assignable::value) || std::is_reference_v> struct MoveAssignBase { MoveAssignBase() = default; MoveAssignBase(const MoveAssignBase&) = default; MoveAssignBase(MoveAssignBase&&) = default; MoveAssignBase& operator=(const MoveAssignBase&) = default; MoveAssignBase& operator=(MoveAssignBase&&) = default; }; template struct MoveAssignBase { MoveAssignBase() = default; MoveAssignBase(const MoveAssignBase&) = default; MoveAssignBase(MoveAssignBase&&) = default; MoveAssignBase& operator=(const MoveAssignBase&) = default; MoveAssignBase& operator=(MoveAssignBase&&) = delete; }; // Used to introduce jitter into the output of printing functions for // `StatusOr` (i.e. `AbslStringify` and `operator<<`). class StringifyRandom { enum BracesType { kBareParens = 0, kSpaceParens, kBareBrackets, kSpaceBrackets, }; // Returns a random `BracesType` determined once per binary load. static BracesType RandomBraces() { static const BracesType kRandomBraces = static_cast( (reinterpret_cast(&kRandomBraces) >> 4) % 4); return kRandomBraces; } public: static inline absl::string_view OpenBrackets() { switch (RandomBraces()) { case kBareParens: return "("; case kSpaceParens: return "( "; case kBareBrackets: return "["; case kSpaceBrackets: return "[ "; } return "("; } static inline absl::string_view CloseBrackets() { switch (RandomBraces()) { case kBareParens: return ")"; case kSpaceParens: return " )"; case kBareBrackets: return "]"; case kSpaceBrackets: return " ]"; } return ")"; } }; } // namespace internal_statusor ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_STATUS_INTERNAL_STATUSOR_INTERNAL_H_