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 2015 Google Inc. All rights reserved. * * 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 * * http://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 FLATBUFFERS_REFLECTION_H_ #define FLATBUFFERS_REFLECTION_H_ // This is somewhat of a circular dependency because flatc (and thus this // file) is needed to generate this header in the first place. // Should normally not be a problem since it can be generated by the // previous version of flatc whenever this code needs to change. // See scripts/generate_code.py for generation. #include "flatbuffers/reflection_generated.h" // Helper functionality for reflection. namespace flatbuffers { // ------------------------- GETTERS ------------------------- inline bool IsScalar(reflection::BaseType t) { return t >= reflection::UType && t <= reflection::Double; } inline bool IsInteger(reflection::BaseType t) { return t >= reflection::UType && t <= reflection::ULong; } inline bool IsFloat(reflection::BaseType t) { return t == reflection::Float || t == reflection::Double; } inline bool IsLong(reflection::BaseType t) { return t == reflection::Long || t == reflection::ULong; } // Size of a basic type, don't use with structs. inline size_t GetTypeSize(reflection::BaseType base_type) { // This needs to correspond to the BaseType enum. static size_t sizes[] = { 0, // None 1, // UType 1, // Bool 1, // Byte 1, // UByte 2, // Short 2, // UShort 4, // Int 4, // UInt 8, // Long 8, // ULong 4, // Float 8, // Double 4, // String 4, // Vector 4, // Obj 4, // Union 0, // Array. Only used in structs. 0 was chosen to prevent out-of-bounds // errors. 8, // Vector64 0 // MaxBaseType. This must be kept the last entry in this array. }; static_assert(sizeof(sizes) / sizeof(size_t) == reflection::MaxBaseType + 1, "Size of sizes[] array does not match the count of BaseType " "enum values."); return sizes[base_type]; } // Same as above, but now correctly returns the size of a struct if // the field (or vector element) is a struct. inline size_t GetTypeSizeInline(reflection::BaseType base_type, int type_index, const reflection::Schema& schema) { if (base_type == reflection::Obj && schema.objects()->Get(type_index)->is_struct()) { return schema.objects()->Get(type_index)->bytesize(); } else { return GetTypeSize(base_type); } } // Get the root, regardless of what type it is. inline Table* GetAnyRoot(uint8_t* const flatbuf) { return GetMutableRoot(flatbuf); } inline const Table* GetAnyRoot(const uint8_t* const flatbuf) { return GetRoot
(flatbuf); } inline Table* GetAnySizePrefixedRoot(uint8_t* const flatbuf) { return GetMutableSizePrefixedRoot
(flatbuf); } inline const Table* GetAnySizePrefixedRoot(const uint8_t* const flatbuf) { return GetSizePrefixedRoot
(flatbuf); } // Get a field's default, if you know it's an integer, and its exact type. template T GetFieldDefaultI(const reflection::Field& field) { FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return static_cast(field.default_integer()); } // Get a field's default, if you know it's floating point and its exact type. template T GetFieldDefaultF(const reflection::Field& field) { FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return static_cast(field.default_real()); } // Get a field, if you know it's an integer, and its exact type. template T GetFieldI(const Table& table, const reflection::Field& field) { FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_integer())); } // Get a field, if you know it's floating point and its exact type. template T GetFieldF(const Table& table, const reflection::Field& field) { FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(field.type()->base_type())); return table.GetField(field.offset(), static_cast(field.default_real())); } // Get a field, if you know it's a string. inline const String* GetFieldS(const Table& table, const reflection::Field& field) { FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::String); return table.GetPointer(field.offset()); } // Get a field, if you know it's a vector. template Vector* GetFieldV(const Table& table, const reflection::Field& field) { FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Vector && sizeof(T) == GetTypeSize(field.type()->element())); return table.GetPointer*>(field.offset()); } // Get a field, if you know it's a vector, generically. // To actually access elements, use the return value together with // field.type()->element() in any of GetAnyVectorElemI below etc. inline VectorOfAny* GetFieldAnyV(const Table& table, const reflection::Field& field) { return table.GetPointer(field.offset()); } // Get a field, if you know it's a table. inline Table* GetFieldT(const Table& table, const reflection::Field& field) { FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj || field.type()->base_type() == reflection::Union); return table.GetPointer(field.offset()); } // Get a field, if you know it's a struct. inline const Struct* GetFieldStruct(const Table& table, const reflection::Field& field) { // TODO: This does NOT check if the field is a table or struct, but we'd need // access to the schema to check the is_struct flag. FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj); return table.GetStruct(field.offset()); } // Get a structure's field, if you know it's a struct. inline const Struct* GetFieldStruct(const Struct& structure, const reflection::Field& field) { FLATBUFFERS_ASSERT(field.type()->base_type() == reflection::Obj); return structure.GetStruct(field.offset()); } // Raw helper functions used below: get any value in memory as a 64bit int, a // double or a string. // All scalars get static_cast to an int64_t, strings use strtoull, every other // data type returns 0. int64_t GetAnyValueI(reflection::BaseType type, const uint8_t* data); // All scalars static cast to double, strings use strtod, every other data // type is 0.0. double GetAnyValueF(reflection::BaseType type, const uint8_t* data); // All scalars converted using stringstream, strings as-is, and all other // data types provide some level of debug-pretty-printing. std::string GetAnyValueS(reflection::BaseType type, const uint8_t* data, const reflection::Schema* schema, int type_index); // Get any table field as a 64bit int, regardless of what type it is. inline int64_t GetAnyFieldI(const Table& table, const reflection::Field& field) { auto field_ptr = table.GetAddressOf(field.offset()); return field_ptr ? GetAnyValueI(field.type()->base_type(), field_ptr) : field.default_integer(); } // Get any table field as a double, regardless of what type it is. inline double GetAnyFieldF(const Table& table, const reflection::Field& field) { auto field_ptr = table.GetAddressOf(field.offset()); return field_ptr ? GetAnyValueF(field.type()->base_type(), field_ptr) : field.default_real(); } // Get any table field as a string, regardless of what type it is. // You may pass nullptr for the schema if you don't care to have fields that // are of table type pretty-printed. inline std::string GetAnyFieldS(const Table& table, const reflection::Field& field, const reflection::Schema* schema) { auto field_ptr = table.GetAddressOf(field.offset()); return field_ptr ? GetAnyValueS(field.type()->base_type(), field_ptr, schema, field.type()->index()) : ""; } // Get any struct field as a 64bit int, regardless of what type it is. inline int64_t GetAnyFieldI(const Struct& st, const reflection::Field& field) { return GetAnyValueI(field.type()->base_type(), st.GetAddressOf(field.offset())); } // Get any struct field as a double, regardless of what type it is. inline double GetAnyFieldF(const Struct& st, const reflection::Field& field) { return GetAnyValueF(field.type()->base_type(), st.GetAddressOf(field.offset())); } // Get any struct field as a string, regardless of what type it is. inline std::string GetAnyFieldS(const Struct& st, const reflection::Field& field) { return GetAnyValueS(field.type()->base_type(), st.GetAddressOf(field.offset()), nullptr, -1); } // Get any vector element as a 64bit int, regardless of what type it is. inline int64_t GetAnyVectorElemI(const VectorOfAny* vec, reflection::BaseType elem_type, size_t i) { return GetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i); } // Get any vector element as a double, regardless of what type it is. inline double GetAnyVectorElemF(const VectorOfAny* vec, reflection::BaseType elem_type, size_t i) { return GetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i); } // Get any vector element as a string, regardless of what type it is. inline std::string GetAnyVectorElemS(const VectorOfAny* vec, reflection::BaseType elem_type, size_t i) { return GetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, nullptr, -1); } // Get a vector element that's a table/string/vector from a generic vector. // Pass Table/String/VectorOfAny as template parameter. // Warning: does no typechecking. template T* GetAnyVectorElemPointer(const VectorOfAny* vec, size_t i) { auto elem_ptr = vec->Data() + sizeof(uoffset_t) * i; return reinterpret_cast(elem_ptr + ReadScalar(elem_ptr)); } // Get the inline-address of a vector element. Useful for Structs (pass Struct // as template arg), or being able to address a range of scalars in-line. // Get elem_size from GetTypeSizeInline(). // Note: little-endian data on all platforms, use EndianScalar() instead of // raw pointer access with scalars). template T* GetAnyVectorElemAddressOf(const VectorOfAny* vec, size_t i, size_t elem_size) { return reinterpret_cast(vec->Data() + elem_size * i); } // Similarly, for elements of tables. template T* GetAnyFieldAddressOf(const Table& table, const reflection::Field& field) { return reinterpret_cast(table.GetAddressOf(field.offset())); } // Similarly, for elements of structs. template T* GetAnyFieldAddressOf(const Struct& st, const reflection::Field& field) { return reinterpret_cast(st.GetAddressOf(field.offset())); } // Loop over all the fields of the provided `object` and call `func` on each one // in increasing order by their field->id(). If `reverse` is true, `func` is // called in descending order void ForAllFields(const reflection::Object* object, bool reverse, std::function func); // ------------------------- SETTERS ------------------------- // Set any scalar field, if you know its exact type. template bool SetField(Table* table, const reflection::Field& field, T val) { reflection::BaseType type = field.type()->base_type(); if (!IsScalar(type)) { return false; } FLATBUFFERS_ASSERT(sizeof(T) == GetTypeSize(type)); T def; if (IsInteger(type)) { def = GetFieldDefaultI(field); } else { FLATBUFFERS_ASSERT(IsFloat(type)); def = GetFieldDefaultF(field); } return table->SetField(field.offset(), val, def); } // Raw helper functions used below: set any value in memory as a 64bit int, a // double or a string. // These work for all scalar values, but do nothing for other data types. // To set a string, see SetString below. void SetAnyValueI(reflection::BaseType type, uint8_t* data, int64_t val); void SetAnyValueF(reflection::BaseType type, uint8_t* data, double val); void SetAnyValueS(reflection::BaseType type, uint8_t* data, const char* val); // Set any table field as a 64bit int, regardless of type what it is. inline bool SetAnyFieldI(Table* table, const reflection::Field& field, int64_t val) { auto field_ptr = table->GetAddressOf(field.offset()); if (!field_ptr) return val == GetFieldDefaultI(field); SetAnyValueI(field.type()->base_type(), field_ptr, val); return true; } // Set any table field as a double, regardless of what type it is. inline bool SetAnyFieldF(Table* table, const reflection::Field& field, double val) { auto field_ptr = table->GetAddressOf(field.offset()); if (!field_ptr) return val == GetFieldDefaultF(field); SetAnyValueF(field.type()->base_type(), field_ptr, val); return true; } // Set any table field as a string, regardless of what type it is. inline bool SetAnyFieldS(Table* table, const reflection::Field& field, const char* val) { auto field_ptr = table->GetAddressOf(field.offset()); if (!field_ptr) return false; SetAnyValueS(field.type()->base_type(), field_ptr, val); return true; } // Set any struct field as a 64bit int, regardless of type what it is. inline void SetAnyFieldI(Struct* st, const reflection::Field& field, int64_t val) { SetAnyValueI(field.type()->base_type(), st->GetAddressOf(field.offset()), val); } // Set any struct field as a double, regardless of type what it is. inline void SetAnyFieldF(Struct* st, const reflection::Field& field, double val) { SetAnyValueF(field.type()->base_type(), st->GetAddressOf(field.offset()), val); } // Set any struct field as a string, regardless of type what it is. inline void SetAnyFieldS(Struct* st, const reflection::Field& field, const char* val) { SetAnyValueS(field.type()->base_type(), st->GetAddressOf(field.offset()), val); } // Set any vector element as a 64bit int, regardless of type what it is. inline void SetAnyVectorElemI(VectorOfAny* vec, reflection::BaseType elem_type, size_t i, int64_t val) { SetAnyValueI(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val); } // Set any vector element as a double, regardless of type what it is. inline void SetAnyVectorElemF(VectorOfAny* vec, reflection::BaseType elem_type, size_t i, double val) { SetAnyValueF(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val); } // Set any vector element as a string, regardless of type what it is. inline void SetAnyVectorElemS(VectorOfAny* vec, reflection::BaseType elem_type, size_t i, const char* val) { SetAnyValueS(elem_type, vec->Data() + GetTypeSize(elem_type) * i, val); } // ------------------------- RESIZING SETTERS ------------------------- // "smart" pointer for use with resizing vectors: turns a pointer inside // a vector into a relative offset, such that it is not affected by resizes. template class pointer_inside_vector { public: pointer_inside_vector(T* ptr, std::vector& vec) : offset_(reinterpret_cast(ptr) - reinterpret_cast(vec.data())), vec_(vec) {} T* operator*() const { return reinterpret_cast(reinterpret_cast(vec_.data()) + offset_); } T* operator->() const { return operator*(); } private: size_t offset_; std::vector& vec_; }; // Helper to create the above easily without specifying template args. template pointer_inside_vector piv(T* ptr, std::vector& vec) { return pointer_inside_vector(ptr, vec); } inline const char* UnionTypeFieldSuffix() { return "_type"; } // Helper to figure out the actual table type a union refers to. inline const reflection::Object& GetUnionType( const reflection::Schema& schema, const reflection::Object& parent, const reflection::Field& unionfield, const Table& table) { auto enumdef = schema.enums()->Get(unionfield.type()->index()); // TODO: this is clumsy and slow, but no other way to find it? auto type_field = parent.fields()->LookupByKey( (unionfield.name()->str() + UnionTypeFieldSuffix()).c_str()); FLATBUFFERS_ASSERT(type_field); auto union_type = GetFieldI(table, *type_field); auto enumval = enumdef->values()->LookupByKey(union_type); return *schema.objects()->Get(enumval->union_type()->index()); } // Changes the contents of a string inside a FlatBuffer. FlatBuffer must // live inside a std::vector so we can resize the buffer if needed. // "str" must live inside "flatbuf" and may be invalidated after this call. // If your FlatBuffer's root table is not the schema's root table, you should // pass in your root_table type as well. void SetString(const reflection::Schema& schema, const std::string& val, const String* str, std::vector* flatbuf, const reflection::Object* root_table = nullptr); // Resizes a flatbuffers::Vector inside a FlatBuffer. FlatBuffer must // live inside a std::vector so we can resize the buffer if needed. // "vec" must live inside "flatbuf" and may be invalidated after this call. // If your FlatBuffer's root table is not the schema's root table, you should // pass in your root_table type as well. uint8_t* ResizeAnyVector(const reflection::Schema& schema, uoffset_t newsize, const VectorOfAny* vec, uoffset_t num_elems, uoffset_t elem_size, std::vector* flatbuf, const reflection::Object* root_table = nullptr); template void ResizeVector(const reflection::Schema& schema, uoffset_t newsize, T val, const Vector* vec, std::vector* flatbuf, const reflection::Object* root_table = nullptr) { auto delta_elem = static_cast(newsize) - static_cast(vec->size()); auto newelems = ResizeAnyVector( schema, newsize, reinterpret_cast(vec), vec->size(), static_cast(sizeof(T)), flatbuf, root_table); // Set new elements to "val". for (int i = 0; i < delta_elem; i++) { auto loc = newelems + i * sizeof(T); auto is_scalar = flatbuffers::is_scalar::value; if (is_scalar) { WriteScalar(loc, val); } else { // struct *reinterpret_cast(loc) = val; } } } // Adds any new data (in the form of a new FlatBuffer) to an existing // FlatBuffer. This can be used when any of the above methods are not // sufficient, in particular for adding new tables and new fields. // This is potentially slightly less efficient than a FlatBuffer constructed // in one piece, since the new FlatBuffer doesn't share any vtables with the // existing one. // The return value can now be set using Vector::MutateOffset or SetFieldT // below. const uint8_t* AddFlatBuffer(std::vector& flatbuf, const uint8_t* newbuf, size_t newlen); inline bool SetFieldT(Table* table, const reflection::Field& field, const uint8_t* val) { FLATBUFFERS_ASSERT(sizeof(uoffset_t) == GetTypeSize(field.type()->base_type())); return table->SetPointer(field.offset(), val); } // ------------------------- COPYING ------------------------- // Generic copying of tables from a FlatBuffer into a FlatBuffer builder. // Can be used to do any kind of merging/selecting you may want to do out // of existing buffers. Also useful to reconstruct a whole buffer if the // above resizing functionality has introduced garbage in a buffer you want // to remove. // Note: this does not deal with DAGs correctly. If the table passed forms a // DAG, the copy will be a tree instead (with duplicates). Strings can be // shared however, by passing true for use_string_pooling. Offset CopyTable(FlatBufferBuilder& fbb, const reflection::Schema& schema, const reflection::Object& objectdef, const Table& table, bool use_string_pooling = false); // Verifies the provided flatbuffer using reflection. // root should point to the root type for this flatbuffer. // buf should point to the start of flatbuffer data. // length specifies the size of the flatbuffer data. bool Verify(const reflection::Schema& schema, const reflection::Object& root, const uint8_t* buf, size_t length, uoffset_t max_depth = 64, uoffset_t max_tables = 1000000); bool VerifySizePrefixed(const reflection::Schema& schema, const reflection::Object& root, const uint8_t* buf, size_t length, uoffset_t max_depth = 64, uoffset_t max_tables = 1000000); } // namespace flatbuffers #endif // FLATBUFFERS_REFLECTION_H_