#include <random>

std::uniform_real_distribution<long double> dis(0.,1.); // Default is double
std::random_device rd;
std::mt19937 gen(rd());

long double pi_estimate(long long n, int seed=0) {
    gen.seed(seed);
    long long inside=0;
    for (auto i=0; i!=n; ++i) if (std::pow(dis(gen),2)+std::pow(dis(gen),2) < 1.) ++inside;
    return (4.*inside)/n; 
}

#include <vector>
#include <algorithm>
#include <utility>

bool Ordering(const std::vector<int> &num) {
  if (num.size()<=1) return true;
  return std::none_of(std::next(num.cbegin()),num.end(),
                      [prev=num[0]](int val) mutable {
                        return val<std::exchange(prev,val);
                      });
}

#include <string>
#include <string_view>
#include <vector>
#include <numeric>

std::string Jointup(const std::vector<std::string> &name , const std::string_view delim = " , "){
  if (name.empty()) return "";
  return std::accumulate(std::next(name.begin()),name.end(),
                         name.front(),
                         [&](auto &s, auto &n){return s.append(delim).append(n);});
}

#include <fmt/format.h>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>
#include <bitset>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <random>


static const std::string msgs[]={
  "Enter your guess (a 4-digit number with non-repeating digits): ",
  "Correct numbers: {} Correct position: {}",
  "Congratulations! You guessed the number {} correctly in {} attempts!",
  "Oups.. You could not guess the number in {} attempts!",
  "Invalid input. Please enter a 4-digit number with non-repeating digits."
};

// Initialize random number generator outside functions
static std::random_device rd;  // Obtain a random number from hardware
static std::mt19937 g(rd());   // Seed the generator

std::string generateRandomNumber() {
    static std::string base{"0123456789"}; 

    // Shuffle digits
    std::shuffle(base.begin(), base.end(), g);

    // Return the first 4 digits as a string
    return base.substr(0,4);
}

bool hasDuplicateDigits(const std::string &number) {
    return std::accumulate(number.cbegin(),number.cend(), std::bitset<10>{0},
                         [](auto &bs,auto c) {return bs.set(c-'0');}
                         ).count()!=number.size();
}

bool isNumeric(const std::string &s) {
    return std::all_of(s.begin(), s.end(), ::isdigit);
}

std::string getUserGuess(std::istream &in = std::cin, std::ostream &out = std::cout) {
    std::string guess;
    out << msgs[0];
    in >> guess;
    return guess;
}

std::pair<int, int> checkGuess(const std::string &randomNumber, const std::string &userGuess) {
    std::pair<int, int> ret {0,0};
  
    for (int i = 0; i < 4; ++i) {
        if (randomNumber[i] == userGuess[i]) {
            ++std::get<0>(ret), ++std::get<1>(ret);
        } else if (std::count(randomNumber.begin(), randomNumber.end(), userGuess[i])) {
            ++std::get<0>(ret);
        }
    }

    return ret;
}

int acceptGuess(const std::string &expected, std::istream &in = std::cin, std::ostream &out = std::cout, int maxattempts=20) {
    int attempts = 0;
    std::pair status{0,0};
    do {
        std::string userGuess = getUserGuess(in, out);
        if (userGuess.length() != 4 || hasDuplicateDigits(userGuess) || !isNumeric(userGuess)) {
            out << msgs[4] << std::endl;
        } else {
          status = checkGuess(expected, userGuess);
          out << fmt::format(msgs[1],status.first,status.second) << std::endl;
        }
        attempts++;
    } while (status.second!=4 && attempts<maxattempts);
    
    if (attempts==maxattempts)
       out << fmt::format(msgs[3],attempts)<< std::endl;
    else 
       out << fmt::format(msgs[2],expected,attempts)<< std::endl;
    return attempts;
}

int _main(std::istream &in = std::cin, std::ostream &out = std::cout) {
    // Seed rand since random_shuffle _probably_ uses it.
    srand(static_cast<unsigned>(time(0)));
    std::string randomNumber = generateRandomNumber();
    acceptGuess(randomNumber, in, out);
    return 0;
}

#include <vector>
#include <numeric>

template <typename T> using add_t=decltype(T() + T());

template <typename T = double>
add_t<T> sum(const std::vector<T>& v) {
  return std::accumulate(v.cbegin(),v.cend(),add_t<T>{0});
}

#include <vector>
#include <numeric>
std::vector<int> gradient(const std::vector<int> &v) {
  std::vector<int> dv(v.size());
  std::adjacent_difference(v.cbegin(),v.cend(),dv.begin());
  dv.erase(dv.begin());
  return dv;
}

#include <string>
#include <numeric>
std::string digest(const std::string& param) {
    return param.empty()? 
               param
             : std::accumulate(std::next(param.cbegin()),param.cend(),
                               std::string(1,param[0]),
                               [](auto &s, auto c) {return s.append(" ").append(1,c);});
}

#include <numeric>
#include <stdint.h>
#include <vector>
#include <range/v3/numeric/accumulate.hpp>

int64_t add_arr(const std::vector<int32_t> &arr) {
  return ranges::accumulate(arr, (int64_t)0);
}

#include <string>
#include <algorithm>

class Password{
    public:
        static bool atLeastOneOf(const std::string& pw,std::string_view sv);
        static bool testPassword(const std::string& password);
};
bool Password::atLeastOneOf(const std::string& pw,std::string_view sv) {
  return std::any_of(pw.begin(),pw.end(),[&](char c){return sv.find(c)!=sv.npos;});
}

bool Password::testPassword(const std::string& password) {
  return password.size()>7
    &&   atLeastOneOf(password,"ABCDEFGHIJKLMNOPQRSTUVWXZ")
    &&   atLeastOneOf(password,"0123456789")
    &&   atLeastOneOf(password,"!\"#$%&'()*+'-./;:<>=?");
  
//  return cap && spec && digit && number;
}

void timeOut(){for(;;);}

#include <string>
#include <numeric>

auto digest(const std::string& param) {
  if (param.empty()) return param; // Oh... should check there !!
  return std::accumulate(std::next(param.cbegin()),param.cend(),
                         std::string(1,param[0]), // Char initializer
                         [](auto &s, auto c) {
                           return s+std::string{{' ',c}}; // initializer_list string initializer
                         });
}

#include <string>
#include <array>
#include <stdexcept>

template <typename T>
std::string calculator(int op, T x, T y) {
  try {

    std::array<std::function<T(T, T)>,5> ops{{
      std::plus<>{},
      std::minus<>{},
      std::multiplies<>{},
      [&](T x, T y) {if (y!=0) return x/y; else throw std::range_error{"Illegal divide by 0"};},
      [&](T x, T y) {if (y!=0) return x%y; else throw std::range_error{"Illegal modulus % 0"};},
    }};
  
    return std::to_string(ops.at(op-1)(x,y)); // 'at()' will throw !!
      
  } catch (const std::out_of_range& e) {
    return "Invalid Input!";
  } catch (const std::range_error& e) {
    return "Invalid Input!";
  }
}

#include <functional>
#include <string>
#include <array>
using namespace std;

template <typename T>
string calculator(int op, T x, T y) {
  static array<std::function<T(T, T)>,5> ops{
    plus<>{},minus<>{},multiplies<>{},divides<>{},modulus<>{},
  };
  static array<std::function<std::string()>, 2> func{
    [&]() {return std::to_string(ops[op-1](x, y));},
    [&]() {return "Invalid Input!";},
  };
  
  return func[op < 1 || op > 5 || (!y && (op == 4 || op == 5))]();
}

using System;

public class LeapYears
{
  public static bool IsLeapYear(int year)
  {
    return year % 4 == 0 && !(year%100==0 && year % 400 != 0);
  }
}

#include <algorithm>
struct ParenAccumulator{
  int count{};
  bool operator()(const char c) {
    count+=(c == '('?1:c == ')'?-1:0);
    return count<0; 
  }
  bool isBalanced() const {return count==0;}
};
bool isBalanced(const std::string& s) {
  ParenAccumulator par;
  return std::none_of(s.cbegin(),s.cend(),std::ref(par)) 
      && par.isBalanced(); 
}