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 (c) 2023-2025 Ivica Siladic, Bruno Iljazovic, Korina Simicevic // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_MQTT5_BASE_ENCODERS_HPP #define BOOST_MQTT5_BASE_ENCODERS_HPP #include #include #include #include #include #include #include #include #include #include #include namespace boost::mqtt5::encoders { namespace basic { using varint_t = int*; inline void to_variable_bytes(std::string& s, int32_t val) { if (val > 0xfffffff) return; while (val > 127) { s.push_back(char((val & 0b01111111) | 0b10000000)); val >>= 7; } s.push_back(val & 0b01111111); } inline size_t variable_length(int32_t val) { if (val > 0xfffffff) return 0; size_t rv = 1; for (; val > 127; ++rv) val >>= 7; return rv; } struct encoder {}; template class flag_def : public encoder { template using least_type = std::conditional_t< num_bits <= 8, uint8_t, std::conditional_t< num_bits <= 16, uint16_t, std::conditional_t< num_bits <= 32, uint32_t, std::conditional_t > > >; template friend class flag_def; repr _val { 0 }; public: flag_def(repr val) : _val(val) {} flag_def() = default; template < typename T, typename projection = boost::identity, std::enable_if_t, bool> = true > auto operator()(T&& value, projection proj = {}) const { if constexpr (std::is_same_v) { repr val = value.has_value(); return flag_def { val }; } else { repr val = value.has_value() ? static_cast(std::invoke(proj, *value)) : 0; return flag_def { val }; } } template < typename T, typename projection = boost::identity, std::enable_if_t, bool> = true > auto operator()(T&& value, projection proj = {}) const { auto val = static_cast(std::invoke(proj, value)); return flag_def { val }; } size_t byte_size() const { return sizeof(repr); } template auto operator|(const flag_def& rhs) const { using res_repr = least_type; auto val = static_cast((_val << rhs_bits) | rhs._val); return flag_def { val }; } std::string& encode(std::string& s) const { using namespace boost::endian; size_t sz = s.size(); s.resize(sz + sizeof(repr)); auto p = reinterpret_cast(s.data() + sz); endian_store(p, _val); return s; } }; template constexpr auto flag = flag_def{}; template class int_val : public encoder { T _val; public: int_val(T val) : _val(val) {} size_t byte_size() const { if constexpr (detail::is_optional) { if (_val) return val_length(*_val); return 0; } else return val_length(_val); } std::string& encode(std::string& s) const { if constexpr (detail::is_optional) { if (_val) return encode_val(s, *_val); return s; } else return encode_val(s, _val); } private: template static size_t val_length(U&& val) { if constexpr (std::is_same_v) return variable_length(int32_t(val)); else return sizeof(Repr); } template static std::string& encode_val(std::string& s, U&& val) { using namespace boost::endian; if constexpr (std::is_same_v) { to_variable_bytes(s, int32_t(val)); return s; } else { size_t sz = s.size(); s.resize(sz + sizeof(Repr)); auto p = reinterpret_cast(s.data() + sz); endian_store(p, val); return s; } } }; template class int_def { public: template auto operator()(T&& val) const { return int_val { std::forward(val) }; } template auto operator()(T&& val, projection proj) const { if constexpr (detail::is_optional) { using rv_type = std::invoke_result_t< projection, typename boost::remove_cv_ref_t::value_type >; if (val.has_value()) return (*this)(std::invoke(proj, *val)); return int_val { rv_type {} }; } else { using rv_type = std::invoke_result_t; return int_val { std::invoke(proj, val) }; } } }; constexpr auto byte_ = int_def {}; constexpr auto int16_ = int_def {}; constexpr auto int32_ = int_def {}; constexpr auto varlen_ = int_def {}; template class array_val : public encoder { T _val; bool _with_length; public: array_val(T val, bool with_length) : _val(val), _with_length(with_length) { static_assert( std::is_reference_v || std::is_same_v ); } size_t byte_size() const { if constexpr (detail::is_optional) return _val ? _with_length * 2 + val_length(*_val) : 0; else return _with_length * 2 + val_length(_val); } std::string& encode(std::string& s) const { if constexpr (detail::is_optional) { if (_val) return encode_val(s, *_val); return s; } else return encode_val(s, _val); } private: template using has_size = decltype(std::declval().size()); template static size_t val_length(U&& val) { if constexpr (std::is_same_v, const char*>) return std::strlen(val); if constexpr (boost::is_detected_exact_v) return val.size(); else // fallback to type const char (&)[N] (substract 1 for trailing 0) return sizeof(val) - 1; } template std::string& encode_val(std::string& s, U&& u) const { using namespace boost::endian; auto byte_len = val_length(std::forward(u)); if (byte_len == 0 && !_with_length) return s; if (_with_length) { size_t sz = s.size(); s.resize(sz + 2); auto p = reinterpret_cast(s.data() + sz); endian_store( p, int16_t(byte_len) ); } s.append(std::begin(u), std::begin(u) + byte_len); return s; } }; template class array_def { public: template auto operator()(T&& val) const { return array_val { std::forward(val), with_length }; } template auto operator()(T&& val, projection proj) const { if constexpr (detail::is_optional) { using rv_type = std::invoke_result_t< projection, typename boost::remove_cv_ref_t::value_type >; if (val.has_value()) return (*this)(std::invoke(proj, *val)); return array_val { rv_type {}, false }; } else { const auto& av = std::invoke(proj, val); return array_val { av, true }; } } }; using utf8_def = array_def; constexpr auto utf8_ = utf8_def {}; constexpr auto binary_ = array_def {}; // for now constexpr auto verbatim_ = array_def {}; template class composed_val : public encoder { T _lhs; U _rhs; public: composed_val(T lhs, U rhs) : _lhs(std::forward(lhs)), _rhs(std::forward(rhs)) {} size_t byte_size() const { return _lhs.byte_size() + _rhs.byte_size(); } std::string& encode(std::string& s) const { _lhs.encode(s); return _rhs.encode(s); } }; template < typename T, typename U, std::enable_if_t< std::is_base_of_v> && std::is_base_of_v>, bool > = true > inline auto operator&(T&& t, U&& u) { return composed_val(std::forward(t), std::forward(u)); } template < typename T, std::enable_if_t>, bool> = true > std::string& operator<<(std::string& s, T&& t) { return t.encode(s); } } // end namespace basic namespace prop { namespace pp = boost::mqtt5::prop; template auto encoder_for_prop_value(const T& val) { if constexpr (std::is_same_v) return basic::int_def{}(val); else if constexpr (std::is_same_v) return basic::int_def{}(val); else if constexpr (std::is_same_v) return basic::int_def{}(val); else if constexpr (std::is_same_v) return basic::int_def{}(val); else if constexpr (std::is_same_v) return basic::utf8_def{}(val); else if constexpr (detail::is_pair) return encoder_for_prop_value(val.first) & encoder_for_prop_value(val.second); } template class prop_val; template < typename T, pp::property_type p > class prop_val< T, p, std::enable_if_t && detail::is_optional> > : public basic::encoder { // allows T to be reference type to std::optional static inline boost::remove_cv_ref_t nulltype; T _val; public: prop_val(T val) : _val(val) { static_assert(std::is_reference_v); } prop_val() : _val(nulltype) {} size_t byte_size() const { if (!_val) return 0; return 1 + encoder_for_prop_value(*_val).byte_size(); } std::string& encode(std::string& s) const { if (!_val) return s; s.push_back(p); return encoder_for_prop_value(*_val).encode(s); } }; template < typename T, pp::property_type p > class prop_val< T, p, std::enable_if_t || detail::is_small_vector> > : public basic::encoder { // allows T to be reference type to std::vector static inline boost::remove_cv_ref_t nulltype; T _val; public: prop_val(T val) : _val(val) { static_assert(std::is_reference_v); } prop_val() : _val(nulltype) { } size_t byte_size() const { if (_val.empty()) return 0; size_t total_size = 0; for (const auto& elem : _val) total_size += 1 + encoder_for_prop_value(elem).byte_size(); return total_size; } std::string& encode(std::string& s) const { if (_val.empty()) return s; for (const auto& elem: _val) { s.push_back(p); encoder_for_prop_value(elem).encode(s); } return s; } }; template class props_val : public basic::encoder { static inline std::decay_t nulltype; template static auto to_prop_val(const T& val) { return prop_val(val); } template static auto to_prop_vals(const pp::properties& props) { return std::make_tuple( to_prop_val( props[std::integral_constant {}] )... ); } template auto apply_each(Func&& func) const { return std::apply([&func](const auto&... props) { return (std::invoke(func, props), ...); }, _prop_vals); } decltype(to_prop_vals(std::declval())) _prop_vals; bool _may_omit; public: props_val(Props val, bool may_omit) : _prop_vals(to_prop_vals(val)), _may_omit(may_omit) { static_assert(std::is_reference_v); } props_val(bool may_omit) : _prop_vals(to_prop_vals(nulltype)), _may_omit(may_omit) {} size_t byte_size() const { size_t psize = props_size(); if (_may_omit && psize == 0) return 0; return psize + basic::varlen_(psize).byte_size(); } std::string& encode(std::string& s) const { size_t psize = props_size(); if (_may_omit && psize == 0) return s; basic::varlen_(psize).encode(s); apply_each([&s](const auto& pv) { return pv.encode(s); }); return s; } private: size_t props_size() const { size_t retval = 0; apply_each([&retval](const auto& pv) { return retval += pv.byte_size(); }); return retval; } }; template class props_def { public: template auto operator()(T&& prop_container) const { if constexpr (detail::is_optional) { if (prop_container.has_value()) return (*this)(*prop_container); return props_val< const typename boost::remove_cv_ref_t::value_type& >(true); } else { return props_val { prop_container, may_omit }; } } }; constexpr auto props_ = props_def {}; constexpr auto props_may_omit_ = props_def {}; } // end namespace prop } // end namespace boost::mqtt5::encoders #endif // !BOOST_MQTT5_BASE_ENCODERS_HPP