// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Author: Abby Cin
 * Mail: abbytsing@gmail.com
 * Create Time: 2020-10-04 10:11:14
 */

using size_t = unsigned long;
struct cout {
    static int itoa(char buf[], int val) {
        static const char* const digits = "9876543210123456789";
        static const char* zero = digits + 9;
        int i = val;
        char *p = buf;
        char *b = buf;
        char c;
        int r = 0;
        int lsd;
        do  {
            lsd = i % 10;
            i /= 10;
            *p++ = zero[lsd];
        } while (i != 0);
        if (val < 0)
            *p++ = '-';
        *p = '\0';
        r = p - buf;
        while (b < p) {
            --p;
            c = *b;
            *b = *p;
            *p = c;
            b++;
        }
        return r;
    }
    static void write(const char *a, size_t n) {
       asm volatile(
               "movq $1, %%rax;"
               "movq $1, %%rdi;"
               "movq %[a], %%rsi;"
               "movq %[n], %%rdx;"
               "syscall;"
               :
               : [a] "m" (a), [n] "m" (n)
               :
               );
    }

    template<size_t N>
    cout &operator<< (const char (&a)[N]) {
        write(a, N);
        return *this;
    }
    cout &operator<< (const char *a) {
        int n = 0;
        const char *p = a;
        while (*p)
            p++;
        n = p - a;
        write(a, n);
        return *this;
    }
    cout &operator<< (const char a) {
        write(&a, 1);
        return *this;
    }
    cout &operator<< (int x) {
        static char buf[32];
        int n = itoa(buf, x);
        write(buf, n);
        return *this;
    }
};

struct cout out;

template<typename T> struct remove_ref { using type = T; };
template<typename T> struct remove_ref<T&> { using type = T; };
template<typename T> struct remove_ref<T&&> { using type = T; };
template<typename T> using remove_ref_t = typename remove_ref<T>::type;

template<typename T> constexpr T&& forward(remove_ref_t<T>& x) { return static_cast<T&&>(x); }
template<typename T> constexpr T&& forward(remove_ref_t<T>&& x) { return static_cast<T&&>(x); }

template<size_t... Is> struct sequence{};
template<typename, typename> struct concat;
template<size_t... I1, size_t... I2> struct concat<sequence<I1...>, sequence<I2...>> { using type = sequence<I1..., (sizeof...(I1) + I2)...>; };
template<size_t> struct gen_seq;
template<> struct gen_seq<1> { using type = sequence<0>; }; // zero based index
template<size_t N> struct gen_seq { using type = typename concat<typename gen_seq<N/2>::type, typename gen_seq<N-N/2>::type>::type; };
template<size_t N> using make_sequence = typename gen_seq<N>::type;

template<typename T> struct tuple_val { T value; };
template<typename...> struct tuple;
template<> struct tuple<> {};
template<size_t> constexpr bool false_t = false;
template<typename T, typename... Ts> struct tuple<T, Ts...> : tuple<Ts...> {
  using base = tuple<Ts...>;
  tuple(T&& t, Ts&&... ts) : base{::forward<Ts>(ts)...}, value{::forward<T>(t)} {} // adl is evil
  tuple_val<T> value;
  constexpr static size_t size = sizeof...(Ts) + 1;
};
template<typename T, typename... Ts> tuple(T&&, Ts&&...) -> tuple<T, Ts...>;

template<size_t Idx, typename T> struct element;
template<size_t Idx> struct element<Idx, tuple<>> { static_assert(false_t<Idx>, "out of range"); };
template<typename T, typename... Ts> struct element<0, tuple<T, Ts...>> {
  using type = T;
  using base = tuple<T, Ts...>;
};
template<size_t Idx, typename T, typename... Ts> struct element<Idx, tuple<T, Ts...>> : element<Idx-1, tuple<Ts...>> {};
template<size_t Idx, typename... Ts> using element_t = typename element<Idx, Ts...>::type;

template<size_t Idx, typename... Ts> constexpr element_t<Idx, tuple<Ts...>>& get(tuple<Ts...>& x) {
  using base = typename element<Idx, tuple<Ts...>>::base;
  return static_cast<base&>(x).value.value;
}
template<typename... Ts> cout& operator<< (cout& os, tuple<Ts...>& x) {
  return [&os, &x]<size_t...Is>(sequence<Is...>) -> cout& {
    ((os << get<Is>(x) << ' '), ...);
    return os << '\n';
  }(make_sequence<sizeof...(Ts)>{});
}
template<typename R, typename F, typename Tuple> R apply(F&& f, Tuple&& args) {
  return [f = ::forward<F>(f), &args]<size_t... Is>(sequence<Is...>) {
    return f(::forward<element_t<Is, remove_ref_t<Tuple>>>(get<Is>(args))...);
  }(make_sequence<remove_ref_t<Tuple>::size>{});
}

void foo(const char *a, int b, const char *c) {
  out << a << ' ' << b << ' ' << c << '\n';
}

int main() {
  tuple t{"elder", 1925, "+1s"}; get<1>(t) += 1; out << t;
  apply<void>(foo, t);
}

asm (
        ".globl _start;"
        "_start:"
        "call main;"
        "movq $60, %rax;"
        "movq $0, %rdi;"
        "syscall"
    );