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 2019 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_STRINGS_INTERNAL_CORDZ_INFO_H_ #define ABSL_STRINGS_INTERNAL_CORDZ_INFO_H_ #include #include #include #include "absl/base/config.h" #include "absl/base/internal/raw_logging.h" #include "absl/base/internal/spinlock.h" #include "absl/base/thread_annotations.h" #include "absl/strings/internal/cord_internal.h" #include "absl/strings/internal/cordz_functions.h" #include "absl/strings/internal/cordz_handle.h" #include "absl/strings/internal/cordz_statistics.h" #include "absl/strings/internal/cordz_update_tracker.h" #include "absl/synchronization/mutex.h" #include "absl/types/span.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace cord_internal { // CordzInfo tracks a profiled Cord. Each of these objects can be in two places. // If a Cord is alive, the CordzInfo will be in the global_cordz_infos map, and // can also be retrieved via the linked list starting with // global_cordz_infos_head and continued via the cordz_info_next() method. When // a Cord has reached the end of its lifespan, the CordzInfo object will be // migrated out of the global_cordz_infos list and the global_cordz_infos_map, // and will either be deleted or appended to the global_delete_queue. If it is // placed on the global_delete_queue, the CordzInfo object will be cleaned in // the destructor of a CordzSampleToken object. class ABSL_LOCKABLE CordzInfo : public CordzHandle { public: using MethodIdentifier = CordzUpdateTracker::MethodIdentifier; // TrackCord creates a CordzInfo instance which tracks important metrics of // a sampled cord, and stores the created CordzInfo instance into `cord'. All // CordzInfo instances are placed in a global list which is used to discover // and snapshot all actively tracked cords. Callers are responsible for // calling UntrackCord() before the tracked Cord instance is deleted, or to // stop tracking the sampled Cord. Callers are also responsible for guarding // changes to the 'tree' value of a Cord (InlineData.tree) through the Lock() // and Unlock() calls. Any change resulting in a new tree value for the cord // requires a call to SetCordRep() before the old tree has been unreffed // and/or deleted. `method` identifies the Cord public API method initiating // the cord to be sampled. // Requires `cord` to hold a tree, and `cord.cordz_info()` to be null. static void TrackCord(InlineData& cord, MethodIdentifier method, int64_t sampling_stride); // Identical to TrackCord(), except that this function fills the // `parent_stack` and `parent_method` properties of the returned CordzInfo // instance from the provided `src` instance if `src` is sampled. // This function should be used for sampling 'copy constructed' and 'copy // assigned' cords. This function allows 'cord` to be already sampled, in // which case the CordzInfo will be newly created from `src`. static void TrackCord(InlineData& cord, const InlineData& src, MethodIdentifier method); // Maybe sample the cord identified by 'cord' for method 'method'. // Uses `cordz_should_profile` to randomly pick cords to be sampled, and if // so, invokes `TrackCord` to start sampling `cord`. static void MaybeTrackCord(InlineData& cord, MethodIdentifier method); // Maybe sample the cord identified by 'cord' for method 'method'. // `src` identifies a 'parent' cord which is assigned to `cord`, typically the // input cord for a copy constructor, or an assign method such as `operator=` // `cord` will be sampled if (and only if) `src` is sampled. // If `cord` is currently being sampled and `src` is not being sampled, then // this function will stop sampling the cord and reset the cord's cordz_info. // // Previously this function defined that `cord` will be sampled if either // `src` is sampled, or if `cord` is randomly picked for sampling. However, // this can cause issues, as there may be paths where some cord is assigned an // indirect copy of it's own value. As such a 'string of copies' would then // remain sampled (`src.is_profiled`), then assigning such a cord back to // 'itself' creates a cycle where the cord will converge to 'always sampled`. // // For example: // // Cord x; // for (...) { // // Copy ctor --> y.is_profiled := x.is_profiled | random(...) // Cord y = x; // ... // // Assign x = y --> x.is_profiled = y.is_profiled | random(...) // // ==> x.is_profiled |= random(...) // // ==> x converges to 'always profiled' // x = y; // } static void MaybeTrackCord(InlineData& cord, const InlineData& src, MethodIdentifier method); // Stops tracking changes for a sampled cord, and deletes the provided info. // This function must be called before the sampled cord instance is deleted, // and before the root cordrep of the sampled cord is unreffed. // This function may extend the lifetime of the cordrep in cases where the // CordInfo instance is being held by a concurrent collection thread. void Untrack(); // Invokes UntrackCord() on `info` if `info` is not null. static void MaybeUntrackCord(CordzInfo* info); CordzInfo() = delete; CordzInfo(const CordzInfo&) = delete; CordzInfo& operator=(const CordzInfo&) = delete; // Retrieves the oldest existing CordzInfo. static CordzInfo* Head(const CordzSnapshot& snapshot) ABSL_NO_THREAD_SAFETY_ANALYSIS; // Retrieves the next oldest existing CordzInfo older than 'this' instance. CordzInfo* Next(const CordzSnapshot& snapshot) const ABSL_NO_THREAD_SAFETY_ANALYSIS; // Locks this instance for the update identified by `method`. // Increases the count for `method` in `update_tracker`. void Lock(MethodIdentifier method) ABSL_EXCLUSIVE_LOCK_FUNCTION(mutex_); // Unlocks this instance. If the contained `rep` has been set to null // indicating the Cord has been cleared or is otherwise no longer sampled, // then this method will delete this CordzInfo instance. void Unlock() ABSL_UNLOCK_FUNCTION(mutex_); // Asserts that this CordzInfo instance is locked. void AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_); // Updates the `rep` property of this instance. This methods is invoked by // Cord logic each time the root node of a sampled Cord changes, and before // the old root reference count is deleted. This guarantees that collection // code can always safely take a reference on the tracked cord. // Requires a lock to be held through the `Lock()` method. // TODO(b/117940323): annotate with ABSL_EXCLUSIVE_LOCKS_REQUIRED once all // Cord code is in a state where this can be proven true by the compiler. void SetCordRep(CordRep* rep); // Returns the current `rep` property of this instance with a reference // added, or null if this instance represents a cord that has since been // deleted or untracked. CordRep* RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_); // Returns the current value of `rep_` for testing purposes only. CordRep* GetCordRepForTesting() const ABSL_NO_THREAD_SAFETY_ANALYSIS { return rep_; } // Sets the current value of `rep_` for testing purposes only. void SetCordRepForTesting(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS { rep_ = rep; } // Returns the stack trace for where the cord was first sampled. Cords are // potentially sampled when they promote from an inlined cord to a tree or // ring representation, which is not necessarily the location where the cord // was first created. Some cords are created as inlined cords, and only as // data is added do they become a non-inlined cord. However, typically the // location represents reasonably well where the cord is 'created'. absl::Span GetStack() const; // Returns the stack trace for a sampled cord's 'parent stack trace'. This // value may be set if the cord is sampled (promoted) after being created // from, or being assigned the value of an existing (sampled) cord. absl::Span GetParentStack() const; // Retrieves the CordzStatistics associated with this Cord. The statistics // are only updated when a Cord goes through a mutation, such as an Append // or RemovePrefix. CordzStatistics GetCordzStatistics() const; int64_t sampling_stride() const { return sampling_stride_; } private: using SpinLock = absl::base_internal::SpinLock; using SpinLockHolder = ::absl::base_internal::SpinLockHolder; // Global cordz info list. CordzInfo stores a pointer to the global list // instance to harden against ODR violations. struct List { constexpr explicit List(absl::ConstInitType) {} SpinLock mutex; std::atomic head ABSL_GUARDED_BY(mutex){nullptr}; }; static constexpr size_t kMaxStackDepth = 64; explicit CordzInfo(CordRep* rep, const CordzInfo* src, MethodIdentifier method, int64_t weight); ~CordzInfo() override; // Sets `rep_` without holding a lock. void UnsafeSetCordRep(CordRep* rep) ABSL_NO_THREAD_SAFETY_ANALYSIS; void Track(); // Returns the parent method from `src`, which is either `parent_method_` or // `method_` depending on `parent_method_` being kUnknown. // Returns kUnknown if `src` is null. static MethodIdentifier GetParentMethod(const CordzInfo* src); // Fills the provided stack from `src`, copying either `parent_stack_` or // `stack_` depending on `parent_stack_` being empty, returning the size of // the parent stack. // Returns 0 if `src` is null. static size_t FillParentStack(const CordzInfo* src, void** stack); void ODRCheck() const { #ifndef NDEBUG ABSL_RAW_CHECK(list_ == &global_list_, "ODR violation in Cord"); #endif } // Non-inlined implementation of `MaybeTrackCord`, which is executed if // either `src` is sampled or `cord` is sampled, and either untracks or // tracks `cord` as documented per `MaybeTrackCord`. static void MaybeTrackCordImpl(InlineData& cord, const InlineData& src, MethodIdentifier method); ABSL_CONST_INIT static List global_list_; List* const list_ = &global_list_; // ci_prev_ and ci_next_ require the global list mutex to be held. // Unfortunately we can't use thread annotations such that the thread safety // analysis understands that list_ and global_list_ are one and the same. std::atomic ci_prev_{nullptr}; std::atomic ci_next_{nullptr}; mutable absl::Mutex mutex_; CordRep* rep_ ABSL_GUARDED_BY(mutex_); void* stack_[kMaxStackDepth]; void* parent_stack_[kMaxStackDepth]; const size_t stack_depth_; const size_t parent_stack_depth_; const MethodIdentifier method_; const MethodIdentifier parent_method_; CordzUpdateTracker update_tracker_; const absl::Time create_time_; const int64_t sampling_stride_; }; inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord( InlineData& cord, MethodIdentifier method) { auto stride = cordz_should_profile(); if (ABSL_PREDICT_FALSE(stride > 0)) { TrackCord(cord, method, stride); } } inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeTrackCord( InlineData& cord, const InlineData& src, MethodIdentifier method) { if (ABSL_PREDICT_FALSE(InlineData::is_either_profiled(cord, src))) { MaybeTrackCordImpl(cord, src, method); } } inline ABSL_ATTRIBUTE_ALWAYS_INLINE void CordzInfo::MaybeUntrackCord( CordzInfo* info) { if (ABSL_PREDICT_FALSE(info)) { info->Untrack(); } } inline void CordzInfo::AssertHeld() ABSL_ASSERT_EXCLUSIVE_LOCK(mutex_) { #ifndef NDEBUG mutex_.AssertHeld(); #endif } inline void CordzInfo::SetCordRep(CordRep* rep) { AssertHeld(); rep_ = rep; } inline void CordzInfo::UnsafeSetCordRep(CordRep* rep) { rep_ = rep; } inline CordRep* CordzInfo::RefCordRep() const ABSL_LOCKS_EXCLUDED(mutex_) { MutexLock lock(mutex_); return rep_ ? CordRep::Ref(rep_) : nullptr; } } // namespace cord_internal ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_STRINGS_INTERNAL_CORDZ_INFO_H_