nekko1119

#include <iostream>
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/archive/shared_ptr_helper.hpp>
#include <memory>

struct Integer
{
    int held = 0;

nekko1119

template <typename... Args>
class tuple;

template <int Index, typename Tuple>
struct tuple_element;

template <int N, typename... Args>
typename tuple_element<N, tuple<Args...>>::type& get(tuple<Args...>& t);

template <typename Head, typename... Tails>

nekko1119

<debug>
    <filename>debug.log</filename>
    <modules>
        <module>Finance</module>
        <module>Admin</module>
        <module>HR</module>
    </modules>
    <level>2</level>
</debug>

nekko1119

#include <iostream>

void hello()
{
    std::cout << "Hello ";
}

struct World
{
    void operator()()

nekko1119

#include <algorithm>
#include <iostream>
#include <iterator>
#include <fstream>
#include <regex>
#include <string>
#include <vector>
#include <boost/optional.hpp>
using namespace std;

nekko1119

#include <chrono>
#include <utility>

template <class F, class ...Args>
std::chrono::system_clock::duration take_time(F&& f, Args&&... args) {
    namespace chrono = std::chrono;

    auto const begin = chrono::system_clock::now();
    f(std::forward<Args>(args)...);
    auto const end = chrono::system_clock::now();

nekko1119

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>

void merge_sort(std::vector<int>& arr) {
    if (arr.size() <= 1) return;
    auto left = std::vector<int>(arr.begin(), arr.begin() + arr.size() / 2);
    auto right = std::vector<int>(arr.begin() + arr.size() / 2, arr.end());
    merge_sort(left);

nekko1119

#include <array>
#include <algorithm>
#include <iostream>
#include <tuple>
#include <utility>

template <typename ...Args, std::size_t N = sizeof...(Args)>
std::array<std::common_type_t<Args...>, N> make_array(Args&&... args)
{
    return {{std::forward<Args>(args)...}};

nekko1119

#include <iterator>
#include <type_traits>

template <class Container>
auto to_index(const Container& container, typename Container::const_iterator it)
    -> decltype(std::distance(std::begin(container), it))
{
    static_assert(std::is_same<
        typename std::iterator_traits<
            typename Container::const_iterator

nekko1119

#include <initializer_list>
#include <iostream>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

template <typename F, typename... Args>