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 2005-2007 Adobe Systems Incorporated // Copyright 2019 Mateusz Loskot // // Distributed under the Boost Software License, Version 1.0 // See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt // #ifndef BOOST_GIL_COLOR_BASE_HPP #define BOOST_GIL_COLOR_BASE_HPP #include #include #include #include #include #include namespace boost { namespace gil { // Forward-declare template P* memunit_advanced(const P* p, std::ptrdiff_t diff); // Forward-declare semantic_at_c template auto semantic_at_c(ColorBase& p) -> typename std::enable_if < !std::is_const::value, typename kth_semantic_element_reference_type::type >::type; template auto semantic_at_c(const ColorBase& p) -> typename kth_semantic_element_const_reference_type::type; // Forward declare element_reference_type template struct element_reference_type; template struct element_const_reference_type; template struct kth_element_type; template struct kth_element_type : public kth_element_type {}; template struct kth_element_reference_type; template struct kth_element_reference_type : public kth_element_reference_type {}; template struct kth_element_const_reference_type; template struct kth_element_const_reference_type : public kth_element_const_reference_type {}; namespace detail { template struct mapping_transform : mp11::mp_at < typename SrcLayout::channel_mapping_t, typename detail::type_to_index < typename DstLayout::channel_mapping_t, std::integral_constant > >::type {}; /// \defgroup ColorBaseModelHomogeneous detail::homogeneous_color_base /// \ingroup ColorBaseModel /// \brief A homogeneous color base holding one color element. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// If the element type models Regular, this class models HomogeneousColorBaseValueConcept. #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif /// \brief A homogeneous color base holding one color element. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template struct homogeneous_color_base { using layout_t = Layout; template < typename U = Element, typename = typename std::enable_if::value>::type > homogeneous_color_base() : v0_{} {} explicit homogeneous_color_base(Element v) : v0_(v) {} template homogeneous_color_base(homogeneous_color_base const& c) : v0_(gil::at_c<0>(c)) {} auto at(std::integral_constant) -> typename element_reference_type::type { return v0_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v0_; } // grayscale pixel values are convertible to channel type // FIXME: explicit? operator Element() const { return v0_; } private: Element v0_; }; /// \brief A homogeneous color base holding two color elements /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template struct homogeneous_color_base { using layout_t = Layout; template < typename U = Element, typename = typename std::enable_if::value>::type > homogeneous_color_base() : v0_{}, v1_{} {} explicit homogeneous_color_base(Element v) : v0_(v), v1_(v) {} homogeneous_color_base(Element v0, Element v1) : v0_(v0), v1_(v1) {} template homogeneous_color_base(homogeneous_color_base const& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) {} // Support for l-value reference proxy copy construction template homogeneous_color_base(homogeneous_color_base& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(*p)) , v1_(&semantic_at_c<1>(*p)) {} // Support for planar_pixel_reference offset constructor template homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(*memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(*memunit_advanced(semantic_at_c<1>(ptr), diff)) {} template Ref deref() const { return Ref(*semantic_at_c<0>(*this), *semantic_at_c<1>(*this)); } auto at(std::integral_constant) -> typename element_reference_type::type { return v0_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v0_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v1_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v1_; } // Support for planar_pixel_reference operator[] auto at_c_dynamic(std::size_t i) const -> Element { if (i == 0) return v0_; else return v1_; } private: Element v0_; Element v1_; }; /// \brief A homogeneous color base holding three color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template struct homogeneous_color_base { using layout_t = Layout; template < typename U = Element, typename = typename std::enable_if::value>::type > homogeneous_color_base() : v0_{}, v1_{}, v2_{} {} explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2) : v0_(v0), v1_(v1), v2_(v2) {} template homogeneous_color_base(homogeneous_color_base const& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) {} // Support for l-value reference proxy copy construction template homogeneous_color_base(homogeneous_color_base& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(*p)) , v1_(&semantic_at_c<1>(*p)) , v2_(&semantic_at_c<2>(*p)) {} // Support for planar_pixel_reference offset constructor template homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(*memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(*memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(*memunit_advanced(semantic_at_c<2>(ptr), diff)) {} template Ref deref() const { return Ref( *semantic_at_c<0>(*this), *semantic_at_c<1>(*this), *semantic_at_c<2>(*this)); } auto at(std::integral_constant) -> typename element_reference_type::type { return v0_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v0_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v1_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v1_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v2_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v2_; } // Support for planar_pixel_reference operator[] auto at_c_dynamic(std::size_t i) const -> Element { switch (i) { case 0: return v0_; case 1: return v1_; } return v2_; } private: Element v0_; Element v1_; Element v2_; }; /// \brief A homogeneous color base holding four color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template struct homogeneous_color_base { using layout_t = Layout; template < typename U = Element, typename = typename std::enable_if::value>::type > homogeneous_color_base() : v0_{}, v1_{}, v2_{}, v3_{} {} explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v), v3_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2, Element v3) : v0_(v0), v1_(v1), v2_(v2), v3_(v3) {} template homogeneous_color_base(homogeneous_color_base const& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) , v3_(gil::at_c::value>(c)) {} // Support for l-value reference proxy copy construction template homogeneous_color_base(homogeneous_color_base& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) , v3_(gil::at_c::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template homogeneous_color_base(P * p, bool) : v0_(&semantic_at_c<0>(*p)) , v1_(&semantic_at_c<1>(*p)) , v2_(&semantic_at_c<2>(*p)) , v3_(&semantic_at_c<3>(*p)) {} // Support for planar_pixel_reference offset constructor template homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(*memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(*memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(*memunit_advanced(semantic_at_c<2>(ptr), diff)) , v3_(*memunit_advanced(semantic_at_c<3>(ptr), diff)) {} template Ref deref() const { return Ref( *semantic_at_c<0>(*this), *semantic_at_c<1>(*this), *semantic_at_c<2>(*this), *semantic_at_c<3>(*this)); } auto at(std::integral_constant) -> typename element_reference_type::type { return v0_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v0_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v1_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v1_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v2_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v2_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v3_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v3_; } // Support for planar_pixel_reference operator[] auto at_c_dynamic(std::size_t i) const -> Element { switch (i) { case 0: return v0_; case 1: return v1_; case 2: return v2_; } return v3_; } private: Element v0_; Element v1_; Element v2_; Element v3_; }; /// \brief A homogeneous color base holding five color elements. /// Models HomogeneousColorBaseConcept or HomogeneousColorBaseValueConcept /// \ingroup ColorBaseModelHomogeneous template struct homogeneous_color_base { using layout_t = Layout; template < typename U = Element, typename = typename std::enable_if::value>::type > homogeneous_color_base() : v0_{}, v1_{}, v2_{}, v3_{}, v4_{} {} explicit homogeneous_color_base(Element v) : v0_(v), v1_(v), v2_(v), v3_(v), v4_(v) {} homogeneous_color_base(Element v0, Element v1, Element v2, Element v3, Element v4) : v0_(v0), v1_(v1), v2_(v2), v3_(v3), v4_(v4) {} template homogeneous_color_base(homogeneous_color_base const& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) , v3_(gil::at_c::value>(c)) , v4_(gil::at_c::value>(c)) {} // Support for l-value reference proxy copy construction template homogeneous_color_base(homogeneous_color_base& c) : v0_(gil::at_c::value>(c)) , v1_(gil::at_c::value>(c)) , v2_(gil::at_c::value>(c)) , v3_(gil::at_c::value>(c)) , v4_(gil::at_c::value>(c)) {} // Support for planar_pixel_iterator construction and dereferencing template homogeneous_color_base(P* p, bool) : v0_(&semantic_at_c<0>(*p)) , v1_(&semantic_at_c<1>(*p)) , v2_(&semantic_at_c<2>(*p)) , v3_(&semantic_at_c<3>(*p)) , v4_(&semantic_at_c<4>(*p)) {} // Support for planar_pixel_reference offset constructor template homogeneous_color_base(Ptr const& ptr, std::ptrdiff_t diff) : v0_(*memunit_advanced(semantic_at_c<0>(ptr), diff)) , v1_(*memunit_advanced(semantic_at_c<1>(ptr), diff)) , v2_(*memunit_advanced(semantic_at_c<2>(ptr), diff)) , v3_(*memunit_advanced(semantic_at_c<3>(ptr), diff)) , v4_(*memunit_advanced(semantic_at_c<4>(ptr), diff)) {} auto at(std::integral_constant) -> typename element_reference_type::type { return v0_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v0_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v1_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v1_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v2_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v2_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v3_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v3_; } auto at(std::integral_constant) -> typename element_reference_type::type { return v4_; } auto at(std::integral_constant) const -> typename element_const_reference_type::type { return v4_; } template Ref deref() const { return Ref( *semantic_at_c<0>(*this), *semantic_at_c<1>(*this), *semantic_at_c<2>(*this), *semantic_at_c<3>(*this), *semantic_at_c<4>(*this)); } // Support for planar_pixel_reference operator[] auto at_c_dynamic(std::size_t i) const -> Element { switch (i) { case 0: return v0_; case 1: return v1_; case 2: return v2_; case 3: return v3_; } return v4_; } private: Element v0_; Element v1_; Element v2_; Element v3_; Element v4_; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif // The following way of casting adjacent channels (the contents of color_base) into an array appears to be unsafe // -- there is no guarantee that the compiler won't add any padding between adjacent channels. // Note, however, that GIL _must_ be compiled with compiler settings ensuring there is no padding in the color base structs. // This is because the color base structs must model the interleaved organization in memory. In other words, the client may // have existing RGB image in the form "RGBRGBRGB..." and we must be able to represent it with an array of RGB color bases (i.e. RGB pixels) // with no padding. We have tested with char/int/float/double channels on gcc and VC and have so far discovered no problem. // We have even tried using strange channels consisting of short + char (3 bytes). With the default 4-byte alignment on VC, the size // of this channel is padded to 4 bytes, so an RGB pixel of it will be 4x3=12 bytes. The code below will still work properly. // However, the client must nevertheless ensure that proper compiler settings are used for their compiler and their channel types. template auto dynamic_at_c(homogeneous_color_base& cb, std::size_t i) -> typename element_reference_type>::type { BOOST_ASSERT(i < K); return (gil_reinterpret_cast(&cb))[i]; } template auto dynamic_at_c(homogeneous_color_base const& cb, std::size_t i) -> typename element_const_reference_type < homogeneous_color_base >::type { BOOST_ASSERT(i < K); return (gil_reinterpret_cast_c(&cb))[i]; } template auto dynamic_at_c(homogeneous_color_base const& cb, std::size_t i) -> typename element_reference_type < homogeneous_color_base >::type { BOOST_ASSERT(i < K); return cb.at_c_dynamic(i); } template auto dynamic_at_c( homogeneous_color_baseconst& cb, std::size_t i) -> typename element_const_reference_type < homogeneous_color_base >::type { BOOST_ASSERT(i < K); return cb.at_c_dynamic(i); } } // namespace detail template struct kth_element_type, K> { using type = Element; }; template struct kth_element_reference_type, K> : std::add_lvalue_reference {}; template struct kth_element_const_reference_type < detail::homogeneous_color_base, K > : std::add_lvalue_reference::type> {}; /// \brief Provides mutable access to the K-th element, in physical order /// \ingroup ColorBaseModelHomogeneous template inline auto at_c(detail::homogeneous_color_base& p) -> typename std::add_lvalue_reference::type { return p.at(std::integral_constant()); } /// \brief Provides constant access to the K-th element, in physical order /// \ingroup ColorBaseModelHomogeneous template inline auto at_c(const detail::homogeneous_color_base& p) -> typename std::add_lvalue_reference::type>::type { return p.at(std::integral_constant()); } namespace detail { struct swap_fn { template void operator()(T& x, T& y) const { using std::swap; swap(x, y); } }; } // namespace detail template inline void swap( detail::homogeneous_color_base& x, detail::homogeneous_color_base& y) { static_for_each(x, y, detail::swap_fn()); } }} // namespace boost::gil #endif