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 2017 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_BETA_DISTRIBUTION_H_ #define ABSL_RANDOM_BETA_DISTRIBUTION_H_ #include #include #include #include #include #include #include #include "absl/base/attributes.h" #include "absl/base/config.h" #include "absl/meta/type_traits.h" #include "absl/random/internal/fast_uniform_bits.h" #include "absl/random/internal/generate_real.h" #include "absl/random/internal/iostream_state_saver.h" namespace absl { ABSL_NAMESPACE_BEGIN // absl::beta_distribution: // Generate a floating-point variate conforming to a Beta distribution: // pdf(x) \propto x^(alpha-1) * (1-x)^(beta-1), // where the params alpha and beta are both strictly positive real values. // // The support is the open interval (0, 1), but the return value might be equal // to 0 or 1, due to numerical errors when alpha and beta are very different. // // Usage note: One usage is that alpha and beta are counts of number of // successes and failures. When the total number of trials are large, consider // approximating a beta distribution with a Gaussian distribution with the same // mean and variance. One could use the skewness, which depends only on the // smaller of alpha and beta when the number of trials are sufficiently large, // to quantify how far a beta distribution is from the normal distribution. template class beta_distribution { public: using result_type = RealType; class param_type { public: using distribution_type = beta_distribution; explicit param_type(result_type alpha, result_type beta) : alpha_(alpha), beta_(beta) { assert(alpha >= 0); assert(beta >= 0); assert(alpha <= (std::numeric_limits::max)()); assert(beta <= (std::numeric_limits::max)()); if (alpha == 0 || beta == 0) { method_ = DEGENERATE_SMALL; x_ = (alpha >= beta) ? 1 : 0; return; } // a_ = min(beta, alpha), b_ = max(beta, alpha). if (beta < alpha) { inverted_ = true; a_ = beta; b_ = alpha; } else { inverted_ = false; a_ = alpha; b_ = beta; } if (a_ <= 1 && b_ >= ThresholdForLargeA()) { method_ = DEGENERATE_SMALL; x_ = inverted_ ? result_type(1) : result_type(0); return; } // For threshold values, see also: // Evaluation of Beta Generation Algorithms, Ying-Chao Hung, et. al. // February, 2009. if ((b_ < 1.0 && a_ + b_ <= 1.2) || a_ <= ThresholdForSmallA()) { // Choose Joehnk over Cheng when it's faster or when Cheng encounters // numerical issues. method_ = JOEHNK; a_ = result_type(1) / alpha_; b_ = result_type(1) / beta_; if (std::isinf(a_) || std::isinf(b_)) { method_ = DEGENERATE_SMALL; x_ = inverted_ ? result_type(1) : result_type(0); } return; } if (a_ >= ThresholdForLargeA()) { method_ = DEGENERATE_LARGE; // Note: on PPC for long double, evaluating // `std::numeric_limits::max() / ThresholdForLargeA` results in NaN. result_type r = a_ / b_; x_ = (inverted_ ? result_type(1) : r) / (1 + r); return; } x_ = a_ + b_; log_x_ = std::log(x_); if (a_ <= 1) { method_ = CHENG_BA; y_ = result_type(1) / a_; gamma_ = a_ + a_; return; } method_ = CHENG_BB; result_type r = (a_ - 1) / (b_ - 1); y_ = std::sqrt((1 + r) / (b_ * r * 2 - r + 1)); gamma_ = a_ + result_type(1) / y_; } result_type alpha() const { return alpha_; } result_type beta() const { return beta_; } friend bool operator==(const param_type& a, const param_type& b) { return a.alpha_ == b.alpha_ && a.beta_ == b.beta_; } friend bool operator!=(const param_type& a, const param_type& b) { return !(a == b); } private: friend class beta_distribution; #ifdef _MSC_VER // MSVC does not have constexpr implementations for std::log and std::exp // so they are computed at runtime. #define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR #else #define ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR constexpr #endif // The threshold for whether std::exp(1/a) is finite. // Note that this value is quite large, and a smaller a_ is NOT abnormal. static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type ThresholdForSmallA() { return result_type(1) / std::log((std::numeric_limits::max)()); } // The threshold for whether a * std::log(a) is finite. static ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR result_type ThresholdForLargeA() { return std::exp( std::log((std::numeric_limits::max)()) - std::log(std::log((std::numeric_limits::max)())) - ThresholdPadding()); } #undef ABSL_RANDOM_INTERNAL_LOG_EXP_CONSTEXPR // Pad the threshold for large A for long double on PPC. This is done via a // template specialization below. static constexpr result_type ThresholdPadding() { return 0; } enum Method { JOEHNK, // Uses algorithm Joehnk CHENG_BA, // Uses algorithm BA in Cheng CHENG_BB, // Uses algorithm BB in Cheng // Note: See also: // Hung et al. Evaluation of beta generation algorithms. Communications // in Statistics-Simulation and Computation 38.4 (2009): 750-770. // especially: // Zechner, Heinz, and Ernst Stadlober. Generating beta variates via // patchwork rejection. Computing 50.1 (1993): 1-18. DEGENERATE_SMALL, // a_ is abnormally small. DEGENERATE_LARGE, // a_ is abnormally large. }; result_type alpha_; result_type beta_; result_type a_{}; // the smaller of {alpha, beta}, or 1.0/alpha_ in JOEHNK result_type b_{}; // the larger of {alpha, beta}, or 1.0/beta_ in JOEHNK result_type x_{}; // alpha + beta, or the result in degenerate cases result_type log_x_{}; // log(x_) result_type y_{}; // "beta" in Cheng result_type gamma_{}; // "gamma" in Cheng Method method_{}; // Placing this last for optimal alignment. // Whether alpha_ != a_, i.e. true iff alpha_ > beta_. bool inverted_{}; static_assert(std::is_floating_point::value, "Class-template absl::beta_distribution<> must be " "parameterized using a floating-point type."); }; beta_distribution() : beta_distribution(1) {} explicit beta_distribution(result_type alpha, result_type beta = 1) : param_(alpha, beta) {} explicit beta_distribution(const param_type& p) : param_(p) {} void reset() {} // Generating functions template result_type operator()(URBG& g) { // NOLINT(runtime/references) return (*this)(g, param_); } template result_type operator()(URBG& g, // NOLINT(runtime/references) const param_type& p); param_type param() const { return param_; } void param(const param_type& p) { param_ = p; } result_type(min)() const { return 0; } result_type(max)() const { return 1; } result_type alpha() const { return param_.alpha(); } result_type beta() const { return param_.beta(); } friend bool operator==(const beta_distribution& a, const beta_distribution& b) { return a.param_ == b.param_; } friend bool operator!=(const beta_distribution& a, const beta_distribution& b) { return a.param_ != b.param_; } private: template result_type AlgorithmJoehnk(URBG& g, // NOLINT(runtime/references) const param_type& p); template result_type AlgorithmCheng(URBG& g, // NOLINT(runtime/references) const param_type& p); template result_type DegenerateCase(URBG& g, // NOLINT(runtime/references) const param_type& p) { if (p.method_ == param_type::DEGENERATE_SMALL && p.alpha_ == p.beta_) { // Returns 0 or 1 with equal probability. random_internal::FastUniformBits fast_u8; return static_cast((fast_u8(g) & 0x10) != 0); // pick any single bit. } return p.x_; } param_type param_; random_internal::FastUniformBits fast_u64_; }; #if defined(__powerpc64__) || defined(__PPC64__) || defined(__powerpc__) || \ defined(__ppc__) || defined(__PPC__) // PPC needs a more stringent boundary for long double. template <> constexpr long double beta_distribution::param_type::ThresholdPadding() { return 10; } #endif template template typename beta_distribution::result_type beta_distribution::AlgorithmJoehnk( URBG& g, // NOLINT(runtime/references) const param_type& p) { using random_internal::GeneratePositiveTag; using random_internal::GenerateRealFromBits; using real_type = absl::conditional_t::value, float, double>; // Based on Joehnk, M. D. Erzeugung von betaverteilten und gammaverteilten // Zufallszahlen. Metrika 8.1 (1964): 5-15. // This method is described in Knuth, Vol 2 (Third Edition), pp 134. result_type u, v, x, y, z; for (;;) { u = GenerateRealFromBits( fast_u64_(g)); v = GenerateRealFromBits( fast_u64_(g)); // Direct method. std::pow is slow for float, so rely on the optimizer to // remove the std::pow() path for that case. if (!std::is_same::value) { x = std::pow(u, p.a_); y = std::pow(v, p.b_); z = x + y; if (z > 1) { // Reject if and only if `x + y > 1.0` continue; } if (z > 0) { // When both alpha and beta are small, x and y are both close to 0, so // divide by (x+y) directly may result in nan. return x / z; } } // Log transform. // x = log( pow(u, p.a_) ), y = log( pow(v, p.b_) ) // since u, v <= 1.0, x, y < 0. x = std::log(u) * p.a_; y = std::log(v) * p.b_; if (!std::isfinite(x) || !std::isfinite(y)) { continue; } // z = log( pow(u, a) + pow(v, b) ) z = x > y ? (x + std::log(1 + std::exp(y - x))) : (y + std::log(1 + std::exp(x - y))); // Reject iff log(x+y) > 0. if (z > 0) { continue; } return std::exp(x - z); } } template template typename beta_distribution::result_type beta_distribution::AlgorithmCheng( URBG& g, // NOLINT(runtime/references) const param_type& p) { using random_internal::GeneratePositiveTag; using random_internal::GenerateRealFromBits; using real_type = absl::conditional_t::value, float, double>; // Based on Cheng, Russell CH. Generating beta variates with nonintegral // shape parameters. Communications of the ACM 21.4 (1978): 317-322. // (https://dl.acm.org/citation.cfm?id=359482). static constexpr result_type kLogFour = result_type(1.3862943611198906188344642429163531361); // log(4) static constexpr result_type kS = result_type(2.6094379124341003746007593332261876); // 1+log(5) const bool use_algorithm_ba = (p.method_ == param_type::CHENG_BA); result_type u1, u2, v, w, z, r, s, t, bw_inv, lhs; for (;;) { u1 = GenerateRealFromBits( fast_u64_(g)); u2 = GenerateRealFromBits( fast_u64_(g)); v = p.y_ * std::log(u1 / (1 - u1)); w = p.a_ * std::exp(v); bw_inv = result_type(1) / (p.b_ + w); r = p.gamma_ * v - kLogFour; s = p.a_ + r - w; z = u1 * u1 * u2; if (!use_algorithm_ba && s + kS >= 5 * z) { break; } t = std::log(z); if (!use_algorithm_ba && s >= t) { break; } lhs = p.x_ * (p.log_x_ + std::log(bw_inv)) + r; if (lhs >= t) { break; } } return p.inverted_ ? (1 - w * bw_inv) : w * bw_inv; } template template typename beta_distribution::result_type beta_distribution::operator()(URBG& g, // NOLINT(runtime/references) const param_type& p) { switch (p.method_) { case param_type::JOEHNK: return AlgorithmJoehnk(g, p); case param_type::CHENG_BA: ABSL_FALLTHROUGH_INTENDED; case param_type::CHENG_BB: return AlgorithmCheng(g, p); default: return DegenerateCase(g, p); } } template std::basic_ostream& operator<<( std::basic_ostream& os, // NOLINT(runtime/references) const beta_distribution& x) { auto saver = random_internal::make_ostream_state_saver(os); os.precision(random_internal::stream_precision_helper::kPrecision); os << x.alpha() << os.fill() << x.beta(); return os; } template std::basic_istream& operator>>( std::basic_istream& is, // NOLINT(runtime/references) beta_distribution& x) { // NOLINT(runtime/references) using result_type = typename beta_distribution::result_type; using param_type = typename beta_distribution::param_type; result_type alpha, beta; auto saver = random_internal::make_istream_state_saver(is); alpha = random_internal::read_floating_point(is); if (is.fail()) return is; beta = random_internal::read_floating_point(is); if (!is.fail()) { x.param(param_type(alpha, beta)); } return is; } ABSL_NAMESPACE_END } // namespace absl #endif // ABSL_RANDOM_BETA_DISTRIBUTION_H_