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) 2022-2023 Christian Mazakas // Copyright (C) 2024-2025 Joaquin M Lopez Munoz // 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_UNORDERED_UNORDERED_FLAT_MAP_HPP_INCLUDED #define BOOST_UNORDERED_UNORDERED_FLAT_MAP_HPP_INCLUDED #include #if defined(BOOST_HAS_PRAGMA_ONCE) #pragma once #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace unordered { #if defined(BOOST_MSVC) #pragma warning(push) #pragma warning(disable : 4714) /* marked as __forceinline not inlined */ #endif template class unordered_flat_map { template friend class concurrent_flat_map; using map_types = detail::foa::flat_map_types; using table_type = detail::foa::table::type>; table_type table_; template bool friend operator==(unordered_flat_map const& lhs, unordered_flat_map const& rhs); template typename unordered_flat_map::size_type friend erase_if( unordered_flat_map& set, Pred pred); public: using key_type = Key; using mapped_type = T; using value_type = typename map_types::value_type; using init_type = typename map_types::init_type; using size_type = std::size_t; using difference_type = std::ptrdiff_t; using hasher = typename boost::unordered::detail::type_identity::type; using key_equal = typename boost::unordered::detail::type_identity::type; using allocator_type = typename boost::unordered::detail::type_identity::type; using reference = value_type&; using const_reference = value_type const&; using pointer = typename boost::allocator_pointer::type; using const_pointer = typename boost::allocator_const_pointer::type; using iterator = typename table_type::iterator; using const_iterator = typename table_type::const_iterator; #if defined(BOOST_UNORDERED_ENABLE_STATS) using stats = typename table_type::stats; #endif unordered_flat_map() : unordered_flat_map(0) {} explicit unordered_flat_map(size_type n, hasher const& h = hasher(), key_equal const& pred = key_equal(), allocator_type const& a = allocator_type()) : table_(n, h, pred, a) { } unordered_flat_map(size_type n, allocator_type const& a) : unordered_flat_map(n, hasher(), key_equal(), a) { } unordered_flat_map(size_type n, hasher const& h, allocator_type const& a) : unordered_flat_map(n, h, key_equal(), a) { } template unordered_flat_map( InputIterator f, InputIterator l, allocator_type const& a) : unordered_flat_map(f, l, size_type(0), hasher(), key_equal(), a) { } explicit unordered_flat_map(allocator_type const& a) : unordered_flat_map(0, a) { } template unordered_flat_map(Iterator first, Iterator last, size_type n = 0, hasher const& h = hasher(), key_equal const& pred = key_equal(), allocator_type const& a = allocator_type()) : unordered_flat_map(n, h, pred, a) { this->insert(first, last); } template unordered_flat_map( Iterator first, Iterator last, size_type n, allocator_type const& a) : unordered_flat_map(first, last, n, hasher(), key_equal(), a) { } template unordered_flat_map(Iterator first, Iterator last, size_type n, hasher const& h, allocator_type const& a) : unordered_flat_map(first, last, n, h, key_equal(), a) { } unordered_flat_map(unordered_flat_map const& other) : table_(other.table_) { } unordered_flat_map( unordered_flat_map const& other, allocator_type const& a) : table_(other.table_, a) { } unordered_flat_map(unordered_flat_map&& other) noexcept(std::is_nothrow_move_constructible::value) : table_(std::move(other.table_)) { } unordered_flat_map(unordered_flat_map&& other, allocator_type const& al) : table_(std::move(other.table_), al) { } unordered_flat_map(std::initializer_list ilist, size_type n = 0, hasher const& h = hasher(), key_equal const& pred = key_equal(), allocator_type const& a = allocator_type()) : unordered_flat_map(ilist.begin(), ilist.end(), n, h, pred, a) { } unordered_flat_map( std::initializer_list il, allocator_type const& a) : unordered_flat_map(il, size_type(0), hasher(), key_equal(), a) { } unordered_flat_map(std::initializer_list init, size_type n, allocator_type const& a) : unordered_flat_map(init, n, hasher(), key_equal(), a) { } unordered_flat_map(std::initializer_list init, size_type n, hasher const& h, allocator_type const& a) : unordered_flat_map(init, n, h, key_equal(), a) { } template unordered_flat_map( concurrent_flat_map&& other) : table_(std::move(other.table_)) { } ~unordered_flat_map() = default; unordered_flat_map& operator=(unordered_flat_map const& other) { table_ = other.table_; return *this; } unordered_flat_map& operator=(unordered_flat_map&& other) noexcept( noexcept(std::declval() = std::declval())) { table_ = std::move(other.table_); return *this; } unordered_flat_map& operator=(std::initializer_list il) { this->clear(); this->insert(il.begin(), il.end()); return *this; } allocator_type get_allocator() const noexcept { return table_.get_allocator(); } /// Iterators /// iterator begin() noexcept { return table_.begin(); } const_iterator begin() const noexcept { return table_.begin(); } const_iterator cbegin() const noexcept { return table_.cbegin(); } iterator end() noexcept { return table_.end(); } const_iterator end() const noexcept { return table_.end(); } const_iterator cend() const noexcept { return table_.cend(); } /// Capacity /// BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept { return table_.empty(); } size_type size() const noexcept { return table_.size(); } size_type max_size() const noexcept { return table_.max_size(); } /// Modifiers /// void clear() noexcept { table_.clear(); } template BOOST_FORCEINLINE auto insert(Ty&& value) -> decltype(table_.insert(std::forward(value))) { return table_.insert(std::forward(value)); } BOOST_FORCEINLINE std::pair insert(init_type&& value) { return table_.insert(std::move(value)); } template BOOST_FORCEINLINE auto insert(const_iterator, Ty&& value) -> decltype(table_.insert(std::forward(value)).first) { return table_.insert(std::forward(value)).first; } BOOST_FORCEINLINE iterator insert(const_iterator, init_type&& value) { return table_.insert(std::move(value)).first; } template BOOST_FORCEINLINE void insert(InputIterator first, InputIterator last) { for (auto pos = first; pos != last; ++pos) { table_.emplace(*pos); } } void insert(std::initializer_list ilist) { this->insert(ilist.begin(), ilist.end()); } template std::pair insert_or_assign(key_type const& key, M&& obj) { auto ibp = table_.try_emplace(key, std::forward(obj)); if (ibp.second) { return ibp; } ibp.first->second = std::forward(obj); return ibp; } template std::pair insert_or_assign(key_type&& key, M&& obj) { auto ibp = table_.try_emplace(std::move(key), std::forward(obj)); if (ibp.second) { return ibp; } ibp.first->second = std::forward(obj); return ibp; } template typename std::enable_if< boost::unordered::detail::are_transparent::value, std::pair >::type insert_or_assign(K&& k, M&& obj) { auto ibp = table_.try_emplace(std::forward(k), std::forward(obj)); if (ibp.second) { return ibp; } ibp.first->second = std::forward(obj); return ibp; } template iterator insert_or_assign(const_iterator, key_type const& key, M&& obj) { return this->insert_or_assign(key, std::forward(obj)).first; } template iterator insert_or_assign(const_iterator, key_type&& key, M&& obj) { return this->insert_or_assign(std::move(key), std::forward(obj)) .first; } template typename std::enable_if< boost::unordered::detail::are_transparent::value, iterator>::type insert_or_assign(const_iterator, K&& k, M&& obj) { return this->insert_or_assign(std::forward(k), std::forward(obj)) .first; } template BOOST_FORCEINLINE std::pair emplace(Args&&... args) { return table_.emplace(std::forward(args)...); } template BOOST_FORCEINLINE iterator emplace_hint(const_iterator, Args&&... args) { return table_.emplace(std::forward(args)...).first; } template BOOST_FORCEINLINE std::pair try_emplace( key_type const& key, Args&&... args) { return table_.try_emplace(key, std::forward(args)...); } template BOOST_FORCEINLINE std::pair try_emplace( key_type&& key, Args&&... args) { return table_.try_emplace(std::move(key), std::forward(args)...); } template BOOST_FORCEINLINE typename std::enable_if< boost::unordered::detail::transparent_non_iterable::value, std::pair >::type try_emplace(K&& key, Args&&... args) { return table_.try_emplace( std::forward(key), std::forward(args)...); } template BOOST_FORCEINLINE iterator try_emplace( const_iterator, key_type const& key, Args&&... args) { return table_.try_emplace(key, std::forward(args)...).first; } template BOOST_FORCEINLINE iterator try_emplace( const_iterator, key_type&& key, Args&&... args) { return table_.try_emplace(std::move(key), std::forward(args)...) .first; } template BOOST_FORCEINLINE typename std::enable_if< boost::unordered::detail::transparent_non_iterable::value, iterator>::type try_emplace(const_iterator, K&& key, Args&&... args) { return table_ .try_emplace(std::forward(key), std::forward(args)...) .first; } BOOST_FORCEINLINE typename table_type::erase_return_type erase( iterator pos) { return table_.erase(pos); } BOOST_FORCEINLINE typename table_type::erase_return_type erase( const_iterator pos) { return table_.erase(pos); } iterator erase(const_iterator first, const_iterator last) { while (first != last) { this->erase(first++); } return iterator{detail::foa::const_iterator_cast_tag{}, last}; } BOOST_FORCEINLINE size_type erase(key_type const& key) { return table_.erase(key); } template BOOST_FORCEINLINE typename std::enable_if< detail::transparent_non_iterable::value, size_type>::type erase(K const& key) { return table_.erase(key); } BOOST_FORCEINLINE init_type pull(const_iterator pos) { return table_.pull(pos); } void swap(unordered_flat_map& rhs) noexcept( noexcept(std::declval().swap(std::declval()))) { table_.swap(rhs.table_); } template void merge( unordered_flat_map& source) { table_.merge(source.table_); } template void merge( unordered_flat_map&& source) { table_.merge(std::move(source.table_)); } /// Lookup /// mapped_type& at(key_type const& key) { auto pos = table_.find(key); if (pos != table_.end()) { return pos->second; } // TODO: someday refactor this to conditionally serialize the key and // include it in the error message // boost::unordered::detail::throw_out_of_range( "key was not found in unordered_flat_map"); } mapped_type const& at(key_type const& key) const { auto pos = table_.find(key); if (pos != table_.end()) { return pos->second; } boost::unordered::detail::throw_out_of_range( "key was not found in unordered_flat_map"); } template typename std::enable_if< boost::unordered::detail::are_transparent::value, mapped_type&>::type at(K&& key) { auto pos = table_.find(std::forward(key)); if (pos != table_.end()) { return pos->second; } boost::unordered::detail::throw_out_of_range( "key was not found in unordered_flat_map"); } template typename std::enable_if< boost::unordered::detail::are_transparent::value, mapped_type const&>::type at(K&& key) const { auto pos = table_.find(std::forward(key)); if (pos != table_.end()) { return pos->second; } boost::unordered::detail::throw_out_of_range( "key was not found in unordered_flat_map"); } BOOST_FORCEINLINE mapped_type& operator[](key_type const& key) { return table_.try_emplace(key).first->second; } BOOST_FORCEINLINE mapped_type& operator[](key_type&& key) { return table_.try_emplace(std::move(key)).first->second; } template typename std::enable_if< boost::unordered::detail::are_transparent::value, mapped_type&>::type operator[](K&& key) { return table_.try_emplace(std::forward(key)).first->second; } BOOST_FORCEINLINE size_type count(key_type const& key) const { auto pos = table_.find(key); return pos != table_.end() ? 1 : 0; } template BOOST_FORCEINLINE typename std::enable_if< detail::are_transparent::value, size_type>::type count(K const& key) const { auto pos = table_.find(key); return pos != table_.end() ? 1 : 0; } BOOST_FORCEINLINE iterator find(key_type const& key) { return table_.find(key); } BOOST_FORCEINLINE const_iterator find(key_type const& key) const { return table_.find(key); } template BOOST_FORCEINLINE typename std::enable_if< boost::unordered::detail::are_transparent::value, iterator>::type find(K const& key) { return table_.find(key); } template BOOST_FORCEINLINE typename std::enable_if< boost::unordered::detail::are_transparent::value, const_iterator>::type find(K const& key) const { return table_.find(key); } BOOST_FORCEINLINE bool contains(key_type const& key) const { return this->find(key) != this->end(); } template BOOST_FORCEINLINE typename std::enable_if< boost::unordered::detail::are_transparent::value, bool>::type contains(K const& key) const { return this->find(key) != this->end(); } std::pair equal_range(key_type const& key) { auto pos = table_.find(key); if (pos == table_.end()) { return {pos, pos}; } auto next = pos; ++next; return {pos, next}; } std::pair equal_range( key_type const& key) const { auto pos = table_.find(key); if (pos == table_.end()) { return {pos, pos}; } auto next = pos; ++next; return {pos, next}; } template typename std::enable_if< detail::are_transparent::value, std::pair >::type equal_range(K const& key) { auto pos = table_.find(key); if (pos == table_.end()) { return {pos, pos}; } auto next = pos; ++next; return {pos, next}; } template typename std::enable_if< detail::are_transparent::value, std::pair >::type equal_range(K const& key) const { auto pos = table_.find(key); if (pos == table_.end()) { return {pos, pos}; } auto next = pos; ++next; return {pos, next}; } /// Hash Policy /// size_type bucket_count() const noexcept { return table_.capacity(); } float load_factor() const noexcept { return table_.load_factor(); } float max_load_factor() const noexcept { return table_.max_load_factor(); } void max_load_factor(float) {} size_type max_load() const noexcept { return table_.max_load(); } void rehash(size_type n) { table_.rehash(n); } void reserve(size_type n) { table_.reserve(n); } #if defined(BOOST_UNORDERED_ENABLE_STATS) /// Stats /// stats get_stats() const { return table_.get_stats(); } void reset_stats() noexcept { table_.reset_stats(); } #endif /// Observers /// hasher hash_function() const { return table_.hash_function(); } key_equal key_eq() const { return table_.key_eq(); } }; template bool operator==( unordered_flat_map const& lhs, unordered_flat_map const& rhs) { return lhs.table_ == rhs.table_; } template bool operator!=( unordered_flat_map const& lhs, unordered_flat_map const& rhs) { return !(lhs == rhs); } template void swap(unordered_flat_map& lhs, unordered_flat_map& rhs) noexcept(noexcept(lhs.swap(rhs))) { lhs.swap(rhs); } template typename unordered_flat_map::size_type erase_if( unordered_flat_map& map, Pred pred) { return erase_if(map.table_, pred); } template void serialize(Archive& ar, unordered_flat_map& map, unsigned int version) { detail::serialize_container(ar, map, version); } #if defined(BOOST_MSVC) #pragma warning(pop) /* C4714 */ #endif #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES template >, class Pred = std::equal_to >, class Allocator = std::allocator< boost::unordered::detail::iter_to_alloc_t >, class = std::enable_if_t >, class = std::enable_if_t >, class = std::enable_if_t >, class = std::enable_if_t > > unordered_flat_map(InputIterator, InputIterator, std::size_t = boost::unordered::detail::foa::default_bucket_count, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_flat_map, boost::unordered::detail::iter_val_t, Hash, Pred, Allocator>; template >, class Pred = std::equal_to >, class Allocator = std::allocator >, class = std::enable_if_t >, class = std::enable_if_t >, class = std::enable_if_t > > unordered_flat_map(std::initializer_list >, std::size_t = boost::unordered::detail::foa::default_bucket_count, Hash = Hash(), Pred = Pred(), Allocator = Allocator()) -> unordered_flat_map, T, Hash, Pred, Allocator>; template >, class = std::enable_if_t > > unordered_flat_map(InputIterator, InputIterator, std::size_t, Allocator) -> unordered_flat_map, boost::unordered::detail::iter_val_t, boost::hash >, std::equal_to >, Allocator>; template >, class = std::enable_if_t > > unordered_flat_map(InputIterator, InputIterator, Allocator) -> unordered_flat_map, boost::unordered::detail::iter_val_t, boost::hash >, std::equal_to >, Allocator>; template >, class = std::enable_if_t >, class = std::enable_if_t > > unordered_flat_map( InputIterator, InputIterator, std::size_t, Hash, Allocator) -> unordered_flat_map, boost::unordered::detail::iter_val_t, Hash, std::equal_to >, Allocator>; template > > unordered_flat_map(std::initializer_list >, std::size_t, Allocator) -> unordered_flat_map, T, boost::hash >, std::equal_to >, Allocator>; template > > unordered_flat_map(std::initializer_list >, Allocator) -> unordered_flat_map, T, boost::hash >, std::equal_to >, Allocator>; template >, class = std::enable_if_t > > unordered_flat_map(std::initializer_list >, std::size_t, Hash, Allocator) -> unordered_flat_map, T, Hash, std::equal_to >, Allocator>; #endif } // namespace unordered } // namespace boost #endif