#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(); 
}

#include <algorithm>
bool isBalanced(const std::string& s) {
  int count{};
  if (std::any_of(s.cbegin(),s.cend(),[&](auto c){
    count+=(c == '('?1:c == ')'?-1:0);
    return count<0;
  }))
    return false;
  
  return count==0;
}

bool isBalanced(const std::string& s) {
  int count = 0;
  for (const auto c: s) {
    if (count+= c=='(' ? +1: c==')'?-1:0; count <0)
      return false;
  }
  return count == 0;
}

#include <list>

auto merge_list(const std::list<int>& a, const std::list<int>& b) {
  std::list<int> o{a};
  for(auto i : b) o.insert(std::lower_bound(o.begin(), o.end(), i), i);
  return o;
}

#include <algorithm>
#include <list>
#include <execution>
#include <iterator>

auto merge_list(const std::list<int>& a, const std::list<int>& b) {
  std::list<int> o;
  std::merge(
    std::execution::seq,
    a.begin(),
    a.end(),
    b.begin(),
    b.end(),
    std::back_inserter(o) 
    // std::less is default sort
  );
  return o;
}

constexpr int fact(int n) {
    if (n < 2) return 1;
    return n * fact(n-1);
}
const int HOURS_IN_A_DAY      = 24;
const int MINUTES_IN_AN_HOUR  = 60;
const int SECONDS_IN_A_MINUTE = 60;
constexpr int seconds_in_a_day() { return HOURS_IN_A_DAY * MINUTES_IN_AN_HOUR * SECONDS_IN_A_MINUTE; };

auto meaning_of_life_is() {
   return fact(10)/seconds_in_a_day();
}