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 2018 The Abseil Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_ #define ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_ #include #include "absl/base/config.h" #include "absl/meta/type_traits.h" #include "absl/numeric/bits.h" #include "absl/numeric/int128.h" #include "absl/random/internal/fastmath.h" #include "absl/random/internal/iostream_state_saver.h" namespace absl { ABSL_NAMESPACE_BEGIN namespace random_internal { // pcg_engine is a simplified implementation of Melissa O'Neil's PCG engine in // C++. PCG combines a linear congruential generator (LCG) with output state // mixing functions to generate each random variate. pcg_engine supports only a // single sequence (oneseq), and does not support streams. // // pcg_engine is parameterized by two types: // Params, which provides the multiplier and increment values; // Mix, which mixes the state into the result. // template class pcg_engine { static_assert(std::is_same::value, "Class-template absl::pcg_engine must be parameterized by " "Params and Mix with identical state_type"); static_assert(std::is_unsigned::value, "Class-template absl::pcg_engine must be parameterized by " "an unsigned Mix::result_type"); using params_type = Params; using mix_type = Mix; using state_type = typename Mix::state_type; public: // C++11 URBG interface: using result_type = typename Mix::result_type; static constexpr result_type(min)() { return (std::numeric_limits::min)(); } static constexpr result_type(max)() { return (std::numeric_limits::max)(); } explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); } template ::value>> explicit pcg_engine(SeedSequence&& seq) { seed(seq); } pcg_engine(const pcg_engine&) = default; pcg_engine& operator=(const pcg_engine&) = default; pcg_engine(pcg_engine&&) = default; pcg_engine& operator=(pcg_engine&&) = default; result_type operator()() { // Advance the LCG state, always using the new value to generate the output. state_ = lcg(state_); return Mix{}(state_); } void seed(uint64_t seed_value = 0) { state_type tmp = seed_value; state_ = lcg(tmp + Params::increment()); } template typename absl::enable_if_t< !std::is_convertible::value, void> seed(SeedSequence&& seq) { reseed(seq); } void discard(uint64_t count) { state_ = advance(state_, count); } bool operator==(const pcg_engine& other) const { return state_ == other.state_; } bool operator!=(const pcg_engine& other) const { return !(*this == other); } template friend typename absl::enable_if_t<(sizeof(state_type) == 16), std::basic_ostream&> operator<<( std::basic_ostream& os, // NOLINT(runtime/references) const pcg_engine& engine) { auto saver = random_internal::make_ostream_state_saver(os); random_internal::stream_u128_helper helper; helper.write(pcg_engine::params_type::multiplier(), os); os << os.fill(); helper.write(pcg_engine::params_type::increment(), os); os << os.fill(); helper.write(engine.state_, os); return os; } template friend typename absl::enable_if_t<(sizeof(state_type) <= 8), std::basic_ostream&> operator<<( std::basic_ostream& os, // NOLINT(runtime/references) const pcg_engine& engine) { auto saver = random_internal::make_ostream_state_saver(os); os << pcg_engine::params_type::multiplier() << os.fill(); os << pcg_engine::params_type::increment() << os.fill(); os << engine.state_; return os; } template friend typename absl::enable_if_t<(sizeof(state_type) == 16), std::basic_istream&> operator>>( std::basic_istream& is, // NOLINT(runtime/references) pcg_engine& engine) { // NOLINT(runtime/references) random_internal::stream_u128_helper helper; auto mult = helper.read(is); auto inc = helper.read(is); auto tmp = helper.read(is); if (mult != pcg_engine::params_type::multiplier() || inc != pcg_engine::params_type::increment()) { // signal failure by setting the failbit. is.setstate(is.rdstate() | std::ios_base::failbit); } if (!is.fail()) { engine.state_ = tmp; } return is; } template friend typename absl::enable_if_t<(sizeof(state_type) <= 8), std::basic_istream&> operator>>( std::basic_istream& is, // NOLINT(runtime/references) pcg_engine& engine) { // NOLINT(runtime/references) state_type mult{}, inc{}, tmp{}; is >> mult >> inc >> tmp; if (mult != pcg_engine::params_type::multiplier() || inc != pcg_engine::params_type::increment()) { // signal failure by setting the failbit. is.setstate(is.rdstate() | std::ios_base::failbit); } if (!is.fail()) { engine.state_ = tmp; } return is; } private: state_type state_; // Returns the linear-congruential generator next state. static inline constexpr state_type lcg(state_type s) { return s * Params::multiplier() + Params::increment(); } // Returns the linear-congruential arbitrary seek state. inline state_type advance(state_type s, uint64_t n) const { state_type mult = Params::multiplier(); state_type inc = Params::increment(); state_type m = 1; state_type i = 0; while (n > 0) { if (n & 1) { m *= mult; i = i * mult + inc; } inc = (mult + 1) * inc; mult *= mult; n >>= 1; } return m * s + i; } template void reseed(SeedSequence& seq) { using sequence_result_type = typename SeedSequence::result_type; constexpr size_t kBufferSize = sizeof(state_type) / sizeof(sequence_result_type); sequence_result_type buffer[kBufferSize]; seq.generate(std::begin(buffer), std::end(buffer)); // Convert the seed output to a single state value. state_type tmp = buffer[0]; for (size_t i = 1; i < kBufferSize; i++) { tmp <<= (sizeof(sequence_result_type) * 8); tmp |= buffer[i]; } state_ = lcg(tmp + params_type::increment()); } }; // Parameterized implementation of the PCG 128-bit oneseq state. // This provides state_type, multiplier, and increment for pcg_engine. template class pcg128_params { public: using state_type = absl::uint128; static inline constexpr state_type multiplier() { return absl::MakeUint128(kMultA, kMultB); } static inline constexpr state_type increment() { return absl::MakeUint128(kIncA, kIncB); } }; // Implementation of the PCG xsl_rr_128_64 128-bit mixing function, which // accepts an input of state_type and mixes it into an output of result_type. struct pcg_xsl_rr_128_64 { using state_type = absl::uint128; using result_type = uint64_t; inline uint64_t operator()(state_type state) { // This is equivalent to the xsl_rr_128_64 mixing function. uint64_t rotate = static_cast(state >> 122u); state ^= state >> 64; uint64_t s = static_cast(state); return rotr(s, static_cast(rotate)); } }; // Parameterized implementation of the PCG 64-bit oneseq state. // This provides state_type, multiplier, and increment for pcg_engine. template class pcg64_params { public: using state_type = uint64_t; static inline constexpr state_type multiplier() { return kMult; } static inline constexpr state_type increment() { return kInc; } }; // Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts // an input of state_type and mixes it into an output of result_type. struct pcg_xsh_rr_64_32 { using state_type = uint64_t; using result_type = uint32_t; inline uint32_t operator()(uint64_t state) { return rotr(static_cast(((state >> 18) ^ state) >> 27), state >> 59); } }; // Stable pcg_engine implementations: // This is a 64-bit generator using 128-bits of state. // The output sequence is equivalent to Melissa O'Neil's pcg64_oneseq. using pcg64_2018_engine = pcg_engine< random_internal::pcg128_params<0x2360ed051fc65da4ull, 0x4385df649fccf645ull, 0x5851f42d4c957f2d, 0x14057b7ef767814f>, random_internal::pcg_xsl_rr_128_64>; // This is a 32-bit generator using 64-bits of state. // This is equivalent to Melissa O'Neil's pcg32_oneseq. using pcg32_2018_engine = pcg_engine< random_internal::pcg64_params<0x5851f42d4c957f2dull, 0x14057b7ef767814full>, random_internal::pcg_xsh_rr_64_32>; } // namespace random_internal ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_RANDOM_INTERNAL_PCG_ENGINE_H_