#pragma once 

#include <cstring>
#define min(A, B) ((A < B) ? (A) : (B))
#define max(A, B) ((A > B) ? (A) : (B))
#define better(GT, A, B) (GT ? max((A), (B)) : min((A), (B)))

template <class T> struct Array {
    T *data;
    int len;

    T &operator[](int i) { return data[i]; }
};


template <class T> Array<T> make_array(int len) {
    return {
	.data=(T*)malloc(sizeof(T)*len),
	.len=len
     };
}
template <class T> T back(Array<T> &a) { return a.data[a.len-1]; }
template <class T> T front(Array<T> &a) { return a.data[0]; }

template <class T> struct DynArray {
    T* _data;
    int end;
    int cap;

    T &operator[](int i) { return _data[i]; }
};

template <class T> DynArray<T> make_dynarray(int cap) {
    return {
	._data=(T*)malloc(sizeof(T)*cap),
	.end=0,
	.cap=cap
    };
}

template <class T> void resize(DynArray<T> &a, int new_cap) {
    T* old = a._data;
    a._data = (T*)malloc(sizeof(T)*new_cap);
    memcpy(a._data, old, min(sizeof(T)*a.end, sizeof(T)*new_cap));
    a.cap = new_cap;
    free(old);
}

template <class T> void append(DynArray<T> &a, T el) {
    if (a.end == a.cap) resize(a, min(1, a.cap*2));
    a[a.end++] = el;
}

template <class T> T back(DynArray<T> &a) { return a._data[a.end-1]; }
template <class T> T front(DynArray<T> &a) { return a._data[0]; }