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
// Protocol Buffers - Google's data interchange format // Copyright 2008 Google Inc. All rights reserved. // // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file or at // https://developers.google.com/open-source/licenses/bsd // Author: kenton@google.com (Kenton Varda) // Based on original Protocol Buffers design by // Sanjay Ghemawat, Jeff Dean, and others. // // This header is logically internal, but is made public because it is used // from protocol-compiler-generated code, which may reside in other components. #ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__ #define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__ #include #include #include #include #include "absl/base/call_once.h" #include "absl/base/optimization.h" #include "absl/log/absl_check.h" #include "google/protobuf/descriptor.h" #include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/has_bits.h" #include "google/protobuf/unknown_field_set.h" // Must be included last. #include "google/protobuf/port_def.inc" #ifdef SWIG #error "You cannot SWIG proto headers" #endif namespace google { namespace protobuf { class MapKey; class MapValueRef; class MessageLayoutInspector; class Message; struct Metadata; namespace io { class CodedOutputStream; } } // namespace protobuf } // namespace google namespace google { namespace protobuf { namespace internal { class DefaultEmptyOneof; // Defined in other files. class ExtensionSet; // extension_set.h class WeakFieldMap; // weak_field_map.h // Tag used on offsets for fields that don't have a real offset. // For example, weak message fields go into the WeakFieldMap and not in an // actual field. inline constexpr uint32_t kInvalidFieldOffsetTag = 0x40000000u; // Mask used on offsets for split fields. inline constexpr uint32_t kSplitFieldOffsetMask = 0x80000000u; inline constexpr uint32_t kLazyMask = 0x1u; inline constexpr uint32_t kInlinedMask = 0x1u; inline constexpr uint32_t kMicroStringMask = 0x2u; // This struct describes the internal layout of the message, hence this is // used to act on the message reflectively. // default_instance: The default instance of the message. This is only // used to obtain pointers to default instances of embedded // messages, which GetMessage() will return if the particular // sub-message has not been initialized yet. (Thus, all // embedded message fields *must* have non-null pointers // in the default instance.) // offsets: An array of ints giving the byte offsets. // For each oneof or weak field, the offset is relative to the // default_instance. These can be computed at compile time // using the // PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET() // macro. For each none oneof field, the offset is related to // the start of the message object. These can be computed at // compile time using the // PROTO2_GENERATED_MESSAGE_FIELD_OFFSET() macro. // Besides offsets for all fields, this array also contains // offsets for oneof unions. The offset of the i-th oneof union // is offsets[descriptor->field_count() + i]. // has_bit_indices: Mapping from field indexes to their index in the has // bit array. // has_bits_offset: Offset in the message of an array of uint32s of size // descriptor->field_count()/32, rounded up. This is a // bitfield where each bit indicates whether or not the // corresponding field of the message has been initialized. // The bit for field index i is obtained by the expression: // has_bits[i / 32] & (1 << (i % 32)) // unknown_fields_offset: Offset in the message of the UnknownFieldSet for // the message. // extensions_offset: Offset in the message of the ExtensionSet for the // message, or -1 if the message type has no extension // ranges. // oneof_case_offset: Offset in the message of an array of uint32s of // size descriptor->oneof_decl_count(). Each uint32_t // indicates what field is set for each oneof. // object_size: The size of a message object of this type, as measured // by sizeof(). // arena_offset: If a message doesn't have a unknown_field_set that stores // the arena, it must have a direct pointer to the arena. // weak_field_map_offset: If the message proto has weak fields, this is the // offset of _weak_field_map_ in the generated proto. Otherwise // -1. struct ReflectionSchema { public: // Size of a google::protobuf::Message object of this type. uint32_t GetObjectSize() const { return static_cast(object_size_); } bool InRealOneof(const FieldDescriptor* field) const { return field->real_containing_oneof(); } // Offset of any field. template uint32_t GetFieldOffset(const FieldDescriptor* field) const { return OffsetValue(offsets_[field->index()], field->type()); } bool IsFieldInlined(const FieldDescriptor* field) const { return Inlined(offsets_[field->index()], field->type()); } bool IsFieldMicroString(const FieldDescriptor* field) const { return IsMicroString(offsets_[field->index()], field->type()); } uint32_t GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const { return static_cast(oneof_case_offset_) + static_cast( static_cast(oneof_descriptor->index()) * sizeof(uint32_t)); } // Returns true iff the field object has usable hasbit offset. // Note that this is not necessarily correlated with *field presence* : // Fields with implicit presence (i.e. ones that don't expose has_foo API) // can still have hasbits in their underlying implementation. bool HasHasbits() const { return has_bits_offset_ != -1; } // Bit index within the bit array of hasbits. Bit order is low-to-high. uint32_t HasBitIndex(const FieldDescriptor* field) const { ABSL_DCHECK(!field->is_extension()); if (has_bits_offset_ == -1) return static_cast(kNoHasbit); ABSL_DCHECK(HasHasbits()); return has_bit_indices_[field->index()]; } // Byte offset of the hasbits array. uint32_t HasBitsOffset() const { ABSL_DCHECK(HasHasbits()); return static_cast(has_bits_offset_); } bool HasInlinedString() const { return inlined_string_donated_offset_ != -1; } // Bit index within the bit array of _inlined_string_donated_. Bit order is // low-to-high. uint32_t InlinedStringIndex(const FieldDescriptor* field) const { ABSL_DCHECK(HasInlinedString()); return inlined_string_indices_[field->index()]; } // Byte offset of the _inlined_string_donated_ array. uint32_t InlinedStringDonatedOffset() const { ABSL_DCHECK(HasInlinedString()); return static_cast(inlined_string_donated_offset_); } // Whether this message has an ExtensionSet. bool HasExtensionSet() const { return extensions_offset_ != -1; } // The offset of the ExtensionSet in this message. uint32_t GetExtensionSetOffset() const { ABSL_DCHECK(HasExtensionSet()); return static_cast(extensions_offset_); } // The off set of WeakFieldMap when the message contains weak fields. // The default is 0 for now. int GetWeakFieldMapOffset() const { return weak_field_map_offset_; } bool IsDefaultInstance(const Message& message) const { return &message == default_instance_; } // Returns a pointer to the default value for this field. The size and type // of the underlying data depends on the field's type. const void* GetFieldDefault(const FieldDescriptor* field) const { return reinterpret_cast(default_instance_) + OffsetValue(offsets_[field->index()], field->type()); } // Returns true if the field is implicitly backed by LazyField. bool IsEagerlyVerifiedLazyField(const FieldDescriptor* field) const { ABSL_DCHECK_EQ(field->type(), FieldDescriptor::TYPE_MESSAGE); (void)field; return false; } bool IsSplit() const { return split_offset_ != -1; } bool IsSplit(const FieldDescriptor* field) const { return split_offset_ != -1 && (offsets_[field->index()] & kSplitFieldOffsetMask) != 0; } // Byte offset of _split_. uint32_t SplitOffset() const { ABSL_DCHECK(IsSplit()); return static_cast(split_offset_); } uint32_t SizeofSplit() const { ABSL_DCHECK(IsSplit()); return static_cast(sizeof_split_); } bool HasWeakFields() const { return weak_field_map_offset_ > 0; } // These members are intended to be private, but we cannot actually make them // private because this prevents us from using aggregate initialization of // them, ie. // // ReflectionSchema schema = {a, b, c, d, e, ...}; // private: const Message* default_instance_; const uint32_t* offsets_; const uint32_t* has_bit_indices_; int has_bits_offset_; int extensions_offset_; int oneof_case_offset_; int object_size_; int weak_field_map_offset_; const uint32_t* inlined_string_indices_; int inlined_string_donated_offset_; int split_offset_; int sizeof_split_; // We tag offset values to provide additional data about fields (such as // "unused" or "lazy" or "inlined"). template static uint32_t OffsetValue(uint32_t v, FieldDescriptor::Type type) { if constexpr (!std::is_void_v) { // If the type is passed, statically use the alignment for the mask. // Faster than checking `type`. return v & ~kSplitFieldOffsetMask & ~(alignof(Type) - 1); } if (type == FieldDescriptor::TYPE_MESSAGE || type == FieldDescriptor::TYPE_STRING || type == FieldDescriptor::TYPE_BYTES) { return v & ~kSplitFieldOffsetMask & ~kInlinedMask & ~kLazyMask & ~kMicroStringMask; } return v & (~kSplitFieldOffsetMask); } static bool Inlined(uint32_t v, FieldDescriptor::Type type) { if (type == FieldDescriptor::TYPE_STRING || type == FieldDescriptor::TYPE_BYTES) { return (v & kInlinedMask) != 0u; } else { // Non string/byte fields are not inlined. return false; } } static bool IsMicroString(uint32_t v, FieldDescriptor::Type type) { ABSL_DCHECK(type == FieldDescriptor::TYPE_STRING || type == FieldDescriptor::TYPE_BYTES) << type; return (v & kMicroStringMask) != 0u; } }; // Structs that the code generator emits directly to describe a message. // These should never used directly except to build a ReflectionSchema // object. // // EXPERIMENTAL: these are changing rapidly, and may completely disappear // or merge with ReflectionSchema. struct MigrationSchema { int32_t offsets_index; int object_size; }; // This struct tries to reduce unnecessary padding. // The num_xxx might not be close to their respective pointer, but this saves // padding. struct PROTOBUF_EXPORT DescriptorTable { mutable bool is_initialized; bool is_eager; int size; // of serialized descriptor const char* descriptor; const char* filename; absl::once_flag* once; const DescriptorTable* const* deps; int num_deps; int num_messages; const MigrationSchema* schemas; const Message* const* default_instances; const uint32_t* offsets; // update the following descriptor arrays. const EnumDescriptor** file_level_enum_descriptors; const ServiceDescriptor** file_level_service_descriptors; }; // AssignDescriptors() pulls the compiled FileDescriptor from the DescriptorPool // and uses it to populate all of the global variables which store pointers to // the descriptor objects. It also constructs the reflection objects. It is // called the first time anyone calls descriptor() or GetReflection() on one of // the types defined in the file. AssignDescriptors() is thread-safe. void PROTOBUF_EXPORT AssignDescriptors(const DescriptorTable* table); // As above, but the caller did the call_once call already. void PROTOBUF_EXPORT AssignDescriptorsOnceInnerCall(const DescriptorTable* table); // These cannot be in lite so we put them in the reflection. PROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8_t* base, uint32_t offset, uint32_t tag, uint32_t has_offset, io::CodedOutputStream* output); PROTOBUF_EXPORT void InitializeFileDescriptorDefaultInstances(); PROTOBUF_EXPORT void AddDescriptors(const DescriptorTable* table); struct PROTOBUF_EXPORT AddDescriptorsRunner { explicit AddDescriptorsRunner(const DescriptorTable* table); }; // Retrieves the existing prototype out of a descriptor table. // If it doesn't exist: // - If force_build is true, asks the generated message factory for one. // - Otherwise, return null const Message* GetPrototypeForWeakDescriptor(const DescriptorTable* table, int index, bool force_build); struct DenseEnumCacheInfo { std::atomic cache; int min_val; int max_val; const EnumDescriptor* (*descriptor_fn)(); }; PROTOBUF_EXPORT const std::string& NameOfDenseEnumSlow(int v, DenseEnumCacheInfo*); // Similar to the routine NameOfEnum, this routine returns the name of an enum. // Unlike that routine, it allocates, on-demand, a block of pointers to the // std::string objects allocated by reflection to store the enum names. This // way, as long as the enum values are fairly dense, looking them up can be // very fast. This assumes all the enums fall in the range [min_val .. max_val]. template const std::string& NameOfDenseEnum(int v) { static_assert(max_val - min_val >= 0, "Too many enums between min and max."); static DenseEnumCacheInfo deci = {/* atomic ptr */ {}, min_val, max_val, descriptor_fn}; const std::string** cache = deci.cache.load(std::memory_order_acquire ); if (ABSL_PREDICT_TRUE(cache != nullptr)) { if (ABSL_PREDICT_TRUE(v >= min_val && v <= max_val)) { return *cache[v - min_val]; } } return NameOfDenseEnumSlow(v, &deci); } // Returns whether this type of field is stored in the split struct as a raw // pointer. PROTOBUF_EXPORT bool SplitFieldHasExtraIndirection( const FieldDescriptor* field); } // namespace internal } // namespace protobuf } // namespace google #include "google/protobuf/port_undef.inc" #endif // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__