mmax sped up

// m = moving (arg1 = window size; arg2 = values)
// r = range (arg1 = max date range; arg2 = dates; arg3 = values)

template<typename LT, bool greater, bool do_index>
K mminmaxtpl(K w0, K left) {
    typedef std::conditional_t<do_index, J, LT> REST;
    typedef std::conditional_t<greater, std::greater<LT>, std::less<LT>> GTLT;
    K rv = ktn(KTY<REST>(), left->n);
    J w = w0->j;
    LT *l = kT<LT>(left);
    REST *dest = kT<REST>(rv);
    int limit = left->n;
    LT lastM = KNULL<LT>();
    GTLT compare;
    J lastMI = -1;
    J mi;
    for(int i=0; i<limit; i++) {
        int s = i-w;
        if (s < 0) {
            s = -1;
        } else {
            if (l[s] == lastM) {
                lastM = KNULL<LT>();
            }
        }
        F m = l[i];
        if (do_index) {
            mi = i;
        }
        if (KISNULL<LT>(lastM)) {
            for(int j=i-1; j>s; j--) {
                F q = l[j];
                if (compare(q,m)) {
                    m = q;
                    if (do_index) mi = j;
                }
            }
            lastM = m;
            if (do_index) lastMI = mi;
        } else if (compare(m, lastM)) {
            lastM = m;
            if (do_index) lastMI = mi;
        }
        if (do_index) {
            *(dest++) = lastMI;
        } else {
            *(dest++) = lastM;
        }
    }
    return rv;
}

template<bool greater, bool do_index>
K mminmaxtpl1(K w0, K left) {
    if (w0->t != -KJ)  return krr("1st arg must be long.");
    switch(left->t) {
        case KF:
            return mminmaxtpl<F, greater, do_index>(w0, left);
        case KI:
            return mminmaxtpl<I, greater, do_index>(w0, left);
        case KJ:
            return mminmaxtpl<J, greater, do_index>(w0, left);
        default:
            return krr("arg2 type");
    }
}

extern "C" K mmax0(K w0, K left) {
    return mminmaxtpl1<true, false>(w0, left);
}
extern "C" K mmin0(K w0, K left) {
    return mminmaxtpl1<false, false>(w0, left);
}
extern "C" K mmaxi(K w0, K left) {
    return mminmaxtpl1<true, true>(w0, left);
}
extern "C" K mmini(K w0, K left) {
    return mminmaxtpl1<false, true>(w0, left);
}