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
/****************************************************************************** * * Project: CPL * Purpose: Floating point conversion functions. Convert 16- and 24-bit * floating point numbers into the 32-bit IEEE 754 compliant ones. * Author: Andrey Kiselev, dron@remotesensing.org * ****************************************************************************** * Copyright (c) 2005, Andrey Kiselev * Copyright (c) 2010, Even Rouault * * This code is based on the code from OpenEXR project with the following * copyright: * * Copyright (c) 2002, Industrial Light & Magic, a division of Lucas * Digital Ltd. LLC * * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * Redistributions in binary form must reproduce the above * copyright notice, this list of conditions and the following disclaimer * in the documentation and/or other materials provided with the * distribution. * * Neither the name of Industrial Light & Magic nor the names of * its contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * ****************************************************************************/ #ifndef CPL_FLOAT_H_INCLUDED #define CPL_FLOAT_H_INCLUDED #include "cpl_port.h" #ifdef __cplusplus #include #include #include #include #include #ifdef HAVE_STD_FLOAT16_T #include #endif #endif CPL_C_START GUInt32 CPL_DLL CPLHalfToFloat(GUInt16 iHalf); GUInt32 CPL_DLL CPLTripleToFloat(GUInt32 iTriple); CPL_C_END #ifdef __cplusplus GUInt16 CPL_DLL CPLFloatToHalf(GUInt32 iFloat32, bool &bHasWarned); GUInt16 CPL_DLL CPLConvertFloatToHalf(float fFloat32); float CPL_DLL CPLConvertHalfToFloat(GUInt16 nHalf); #if defined(__F16C__) #include #ifndef GDALCopyXMMToInt16_defined #define GDALCopyXMMToInt16_defined static inline void GDALCopyXMMToInt16(const __m128i xmm, void *pDest) { GInt16 i = static_cast(_mm_extract_epi16(xmm, 0)); memcpy(pDest, &i, 2); } #endif #endif namespace cpl { // We define our own version of `std::numeric_limits` so that we can // specialize it for `cpl::Float16` if necessary. Specializing // `std::numeric_limits` doesn't always work because some libraries // use `std::numeric_limits`, and one cannot specialize a type // template after it has been used. template struct NumericLimits : std::numeric_limits { }; #ifndef HAVE_STD_FLOAT16_T // Define a type `cpl::Float16`. If the compiler supports it natively // (as `_Float16`), then this class is a simple wrapper. Otherwise we // store the values in a `GUInt16` as bit pattern. //! @cond Doxygen_Suppress struct Float16 { struct make_from_bits_and_value { }; #ifdef HAVE__FLOAT16 // How we represent a `Float16` internally using repr = _Float16; // How we compute on `Float16` values using compute = _Float16; // Create a Float16 in a constexpr manner. Since we can't convert // bits in a constexpr function, we need to take both the bit // pattern and a float value as input, and can then choose which // of the two to use. constexpr Float16(make_from_bits_and_value, CPL_UNUSED std::uint16_t bits, float fValue) : rValue(repr(fValue)) { } static constexpr repr computeToRepr(compute fValue) { return fValue; } static constexpr compute reprToCompute(repr rValue) { return rValue; } template static constexpr repr toRepr(T fValue) { return static_cast(fValue); } template static constexpr T fromRepr(repr rValue) { return static_cast(rValue); } #else // #ifndef HAVE__FLOAT16 // How we represent a `Float16` internally using repr = std::uint16_t; // How we compute on `Float16` values using compute = float; // Create a Float16 in a constexpr manner. Since we can't convert // bits in a constexpr function, we need to take both the bit // pattern and a float value as input, and can then choose which // of the two to use. constexpr Float16(make_from_bits_and_value, std::uint16_t bits, CPL_UNUSED float fValue) : rValue(bits) { } static unsigned float2unsigned(float f) { unsigned u; std::memcpy(&u, &f, 4); return u; } static float unsigned2float(unsigned u) { float f; std::memcpy(&f, &u, 4); return f; } // Copied from cpl_float.cpp so that we can inline for performance static std::uint16_t computeToRepr(float fFloat32) { std::uint32_t iFloat32 = float2unsigned(fFloat32); std::uint32_t iSign = (iFloat32 >> 31) & 0x00000001; std::uint32_t iExponent = (iFloat32 >> 23) & 0x000000ff; std::uint32_t iMantissa = iFloat32 & 0x007fffff; if (iExponent == 255) { if (iMantissa == 0) { // Positive or negative infinity. return static_cast((iSign << 15) | 0x7C00); } // NaN -- preserve sign and significand bits. if (iMantissa >> 13) return static_cast((iSign << 15) | 0x7C00 | (iMantissa >> 13)); return static_cast((iSign << 15) | 0x7E00); } if (iExponent <= 127 - 15) { // Zero, float32 denormalized number or float32 too small normalized // number if (13 + 1 + 127 - 15 - iExponent >= 32) return static_cast(iSign << 15); // Return a denormalized number return static_cast( (iSign << 15) | ((iMantissa | 0x00800000) >> (13 + 1 + 127 - 15 - iExponent))); } if (iExponent - (127 - 15) >= 31) { return static_cast((iSign << 15) | 0x7C00); // Infinity } // Normalized number. iExponent = iExponent - (127 - 15); iMantissa = iMantissa >> 13; // Assemble sign, exponent and mantissa. // coverity[overflow_sink] return static_cast((iSign << 15) | (iExponent << 10) | iMantissa); } // Copied from cpl_float.cpp so that we can inline for performance static float reprToCompute(std::uint16_t iHalf) { std::uint32_t iSign = (iHalf >> 15) & 0x00000001; int iExponent = (iHalf >> 10) & 0x0000001f; std::uint32_t iMantissa = iHalf & 0x000003ff; if (iExponent == 31) { if (iMantissa == 0) { // Positive or negative infinity. return unsigned2float((iSign << 31) | 0x7f800000); } // NaN -- preserve sign and significand bits. return unsigned2float((iSign << 31) | 0x7f800000 | (iMantissa << 13)); } if (iExponent == 0) { if (iMantissa == 0) { // Plus or minus zero. return unsigned2float(iSign << 31); } // Denormalized number -- renormalize it. while (!(iMantissa & 0x00000400)) { iMantissa <<= 1; iExponent -= 1; } iExponent += 1; iMantissa &= ~0x00000400U; } // Normalized number. iExponent = iExponent + (127 - 15); iMantissa = iMantissa << 13; // Assemble sign, exponent and mantissa. /* coverity[overflow_sink] */ return unsigned2float((iSign << 31) | (static_cast(iExponent) << 23) | iMantissa); } template static repr toRepr(T value) { #ifdef __F16C__ float fValue = static_cast(value); __m128 xmm_float = _mm_load_ss(&fValue); const __m128i xmm_hfloat = _mm_cvtps_ph(xmm_float, _MM_FROUND_TO_NEAREST_INT); repr hfValueOut; GDALCopyXMMToInt16(xmm_hfloat, &hfValueOut); return hfValueOut; #else return computeToRepr(static_cast(value)); #endif } template static T fromRepr(repr rValue) { #ifdef __F16C__ __m128i xmm; memcpy(&xmm, &rValue, sizeof(repr)); float fValueOut; _mm_store_ss(&fValueOut, _mm_cvtph_ps(xmm)); return static_cast(fValueOut); #else return static_cast(reprToCompute(rValue)); #endif } #endif // #ifndef HAVE__FLOAT16 private: repr rValue; public: compute get() const { return reprToCompute(rValue); } // cppcheck-suppress uninitMemberVar Float16() = default; Float16(const Float16 &) = default; Float16(Float16 &&) = default; Float16 &operator=(const Float16 &) = default; Float16 &operator=(Float16 &&) = default; // Constructors and conversion operators #ifdef HAVE__FLOAT16 // cppcheck-suppress noExplicitConstructor constexpr Float16(_Float16 hfValue) : rValue(hfValue) { } constexpr operator _Float16() const { return rValue; } #endif // cppcheck-suppress-macro noExplicitConstructor #define GDAL_DEFINE_CONVERSION(TYPE) \ \ Float16(TYPE fValue) : rValue(toRepr(fValue)) \ { \ } \ \ operator TYPE() const \ { \ return fromRepr(rValue); \ } GDAL_DEFINE_CONVERSION(float) GDAL_DEFINE_CONVERSION(double) GDAL_DEFINE_CONVERSION(char) GDAL_DEFINE_CONVERSION(signed char) GDAL_DEFINE_CONVERSION(short) GDAL_DEFINE_CONVERSION(int) GDAL_DEFINE_CONVERSION(long) GDAL_DEFINE_CONVERSION(long long) GDAL_DEFINE_CONVERSION(unsigned char) GDAL_DEFINE_CONVERSION(unsigned short) GDAL_DEFINE_CONVERSION(unsigned int) GDAL_DEFINE_CONVERSION(unsigned long) GDAL_DEFINE_CONVERSION(unsigned long long) #undef GDAL_DEFINE_CONVERSION // Arithmetic operators friend Float16 operator+(Float16 x) { return +x.get(); } friend Float16 operator-(Float16 x) { return -x.get(); } #define GDAL_DEFINE_ARITHOP(OP) \ \ friend Float16 operator OP(Float16 x, Float16 y) \ { \ return x.get() OP y.get(); \ } \ \ friend double operator OP(double x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend float operator OP(float x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend Float16 operator OP(int x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend double operator OP(Float16 x, double y) \ { \ return static_cast(x.get()) OP y; \ } \ \ friend float operator OP(Float16 x, float y) \ { \ return static_cast(x.get()) OP y; \ } \ \ friend Float16 operator OP(Float16 x, int y) \ { \ return static_cast(x.get()) OP y; \ } GDAL_DEFINE_ARITHOP(+) GDAL_DEFINE_ARITHOP(-) GDAL_DEFINE_ARITHOP(*) GDAL_DEFINE_ARITHOP(/) #undef GDAL_DEFINE_ARITHOP // Comparison operators #define GDAL_DEFINE_COMPARISON(OP) \ \ friend bool operator OP(Float16 x, Float16 y) \ { \ return x.get() OP y.get(); \ } \ \ friend bool operator OP(float x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend bool operator OP(double x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend bool operator OP(int x, Float16 y) \ { \ return x OP static_cast(y.get()); \ } \ \ friend bool operator OP(Float16 x, float y) \ { \ return static_cast(x.get()) OP y; \ } \ \ friend bool operator OP(Float16 x, double y) \ { \ return static_cast(x.get()) OP y; \ } \ \ friend bool operator OP(Float16 x, int y) \ { \ return static_cast(x.get()) OP y; \ } GDAL_DEFINE_COMPARISON(==) GDAL_DEFINE_COMPARISON(!=) GDAL_DEFINE_COMPARISON(<) GDAL_DEFINE_COMPARISON(>) GDAL_DEFINE_COMPARISON(<=) GDAL_DEFINE_COMPARISON(>=) #undef GDAL_DEFINE_COMPARISON // Standard math functions friend bool isfinite(Float16 x) { using std::isfinite; return isfinite(float(x)); } friend bool isinf(Float16 x) { using std::isinf; return isinf(float(x)); } friend bool isnan(Float16 x) { using std::isnan; return isnan(float(x)); } friend bool isnormal(Float16 x) { using std::isnormal; return isnormal(float(x)); } friend bool signbit(Float16 x) { using std::signbit; return signbit(float(x)); } friend Float16 abs(Float16 x) { using std::abs; return Float16(abs(float(x))); } friend Float16 cbrt(Float16 x) { using std::cbrt; return Float16(cbrt(float(x))); } friend Float16 ceil(Float16 x) { using std::ceil; return Float16(ceil(float(x))); } friend Float16 copysign(Float16 x, Float16 y) { using std::copysign; return Float16(copysign(float(x), float(y))); } friend Float16 fabs(Float16 x) { using std::fabs; return Float16(fabs(float(x))); } friend Float16 floor(Float16 x) { using std::floor; return Float16(floor(float(x))); } friend Float16 fmax(Float16 x, Float16 y) { using std::fmax; return Float16(fmax(float(x), float(y))); } friend Float16 fmin(Float16 x, Float16 y) { using std::fmin; return Float16(fmin(float(x), float(y))); } friend Float16 hypot(Float16 x, Float16 y) { using std::hypot; return Float16(hypot(float(x), float(y))); } friend Float16 max(Float16 x, Float16 y) { using std::max; return Float16(max(float(x), float(y))); } friend Float16 min(Float16 x, Float16 y) { using std::min; return Float16(min(float(x), float(y))); } // Adapted from the LLVM Project, under the Apache License v2.0 friend Float16 nextafter(Float16 x, Float16 y) { if (isnan(x)) return x; if (isnan(y)) return y; if (x == y) return y; std::uint16_t bits; if (x != Float16(0)) { std::memcpy(&bits, &x.rValue, 2); if ((x < y) == (x > Float16(0))) ++bits; else --bits; } else { bits = (signbit(y) << 15) | 0x0001; } Float16 r; std::memcpy(&r.rValue, &bits, 2); return r; } friend Float16 pow(Float16 x, Float16 y) { using std::pow; return Float16(pow(float(x), float(y))); } friend Float16 pow(Float16 x, int n) { using std::pow; return Float16(pow(float(x), n)); } friend Float16 round(Float16 x) { using std::round; return Float16(round(float(x))); } friend Float16 sqrt(Float16 x) { using std::sqrt; return Float16(sqrt(float(x))); } }; template <> struct NumericLimits { static constexpr bool is_specialized = true; static constexpr bool is_signed = true; static constexpr bool is_integer = false; static constexpr bool is_exact = false; static constexpr bool has_infinity = true; static constexpr bool has_quiet_NaN = true; static constexpr bool has_signaling_NaN = true; static constexpr bool has_denorm = true; static constexpr bool is_iec559 = true; static constexpr int digits = 11; static constexpr int digits10 = 3; static constexpr int max_digits10 = 5; static constexpr int radix = 2; static constexpr Float16 epsilon() { return Float16(Float16::make_from_bits_and_value{}, 0x1400, 0.000977f); } static constexpr Float16 min() { return Float16(Float16::make_from_bits_and_value{}, 0x0001, 6.0e-8f); } static constexpr Float16 lowest() { return Float16(Float16::make_from_bits_and_value{}, 0xfbff, -65504.0f); } static constexpr Float16 max() { return Float16(Float16::make_from_bits_and_value{}, 0x7bff, +65504.0f); } static constexpr Float16 infinity() { return Float16(Float16::make_from_bits_and_value{}, 0x7c00, std::numeric_limits::infinity()); } static constexpr Float16 quiet_NaN() { return Float16(Float16::make_from_bits_and_value{}, 0x7e00, std::numeric_limits::quiet_NaN()); } static constexpr Float16 signaling_NaN() { return Float16(Float16::make_from_bits_and_value{}, 0xfe00, std::numeric_limits::signaling_NaN()); } }; //! @endcond #endif // #ifndef HAVE_STD_FLOAT16_T } // namespace cpl #ifdef HAVE_STD_FLOAT16_T using GFloat16 = std::float16_t; #else using GFloat16 = cpl::Float16; #endif // Define some GDAL wrappers. Their C equivalents are defined in `cpl_port.h`. // (These wrappers are not necessary any more in C++, one can always // call `isnan` etc directly.) template constexpr int CPLIsNan(T x) { // We need to write `using std::isnan` instead of directly using // `std::isnan` because `std::isnan` only supports the types // `float` and `double`. The `isnan` for `cpl::Float16` is found in the // `cpl` namespace via argument-dependent lookup // . using std::isnan; return isnan(x); } template constexpr int CPLIsInf(T x) { using std::isinf; return isinf(x); } template constexpr int CPLIsFinite(T x) { using std::isfinite; return isfinite(x); } #endif // #ifdef __cplusplus double CPL_DLL CPLGreatestCommonDivisor(double x, double y); #endif // CPL_FLOAT_H_INCLUDED