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
#ifndef _DATE_TIME_INT_ADAPTER_HPP__ #define _DATE_TIME_INT_ADAPTER_HPP__ /* Copyright (c) 2002,2003 CrystalClear Software, Inc. * Use, modification and distribution is subject to the * Boost Software License, Version 1.0. (See accompanying * file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) * Author: Jeff Garland, Bart Garst * $Date$ */ #include "boost/config.hpp" #include "boost/limits.hpp" //work around compilers without limits #include "boost/date_time/special_defs.hpp" #include "boost/date_time/locale_config.hpp" #ifndef BOOST_DATE_TIME_NO_LOCALE # include #endif #if defined(BOOST_MSVC) #pragma warning(push) // conditional expression is constant #pragma warning(disable: 4127) #endif namespace boost { namespace date_time { //! Adapter to create integer types with +-infinity, and not a value /*! This class is used internally in counted date/time representations. * It adds the floating point like features of infinities and * not a number. It also provides mathmatical operations with * consideration to special values following these rules: *@code * +infinity - infinity == Not A Number (NAN) * infinity * non-zero == infinity * infinity * zero == NAN * +infinity * -integer == -infinity * infinity / infinity == NAN * infinity * infinity == infinity *@endcode */ template class int_adapter { public: typedef int_type_ int_type; BOOST_CXX14_CONSTEXPR int_adapter(int_type v) : value_(v) {} static BOOST_CONSTEXPR bool has_infinity() { return true; } static BOOST_CONSTEXPR int_adapter pos_infinity() { return (::std::numeric_limits::max)(); } static BOOST_CONSTEXPR int_adapter neg_infinity() { return (::std::numeric_limits::min)(); } static BOOST_CONSTEXPR int_adapter not_a_number() { return (::std::numeric_limits::max)()-1; } static BOOST_CONSTEXPR int_adapter max BOOST_PREVENT_MACRO_SUBSTITUTION () { return (::std::numeric_limits::max)()-2; } static BOOST_CONSTEXPR int_adapter min BOOST_PREVENT_MACRO_SUBSTITUTION () { return (::std::numeric_limits::min)()+1; } static BOOST_CXX14_CONSTEXPR int_adapter from_special(special_values sv) { switch (sv) { case not_a_date_time: return not_a_number(); case neg_infin: return neg_infinity(); case pos_infin: return pos_infinity(); case max_date_time: return (max)(); case min_date_time: return (min)(); default: return not_a_number(); } } static BOOST_CONSTEXPR bool is_inf(int_type v) { return (v == neg_infinity().as_number() || v == pos_infinity().as_number()); } static BOOST_CXX14_CONSTEXPR bool is_neg_inf(int_type v) { return (v == neg_infinity().as_number()); } static BOOST_CXX14_CONSTEXPR bool is_pos_inf(int_type v) { return (v == pos_infinity().as_number()); } static BOOST_CXX14_CONSTEXPR bool is_not_a_number(int_type v) { return (v == not_a_number().as_number()); } //! Returns either special value type or is_not_special static BOOST_CXX14_CONSTEXPR special_values to_special(int_type v) { if (is_not_a_number(v)) return not_a_date_time; if (is_neg_inf(v)) return neg_infin; if (is_pos_inf(v)) return pos_infin; return not_special; } //-3 leaves room for representations of infinity and not a date static BOOST_CONSTEXPR int_type maxcount() { return (::std::numeric_limits::max)()-3; } BOOST_CONSTEXPR bool is_infinity() const { return (value_ == neg_infinity().as_number() || value_ == pos_infinity().as_number()); } BOOST_CONSTEXPR bool is_pos_infinity()const { return(value_ == pos_infinity().as_number()); } BOOST_CONSTEXPR bool is_neg_infinity()const { return(value_ == neg_infinity().as_number()); } BOOST_CONSTEXPR bool is_nan() const { return (value_ == not_a_number().as_number()); } BOOST_CONSTEXPR bool is_special() const { return(is_infinity() || is_nan()); } BOOST_CONSTEXPR bool operator==(const int_adapter& rhs) const { return (compare(rhs) == 0); } BOOST_CXX14_CONSTEXPR bool operator==(const int& rhs) const { if(!std::numeric_limits::is_signed) { if(is_neg_inf(value_) && rhs == 0) { return false; } } return (compare(rhs) == 0); } BOOST_CONSTEXPR bool operator!=(const int_adapter& rhs) const { return (compare(rhs) != 0); } BOOST_CXX14_CONSTEXPR bool operator!=(const int& rhs) const { if(!std::numeric_limits::is_signed) { if(is_neg_inf(value_) && rhs == 0) { return true; } } return (compare(rhs) != 0); } BOOST_CONSTEXPR bool operator<(const int_adapter& rhs) const { return (compare(rhs) == -1); } BOOST_CXX14_CONSTEXPR bool operator<(const int& rhs) const { // quiets compiler warnings if(!std::numeric_limits::is_signed) { if(is_neg_inf(value_) && rhs == 0) { return true; } } return (compare(rhs) == -1); } BOOST_CONSTEXPR bool operator>(const int_adapter& rhs) const { return (compare(rhs) == 1); } BOOST_CONSTEXPR int_type as_number() const { return value_; } //! Returns either special value type or is_not_special BOOST_CONSTEXPR special_values as_special() const { return int_adapter::to_special(value_); } //creates nasty ambiguities // operator int_type() const // { // return value_; // } /*! Operator allows for adding dissimilar int_adapter types. * The return type will match that of the the calling object's type */ template BOOST_CXX14_CONSTEXPR int_adapter operator+(const int_adapter& rhs) const { if(is_special() || rhs.is_special()) { if (is_nan() || rhs.is_nan()) { return int_adapter::not_a_number(); } if((is_pos_inf(value_) && rhs.is_neg_inf(rhs.as_number())) || (is_neg_inf(value_) && rhs.is_pos_inf(rhs.as_number())) ) { return int_adapter::not_a_number(); } if (is_infinity()) { return *this; } if (rhs.is_pos_inf(rhs.as_number())) { return int_adapter::pos_infinity(); } if (rhs.is_neg_inf(rhs.as_number())) { return int_adapter::neg_infinity(); } } return int_adapter(value_ + static_cast(rhs.as_number())); } BOOST_CXX14_CONSTEXPR int_adapter operator+(const int_type rhs) const { if(is_special()) { if (is_nan()) { return int_adapter(not_a_number()); } if (is_infinity()) { return *this; } } return int_adapter(value_ + rhs); } /*! Operator allows for subtracting dissimilar int_adapter types. * The return type will match that of the the calling object's type */ template BOOST_CXX14_CONSTEXPR int_adapter operator-(const int_adapter& rhs)const { if(is_special() || rhs.is_special()) { if (is_nan() || rhs.is_nan()) { return int_adapter::not_a_number(); } if((is_pos_inf(value_) && rhs.is_pos_inf(rhs.as_number())) || (is_neg_inf(value_) && rhs.is_neg_inf(rhs.as_number())) ) { return int_adapter::not_a_number(); } if (is_infinity()) { return *this; } if (rhs.is_pos_inf(rhs.as_number())) { return int_adapter::neg_infinity(); } if (rhs.is_neg_inf(rhs.as_number())) { return int_adapter::pos_infinity(); } } return int_adapter(value_ - static_cast(rhs.as_number())); } BOOST_CXX14_CONSTEXPR int_adapter operator-(const int_type rhs) const { if(is_special()) { if (is_nan()) { return int_adapter(not_a_number()); } if (is_infinity()) { return *this; } } return int_adapter(value_ - rhs); } // should templatize this to be consistant with op +- BOOST_CXX14_CONSTEXPR int_adapter operator*(const int_adapter& rhs)const { if(this->is_special() || rhs.is_special()) { return mult_div_specials(rhs); } return int_adapter(value_ * rhs.value_); } /*! Provided for cases when automatic conversion from * 'int' to 'int_adapter' causes incorrect results. */ BOOST_CXX14_CONSTEXPR int_adapter operator*(const int rhs) const { if(is_special()) { return mult_div_specials(rhs); } return int_adapter(value_ * rhs); } // should templatize this to be consistant with op +- BOOST_CXX14_CONSTEXPR int_adapter operator/(const int_adapter& rhs)const { if(this->is_special() || rhs.is_special()) { if(is_infinity() && rhs.is_infinity()) { return int_adapter(not_a_number()); } if(rhs != 0) { return mult_div_specials(rhs); } else { // let divide by zero blow itself up return int_adapter(value_ / rhs.value_); //NOLINT } } return int_adapter(value_ / rhs.value_); } /*! Provided for cases when automatic conversion from * 'int' to 'int_adapter' causes incorrect results. */ BOOST_CXX14_CONSTEXPR int_adapter operator/(const int rhs) const { if(is_special() && rhs != 0) { return mult_div_specials(rhs); } // let divide by zero blow itself up like int return int_adapter(value_ / rhs); //NOLINT } // should templatize this to be consistant with op +- BOOST_CXX14_CONSTEXPR int_adapter operator%(const int_adapter& rhs)const { if(this->is_special() || rhs.is_special()) { if(is_infinity() && rhs.is_infinity()) { return int_adapter(not_a_number()); } if(rhs != 0) { return mult_div_specials(rhs); } else { // let divide by zero blow itself up return int_adapter(value_ % rhs.value_); //NOLINT } } return int_adapter(value_ % rhs.value_); } /*! Provided for cases when automatic conversion from * 'int' to 'int_adapter' causes incorrect results. */ BOOST_CXX14_CONSTEXPR int_adapter operator%(const int rhs) const { if(is_special() && rhs != 0) { return mult_div_specials(rhs); } // let divide by zero blow itself up return int_adapter(value_ % rhs); //NOLINT } private: int_type value_; //! returns -1, 0, 1, or 2 if 'this' is <, ==, >, or 'nan comparison' rhs BOOST_CXX14_CONSTEXPR int compare( const int_adapter& rhs ) const { if(this->is_special() || rhs.is_special()) { if(this->is_nan() || rhs.is_nan()) { if(this->is_nan() && rhs.is_nan()) { return 0; // equal } else { return 2; // nan } } if((is_neg_inf(value_) && !is_neg_inf(rhs.value_)) || (is_pos_inf(rhs.value_) && !is_pos_inf(value_)) ) { return -1; // less than } if((is_pos_inf(value_) && !is_pos_inf(rhs.value_)) || (is_neg_inf(rhs.value_) && !is_neg_inf(value_)) ) { return 1; // greater than } } if(value_ < rhs.value_) return -1; if(value_ > rhs.value_) return 1; // implied-> if(value_ == rhs.value_) return 0; } /* When multiplying and dividing with at least 1 special value * very simmilar rules apply. In those cases where the rules * are different, they are handled in the respective operator * function. */ //! Assumes at least 'this' or 'rhs' is a special value BOOST_CXX14_CONSTEXPR int_adapter mult_div_specials(const int_adapter& rhs) const { if(this->is_nan() || rhs.is_nan()) { return int_adapter(not_a_number()); } BOOST_CONSTEXPR_OR_CONST int min_value = std::numeric_limits::is_signed ? 0 : 1; if((*this > 0 && rhs > 0) || (*this < min_value && rhs < min_value)) { return int_adapter(pos_infinity()); } if((*this > 0 && rhs < min_value) || (*this < min_value && rhs > 0)) { return int_adapter(neg_infinity()); } //implied -> if(this->value_ == 0 || rhs.value_ == 0) return int_adapter(not_a_number()); } /* Overloaded function necessary because of special * situation where int_adapter is instantiated with * 'unsigned' and func is called with negative int. * It would produce incorrect results since 'unsigned' * wraps around when initialized with a negative value */ //! Assumes 'this' is a special value BOOST_CXX14_CONSTEXPR int_adapter mult_div_specials(const int& rhs) const { if(this->is_nan()) { return int_adapter(not_a_number()); } BOOST_CONSTEXPR_OR_CONST int min_value = std::numeric_limits::is_signed ? 0 : 1; if((*this > 0 && rhs > 0) || (*this < min_value && rhs < 0)) { return int_adapter(pos_infinity()); } if((*this > 0 && rhs < 0) || (*this < min_value && rhs > 0)) { return int_adapter(neg_infinity()); } //implied -> if(this->value_ == 0 || rhs.value_ == 0) return int_adapter(not_a_number()); } }; #ifndef BOOST_DATE_TIME_NO_LOCALE /*! Expected output is either a numeric representation * or a special values representation.
* Ex. "12", "+infinity", "not-a-number", etc. */ //template, typename int_type> template inline std::basic_ostream& operator<<(std::basic_ostream& os, const int_adapter& ia) { if(ia.is_special()) { // switch copied from date_names_put.hpp switch(ia.as_special()) { case not_a_date_time: os << "not-a-number"; break; case pos_infin: os << "+infinity"; break; case neg_infin: os << "-infinity"; break; default: os << ""; } } else { os << ia.as_number(); } return os; } #endif } } //namespace date_time #if defined(BOOST_MSVC) #pragma warning(pop) #endif #endif