/*
 * This file was generated automatically by ExtUtils::ParseXS version 3.44 from the
 * contents of XS.xs. Do not edit this file, edit XS.xs instead.
 *
 *    ANY CHANGES MADE HERE WILL BE LOST!
 *
 */

#line 1 "XS.xs"
#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "multicall.h"
#define NEED_croak_xs_usage
#include "ppport.h"

#ifndef aTHX
#  define aTHX
#  define pTHX
#endif

#ifdef SVf_IVisUV
#  define slu_sv_value(sv) (SvIOK(sv)) ? (SvIOK_UV(sv)) ? (NV)(SvUVX(sv)) : (NV)(SvIVX(sv)) : (SvNV(sv))
#else
#  define slu_sv_value(sv) (SvIOK(sv)) ? (NV)(SvIVX(sv)) : (SvNV(sv))
#endif

/*
 * Perl < 5.18 had some kind of different SvIV_please_nomg
 */
#if PERL_VERSION < 18
#undef SvIV_please_nomg
#  define SvIV_please_nomg(sv) \
    (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv)) \
        ? (SvIV_nomg(sv), SvIOK(sv))      \
        : SvIOK(sv))
#endif

/* compare left and right SVs. Returns:
 * -1: <
 *  0: ==
 *  1: >
 *  2: left or right was a NaN
 */
static I32
LSUXSncmp(pTHX_ SV* left, SV * right)
{
    /* Fortunately it seems NaN isn't IOK */
    if (SvAMAGIC(left) || SvAMAGIC(right))
        return SvIVX(amagic_call(left, right, ncmp_amg, 0));

    if (SvIV_please_nomg(right) && SvIV_please_nomg(left)) {
        if (!SvUOK(left)) {
            const IV leftiv = SvIVX(left);
            if (!SvUOK(right)) {
                /* ## IV <=> IV ## */
                const IV rightiv = SvIVX(right);
                return (leftiv > rightiv) - (leftiv < rightiv);
            }
            /* ## IV <=> UV ## */
            if (leftiv < 0)
                /* As (b) is a UV, it's >=0, so it must be < */
                return -1;
            {
                const UV rightuv = SvUVX(right);
                return ((UV)leftiv > rightuv) - ((UV)leftiv < rightuv);
            }
        }

        if (SvUOK(right)) {
            /* ## UV <=> UV ## */
            const UV leftuv = SvUVX(left);
            const UV rightuv = SvUVX(right);
            return (leftuv > rightuv) - (leftuv < rightuv);
        }
        /* ## UV <=> IV ## */
        {
            const IV rightiv = SvIVX(right);
            if (rightiv < 0)
                /* As (a) is a UV, it's >=0, so it cannot be < */
                return 1;
            {
                const UV leftuv = SvUVX(left);
                return (leftuv > (UV)rightiv) - (leftuv < (UV)rightiv);
            }
        }
        assert(0); /* NOTREACHED */
    } else {
#ifdef SvNV_nomg
        NV const rnv = SvNV_nomg(right);
        NV const lnv = SvNV_nomg(left);
#else
        NV const rnv = slu_sv_value(right);
        NV const lnv = slu_sv_value(left);
#endif

#if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
        if (Perl_isnan(lnv) || Perl_isnan(rnv)) {
            return 2;
        }
        return (lnv > rnv) - (lnv < rnv);
#else
        if (lnv < rnv)
            return -1;
        if (lnv > rnv)
            return 1;
        if (lnv == rnv)
            return 0;
        return 2;
#endif
    }
}

#define ncmp(left,right) LSUXSncmp(aTHX_ left,right)

#define FUNC_NAME GvNAME(GvEGV(ST(items)))

/* shameless stolen from PadWalker */
#ifndef PadARRAY
typedef AV PADNAMELIST;
typedef SV PADNAME;
# if PERL_VERSION < 8 || (PERL_VERSION == 8 && !PERL_SUBVERSION)
typedef AV PADLIST;
typedef AV PAD;
# endif
# define PadlistARRAY(pl)       ((PAD **)AvARRAY(pl))
# define PadlistMAX(pl)         AvFILLp(pl)
# define PadlistNAMES(pl)       (*PadlistARRAY(pl))
# define PadnamelistARRAY(pnl)  ((PADNAME **)AvARRAY(pnl))
# define PadnamelistMAX(pnl)    AvFILLp(pnl)
# define PadARRAY               AvARRAY
# define PadnameIsOUR(pn)       !!(SvFLAGS(pn) & SVpad_OUR)
# define PadnameOURSTASH(pn)    SvOURSTASH(pn)
# define PadnameOUTER(pn)       !!SvFAKE(pn)
# define PadnamePV(pn)          (SvPOKp(pn) ? SvPVX(pn) : NULL)
#endif
#ifndef PadnameSV
# define PadnameSV(pn)          pn
#endif
#ifndef PadnameFLAGS
# define PadnameFLAGS(pn)       (SvFLAGS(PadnameSV(pn)))
#endif

static int
in_pad (pTHX_ SV *code)
{
    GV *gv;
    HV *stash;
    CV *cv = sv_2cv(code, &stash, &gv, 0);
    PADLIST *pad_list = (CvPADLIST(cv));
    PADNAMELIST *pad_namelist = PadlistNAMES(pad_list);
    int i;

    for (i=PadnamelistMAX(pad_namelist); i>=0; --i) {
        PADNAME* name_pn = PadnamelistARRAY(pad_namelist)[i];
        if (name_pn) {
            char *name_str = PadnamePV(name_pn);
            if (name_str) {

                if (PadnameIsOUR(name_pn))
                    continue;

                if (strEQ(name_str, "$a") || strEQ(name_str, "$b"))
                    return 1;

                if (!((PadnameFLAGS(name_pn)) & SVf_OK))
                    continue;
            }
        }
    }
    return 0;
}

#define WARN_OFF \
    SV *oldwarn = PL_curcop->cop_warnings; \
    PL_curcop->cop_warnings = pWARN_NONE;

#define WARN_ON \
    PL_curcop->cop_warnings = oldwarn;

#define EACH_ARRAY_BODY \
    int i;                                                          \
    arrayeach_args * args;                                          \
    HV *stash = gv_stashpv("List::SomeUtils_ea", TRUE);                 \
    CV *closure = newXS(NULL, XS_List__SomeUtils__XS__array_iterator, __FILE__); \
                                                                        \
    /* prototype */                                         \
    sv_setpv((SV*)closure, ";$");                           \
                                                            \
    New(0, args, 1, arrayeach_args);                        \
    New(0, args->avs, items, AV*);                          \
    args->navs = items;                                     \
    args->curidx = 0;                                       \
                                                            \
    for (i = 0; i < items; i++) {                           \
        if (!arraylike(ST(i)))                                      \
            croak_xs_usage(cv,  "\\@;\\@\\@...");                   \
        args->avs[i] = (AV*)SvRV(ST(i));                            \
        SvREFCNT_inc(args->avs[i]);                                 \
    }                                                               \
                                                                    \
    CvXSUBANY(closure).any_ptr = args;                              \
    RETVAL = newRV_noinc((SV*)closure);                             \
                                                                    \
    /* in order to allow proper cleanup in DESTROY-handler */       \
    sv_bless(RETVAL, stash)

#define FOR_EACH(on_item)           \
    if (!codelike(code))                     \
        croak_xs_usage(cv,  "code, ...");   \
                                            \
    if (items > 1) {                        \
        dMULTICALL;                         \
        int i;                              \
        HV *stash;                          \
        GV *gv;                             \
        CV *_cv;                            \
        SV **args = &PL_stack_base[ax];     \
        I32 gimme = G_SCALAR;               \
        _cv = sv_2cv(code, &stash, &gv, 0); \
        PUSH_MULTICALL(_cv);                \
        SAVESPTR(GvSV(PL_defgv));           \
                                            \
        for (i = 1 ; i < items ; ++i) {     \
            GvSV(PL_defgv) = args[i];       \
            MULTICALL;                      \
            on_item;                        \
        }                                   \
        POP_MULTICALL;                      \
    }

#define TRUE_JUNCTION   \
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) ON_TRUE) \
    else ON_EMPTY;

#define FALSE_JUNCTION  \
    FOR_EACH(if (!SvTRUE(*PL_stack_sp)) ON_FALSE)   \
    else ON_EMPTY;

/* need this one for array_each() */
typedef struct {
    AV **avs;       /* arrays over which to iterate in parallel */
    int navs;       /* number of arrays */
    int curidx;     /* the current index of the iterator */
} arrayeach_args;

/* used for natatime */
typedef struct {
    SV **svs;
    int nsvs;
    int curidx;
    int natatime;
} natatime_args;

static void
insert_after (pTHX_ int idx, SV *what, AV *av) {
    int i, len;
    av_extend(av, (len = av_len(av) + 1));

    for (i = len; i > idx+1; i--) {
        SV **sv = av_fetch(av, i-1, FALSE);
        SvREFCNT_inc(*sv);
        av_store(av, i, *sv);
    }
    if (!av_store(av, idx+1, what))
        SvREFCNT_dec(what);
}

static int
is_like(pTHX_ SV *sv, const char *like)
{
    int likely = 0;
    if ( sv_isobject( sv ) )
        {
            dSP;
        int count;

        ENTER;
        SAVETMPS;
        PUSHMARK(SP);
        XPUSHs( sv_2mortal( newSVsv( sv ) ) );
        XPUSHs( sv_2mortal( newSVpv( like, strlen(like) ) ) );
        PUTBACK;

        if ( ( count = call_pv("overload::Method", G_SCALAR) ) ) {
            I32 ax;
            SPAGAIN;

            SP -= count;
            ax = (SP - PL_stack_base) + 1;
            if ( SvTRUE(ST(0)) )
                ++likely;
        }

        PUTBACK;
        FREETMPS;
        LEAVE;
    }

    return likely;
}

static int
is_array(SV *sv)
{
    return SvROK(sv) && ( SVt_PVAV == SvTYPE(SvRV(sv) ) );
}

static int
LSUXScodelike(pTHX_ SV *code)
{
    SvGETMAGIC(code);
    return SvROK(code) && ( ( SVt_PVCV == SvTYPE(SvRV(code)) ) || ( is_like(aTHX_ code, "&{}" ) ) );
}

#define codelike(code) LSUXScodelike(aTHX_ code)

static int
LSUXSarraylike(pTHX_ SV *array)
{
    SvGETMAGIC(array);
    return is_array(array) || is_like(aTHX_ array, "@{}" );
}

#define arraylike(array) LSUXSarraylike(aTHX_ array)

#line 329 "XS.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


/* This stuff is not part of the API! You have been warned. */
#ifndef PERL_VERSION_DECIMAL
#  define PERL_VERSION_DECIMAL(r,v,s) (r*1000000 + v*1000 + s)
#endif
#ifndef PERL_DECIMAL_VERSION
#  define PERL_DECIMAL_VERSION \
	  PERL_VERSION_DECIMAL(PERL_REVISION,PERL_VERSION,PERL_SUBVERSION)
#endif
#ifndef PERL_VERSION_GE
#  define PERL_VERSION_GE(r,v,s) \
	  (PERL_DECIMAL_VERSION >= PERL_VERSION_DECIMAL(r,v,s))
#endif
#ifndef PERL_VERSION_LE
#  define PERL_VERSION_LE(r,v,s) \
	  (PERL_DECIMAL_VERSION <= PERL_VERSION_DECIMAL(r,v,s))
#endif

/* XS_INTERNAL is the explicit static-linkage variant of the default
 * XS macro.
 *
 * XS_EXTERNAL is the same as XS_INTERNAL except it does not include
 * "STATIC", ie. it exports XSUB symbols. You probably don't want that
 * for anything but the BOOT XSUB.
 *
 * See XSUB.h in core!
 */


/* TODO: This might be compatible further back than 5.10.0. */
#if PERL_VERSION_GE(5, 10, 0) && PERL_VERSION_LE(5, 15, 1)
#  undef XS_EXTERNAL
#  undef XS_INTERNAL
#  if defined(__CYGWIN__) && defined(USE_DYNAMIC_LOADING)
#    define XS_EXTERNAL(name) __declspec(dllexport) XSPROTO(name)
#    define XS_INTERNAL(name) STATIC XSPROTO(name)
#  endif
#  if defined(__SYMBIAN32__)
#    define XS_EXTERNAL(name) EXPORT_C XSPROTO(name)
#    define XS_INTERNAL(name) EXPORT_C STATIC XSPROTO(name)
#  endif
#  ifndef XS_EXTERNAL
#    if defined(HASATTRIBUTE_UNUSED) && !defined(__cplusplus)
#      define XS_EXTERNAL(name) void name(pTHX_ CV* cv __attribute__unused__)
#      define XS_INTERNAL(name) STATIC void name(pTHX_ CV* cv __attribute__unused__)
#    else
#      ifdef __cplusplus
#        define XS_EXTERNAL(name) extern "C" XSPROTO(name)
#        define XS_INTERNAL(name) static XSPROTO(name)
#      else
#        define XS_EXTERNAL(name) XSPROTO(name)
#        define XS_INTERNAL(name) STATIC XSPROTO(name)
#      endif
#    endif
#  endif
#endif

/* perl >= 5.10.0 && perl <= 5.15.1 */


/* The XS_EXTERNAL macro is used for functions that must not be static
 * like the boot XSUB of a module. If perl didn't have an XS_EXTERNAL
 * macro defined, the best we can do is assume XS is the same.
 * Dito for XS_INTERNAL.
 */
#ifndef XS_EXTERNAL
#  define XS_EXTERNAL(name) XS(name)
#endif
#ifndef XS_INTERNAL
#  define XS_INTERNAL(name) XS(name)
#endif

/* Now, finally, after all this mess, we want an ExtUtils::ParseXS
 * internal macro that we're free to redefine for varying linkage due
 * to the EXPORT_XSUB_SYMBOLS XS keyword. This is internal, use
 * XS_EXTERNAL(name) or XS_INTERNAL(name) in your code if you need to!
 */

#undef XS_EUPXS
#if defined(PERL_EUPXS_ALWAYS_EXPORT)
#  define XS_EUPXS(name) XS_EXTERNAL(name)
#else
   /* default to internal */
#  define XS_EUPXS(name) XS_INTERNAL(name)
#endif

#ifndef PERL_ARGS_ASSERT_CROAK_XS_USAGE
#define PERL_ARGS_ASSERT_CROAK_XS_USAGE assert(cv); assert(params)

/* prototype to pass -Wmissing-prototypes */
STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params);

STATIC void
S_croak_xs_usage(const CV *const cv, const char *const params)
{
    const GV *const gv = CvGV(cv);

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

    if (gv) {
        const char *const gvname = GvNAME(gv);
        const HV *const stash = GvSTASH(gv);
        const char *const hvname = stash ? HvNAME(stash) : NULL;

        if (hvname)
	    Perl_croak_nocontext("Usage: %s::%s(%s)", hvname, gvname, params);
        else
	    Perl_croak_nocontext("Usage: %s(%s)", gvname, params);
    } else {
        /* Pants. I don't think that it should be possible to get here. */
	Perl_croak_nocontext("Usage: CODE(0x%" UVxf ")(%s)", PTR2UV(cv), params);
    }
}
#undef  PERL_ARGS_ASSERT_CROAK_XS_USAGE

#define croak_xs_usage        S_croak_xs_usage

#endif

/* NOTE: the prototype of newXSproto() is different in versions of perls,
 * so we define a portable version of newXSproto()
 */
#ifdef newXS_flags
#define newXSproto_portable(name, c_impl, file, proto) newXS_flags(name, c_impl, file, proto, 0)
#else
#define newXSproto_portable(name, c_impl, file, proto) (PL_Sv=(SV*)newXS(name, c_impl, file), sv_setpv(PL_Sv, proto), (CV*)PL_Sv)
#endif /* !defined(newXS_flags) */

#if PERL_VERSION_LE(5, 21, 5)
#  define newXS_deffile(a,b) Perl_newXS(aTHX_ a,b,file)
#else
#  define newXS_deffile(a,b) Perl_newXS_deffile(aTHX_ a,b)
#endif

#line 473 "XS.c"

XS_EUPXS(XS_List__SomeUtils_ea_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils_ea_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 325 "XS.xs"
{
    int i;
    CV *code = (CV*)SvRV(sv);
    arrayeach_args *args = (arrayeach_args *)(CvXSUBANY(code).any_ptr);
    if (args) {
        for (i = 0; i < args->navs; ++i)
            SvREFCNT_dec(args->avs[i]);
        Safefree(args->avs);
        Safefree(args);
        CvXSUBANY(code).any_ptr = NULL;
    }
}
#line 497 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils_na_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils_na_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 345 "XS.xs"
{
    int i;
    CV *code = (CV*)SvRV(sv);
    natatime_args *args = (natatime_args *)(CvXSUBANY(code).any_ptr);
    if (args) {
        for (i = 0; i < args->nsvs; ++i)
            SvREFCNT_dec(args->svs[i]);
        Safefree(args->svs);
        Safefree(args);
        CvXSUBANY(code).any_ptr = NULL;
    }
}
#line 525 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_any); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_any)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 365 "XS.xs"
{
#define ON_TRUE { POP_MULTICALL; XSRETURN_YES; }
#define ON_EMPTY XSRETURN_NO
    TRUE_JUNCTION;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 549 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_all); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_all)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 379 "XS.xs"
{
#define ON_FALSE { POP_MULTICALL; XSRETURN_NO; }
#define ON_EMPTY XSRETURN_YES
    FALSE_JUNCTION;
    XSRETURN_YES;
#undef ON_EMPTY
#undef ON_FALSE
}
#line 573 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_none); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_none)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 394 "XS.xs"
{
#define ON_TRUE { POP_MULTICALL; XSRETURN_NO; }
#define ON_EMPTY XSRETURN_YES
    TRUE_JUNCTION;
    XSRETURN_YES;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 597 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_notall); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_notall)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 408 "XS.xs"
{
#define ON_FALSE { POP_MULTICALL; XSRETURN_YES; }
#define ON_EMPTY XSRETURN_NO
    FALSE_JUNCTION;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_FALSE
}
#line 621 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_one); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_one)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 422 "XS.xs"
{
    int found = 0;
#define ON_TRUE { if (found++) { POP_MULTICALL; XSRETURN_NO; }; }
#define ON_EMPTY XSRETURN_NO
    TRUE_JUNCTION;
    if (found)
        XSRETURN_YES;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 648 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_any_u); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_any_u)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 439 "XS.xs"
{
#define ON_TRUE { POP_MULTICALL; XSRETURN_YES; }
#define ON_EMPTY XSRETURN_UNDEF
    TRUE_JUNCTION;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 672 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_all_u); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_all_u)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 453 "XS.xs"
{
#define ON_FALSE { POP_MULTICALL; XSRETURN_NO; }
#define ON_EMPTY XSRETURN_UNDEF
    FALSE_JUNCTION;
    XSRETURN_YES;
#undef ON_EMPTY
#undef ON_FALSE
}
#line 696 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_none_u); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_none_u)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 468 "XS.xs"
{
#define ON_TRUE { POP_MULTICALL; XSRETURN_NO; }
#define ON_EMPTY XSRETURN_UNDEF
    TRUE_JUNCTION;
    XSRETURN_YES;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 720 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_notall_u); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_notall_u)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 482 "XS.xs"
{
#define ON_FALSE { POP_MULTICALL; XSRETURN_YES; }
#define ON_EMPTY XSRETURN_UNDEF
    FALSE_JUNCTION;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_FALSE
}
#line 744 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_one_u); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_one_u)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 496 "XS.xs"
{
    int found = 0;
#define ON_TRUE { if (found++) { POP_MULTICALL; XSRETURN_NO; }; }
#define ON_EMPTY XSRETURN_UNDEF
    TRUE_JUNCTION;
    if (found)
        XSRETURN_YES;
    XSRETURN_NO;
#undef ON_EMPTY
#undef ON_TRUE
}
#line 771 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_true); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_true)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 513 "XS.xs"
{
    I32 count = 0;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) count++);
    RETVAL = count;
}
#line 794 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_false); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_false)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 526 "XS.xs"
{
    I32 count = 0;
    FOR_EACH(if (!SvTRUE(*PL_stack_sp)) count++);
    RETVAL = count;
}
#line 819 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_firstidx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_firstidx)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 539 "XS.xs"
{
    RETVAL = -1;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { RETVAL = i-1; break; });
}
#line 843 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_firstval); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_firstval)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 551 "XS.xs"
{
    RETVAL = &PL_sv_undef;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { SvREFCNT_inc(RETVAL = args[i]); break; });
}
#line 866 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_firstres); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_firstres)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 563 "XS.xs"
{
    RETVAL = &PL_sv_undef;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { SvREFCNT_inc(RETVAL = *PL_stack_sp); break; });
}
#line 889 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_onlyidx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_onlyidx)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 575 "XS.xs"
{
    int found = 0;
    RETVAL = -1;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { if (found++) {RETVAL = -1; break;} RETVAL = i-1; });
}
#line 914 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_onlyval); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_onlyval)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 588 "XS.xs"
{
    int found = 0;
    RETVAL = &PL_sv_undef;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { if (found++) {SvREFCNT_dec(RETVAL); RETVAL = &PL_sv_undef; break;} SvREFCNT_inc(RETVAL = args[i]); });
}
#line 938 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_onlyres); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_onlyres)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 601 "XS.xs"
{
    int found = 0;
    RETVAL = &PL_sv_undef;
    FOR_EACH(if (SvTRUE(*PL_stack_sp)) { if (found++) {SvREFCNT_dec(RETVAL); RETVAL = &PL_sv_undef; break;}SvREFCNT_inc(RETVAL = *PL_stack_sp); });
}
#line 962 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_lastidx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_lastidx)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 614 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    RETVAL = -1;

    if (items > 1) {
        _cv = sv_2cv(code, &stash, &gv, 0);
        PUSH_MULTICALL(_cv);
        SAVESPTR(GvSV(PL_defgv));

        for (i = items-1 ; i > 0 ; --i) {
            GvSV(PL_defgv) = args[i];
            MULTICALL;
            if (SvTRUE(*PL_stack_sp)) {
                RETVAL = i-1;
                break;
            }
        }
        POP_MULTICALL;
    }
}
#line 1012 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_lastval); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_lastval)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 652 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    RETVAL = &PL_sv_undef;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items > 1) {
        _cv = sv_2cv(code, &stash, &gv, 0);
        PUSH_MULTICALL(_cv);
        SAVESPTR(GvSV(PL_defgv));

        for (i = items-1 ; i > 0 ; --i) {
            GvSV(PL_defgv) = args[i];
            MULTICALL;
            if (SvTRUE(*PL_stack_sp)) {
                /* see comment in indexes() */
                SvREFCNT_inc(RETVAL = args[i]);
                break;
            }
        }
        POP_MULTICALL;
    }
}
#line 1062 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_lastres); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_lastres)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 691 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    RETVAL = &PL_sv_undef;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items > 1) {
        _cv = sv_2cv(code, &stash, &gv, 0);
        PUSH_MULTICALL(_cv);
        SAVESPTR(GvSV(PL_defgv));

        for (i = items-1 ; i > 0 ; --i) {
            GvSV(PL_defgv) = args[i];
            MULTICALL;
            if (SvTRUE(*PL_stack_sp)) {
                /* see comment in indexes() */
                SvREFCNT_inc(RETVAL = *PL_stack_sp);
                break;
            }
        }
        POP_MULTICALL;
    }
}
#line 1112 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_insert_after); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_insert_after)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "code, val, avref");
    {
	SV *	code = ST(0)
;
	SV *	val = ST(1)
;
	SV *	avref = ST(2)
;
	int	RETVAL;
	dXSTARG;
#line 732 "XS.xs"
{
    dMULTICALL;
    int i;
    int len;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    CV *_cv;
    AV *av;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, val, \\@area_of_operation");
    if (!arraylike(avref))
        croak_xs_usage(cv,  "code, val, \\@area_of_operation");

    av = (AV*)SvRV(avref);
    len = av_len(av);
    RETVAL = 0;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 0; i <= len ; ++i) {
        GvSV(PL_defgv) = *av_fetch(av, i, FALSE);
        MULTICALL;
        if (SvTRUE(*PL_stack_sp)) {
            RETVAL = 1;
            break;
        }
    }

    POP_MULTICALL;

    if (RETVAL) {
        SvREFCNT_inc(val);
        insert_after(aTHX_ i, val, av);
    }
}
#line 1175 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_insert_after_string); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_insert_after_string)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "string, val, avref");
    {
	SV *	string = ST(0)
;
	SV *	val = ST(1)
;
	SV *	avref = ST(2)
;
	int	RETVAL;
	dXSTARG;
#line 781 "XS.xs"
{
    int i;
    AV *av;
    int len;
    SV **sv;
    STRLEN slen = 0, alen;
    char *str;
    char *astr;
    RETVAL = 0;

    if (!arraylike(avref))
        croak_xs_usage(cv,  "string, val, \\@area_of_operation");

    av = (AV*)SvRV(avref);
    len = av_len(av);

    if (SvTRUE(string))
        str = SvPV(string, slen);
    else
        str = NULL;

    for (i = 0; i <= len ; i++) {
        sv = av_fetch(av, i, FALSE);
        if (SvTRUE(*sv))
            astr = SvPV(*sv, alen);
        else {
            astr = NULL;
            alen = 0;
        }
        if (slen == alen && memcmp(astr, str, slen) == 0) {
            RETVAL = 1;
            break;
        }
    }
    if (RETVAL) {
        SvREFCNT_inc(val);
        insert_after(aTHX_ i, val, av);
    }
}
#line 1238 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_apply); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_apply)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 828 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    CV *_cv;
    SV **args = &PL_stack_base[ax];

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1 ; i < items ; ++i) {
        GvSV(PL_defgv) = newSVsv(args[i]);
        MULTICALL;
        args[i-1] = GvSV(PL_defgv);
    }
    POP_MULTICALL;

    for (i = 1 ; i < items ; ++i)
        sv_2mortal(args[i-1]);

    XSRETURN(items-1);
}
#line 1287 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_after); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_after)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 865 "XS.xs"
{
    dMULTICALL;
    int i, j;
    HV *stash;
    CV *_cv;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1; i < items; i++) {
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        if (SvTRUE(*PL_stack_sp)) {
            break;
        }
    }

    POP_MULTICALL;

    for (j = i + 1; j < items; ++j)
        args[j-i-1] = args[j];

    j = items-i-1;
    XSRETURN(j > 0 ? j : 0);
}
#line 1338 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_after_incl); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_after_incl)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 906 "XS.xs"
{
    dMULTICALL;
    int i, j;
    HV *stash;
    CV *_cv;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1; i < items; i++) {
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        if (SvTRUE(*PL_stack_sp)) {
            break;
        }
    }

    POP_MULTICALL;

    for (j = i; j < items; j++)
        args[j-i] = args[j];

    XSRETURN(items-i);
}
#line 1388 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_before); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_before)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 946 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1; i < items; i++) {
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        if (SvTRUE(*PL_stack_sp)) {
            break;
        }
        args[i-1] = args[i];
    }

    POP_MULTICALL;

    XSRETURN(i-1);
}
#line 1436 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_before_incl); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_before_incl)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 984 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1; i < items; ++i) {
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        args[i-1] = args[i];
        if (SvTRUE(*PL_stack_sp)) {
            ++i;
            break;
        }
    }

    POP_MULTICALL;

    XSRETURN(i-1);
}
#line 1485 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS_indexes); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_indexes)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 1023 "XS.xs"
{
    dMULTICALL;
    int i, j;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items <= 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1, j = 0; i < items; i++) {
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        if (SvTRUE(*PL_stack_sp))
            /* POP_MULTICALL can free mortal temporaries, so we defer
             * mortalising the returned values till after that's been done */
            args[j++] = newSViv(i-1);
    }

    POP_MULTICALL;

    for (i = 0; i < j; i++)
        sv_2mortal(args[i]);

    XSRETURN(j);
}
#line 1536 "XS.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_List__SomeUtils__XS__array_iterator); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS__array_iterator)
{
    dVAR; dXSARGS;
    if (items < 0 || items > 1)
       croak_xs_usage(cv,  "method = \"\"");
    {
	const char *	method;

	if (items < 1)
	    method = "";
	else {
	    method = (const char *)SvPV_nolen(ST(0))
;
	}
#line 1064 "XS.xs"
{
    int i;
    int exhausted = 1;

    /* 'cv' is the hidden argument with which
     * XS_List__SomeUtils__XS__array_iterator (this XSUB) is called. The
     * closure_arg struct is stored in this CV. */

    arrayeach_args *args = (arrayeach_args *)(CvXSUBANY(cv).any_ptr);

    if (strEQ(method, "index")) {
        EXTEND(SP, 1);
        ST(0) = args->curidx > 0 ? sv_2mortal(newSViv(args->curidx-1)) : &PL_sv_undef;
        XSRETURN(1);
    }

    EXTEND(SP, args->navs);

    for (i = 0; i < args->navs; i++) {
        AV *av = args->avs[i];
        if (args->curidx <= av_len(av)) {
            ST(i) = sv_2mortal(newSVsv(*av_fetch(av, args->curidx, FALSE)));
            exhausted = 0;
            continue;
        }
        ST(i) = &PL_sv_undef;
    }

    if (exhausted)
        XSRETURN_EMPTY;

    args->curidx++;
    XSRETURN(args->navs);
}
#line 1592 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_each_array); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_each_array)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	SV *	RETVAL;
#line 1103 "XS.xs"
{
    EACH_ARRAY_BODY;
}
#line 1610 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_each_arrayref); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_each_arrayref)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
	SV *	RETVAL;
#line 1112 "XS.xs"
{
    EACH_ARRAY_BODY;
}
#line 1630 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_pairwise); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_pairwise)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	code = ST(0)
;
#line 1123 "XS.xs"
{
#define av_items(a) (av_len(a)+1)

    /* This function is not quite as efficient as it ought to be: We call
     * 'code' multiple times and want to gather its return values all in one
     * list. However, each call resets the stack pointer so there is no
     * obvious way to get the return values onto the stack without making
     * intermediate copies of the pointers.  The above disabled solution would
     * be more efficient. Unfortunately it doesn't work (and, as of now,
     * wouldn't deal with 'code' returning more than one value).
     *
     * The current solution is a fair trade-off. It only allocates memory for
     * a list of SV-pointers, as many as there are return values. It
     * temporarily stores 'code's return values in this list and, when done,
     * copies them down to SP. */

    int i, j;
    AV *avs[2];
    SV **buf, **p;  /* gather return values here and later copy down to SP */
    int alloc;

    int nitems = 0, maxitems = 0;
    int d;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, list, list");
    if (!arraylike(ST(1)))
        croak_xs_usage(cv,  "code, list, list");
    if (!arraylike(ST(2)))
        croak_xs_usage(cv,  "code, list, list");

    if (in_pad(aTHX_ code)) {
        croak("Can't use lexical $a or $b in pairwise code block");
    }

    /* deref AV's for convenience and
     * get maximum items */
    avs[0] = (AV*)SvRV(ST(1));
    avs[1] = (AV*)SvRV(ST(2));
    maxitems = av_items(avs[0]);
    if (av_items(avs[1]) > maxitems)
        maxitems = av_items(avs[1]);

    if (!PL_firstgv || !PL_secondgv) {
        SAVESPTR(PL_firstgv);
        SAVESPTR(PL_secondgv);
        PL_firstgv = gv_fetchpv("a", TRUE, SVt_PV);
        PL_secondgv = gv_fetchpv("b", TRUE, SVt_PV);
    }

    New(0, buf, alloc = maxitems, SV*);

    ENTER;
    for (d = 0, i = 0; i < maxitems; i++) {
        int nret;
        SV **svp = av_fetch(avs[0], i, FALSE);
        GvSV(PL_firstgv) = svp ? *svp : &PL_sv_undef;
        svp = av_fetch(avs[1], i, FALSE);
        GvSV(PL_secondgv) = svp ? *svp : &PL_sv_undef;
        PUSHMARK(SP);
        PUTBACK;
        nret = call_sv(code, G_EVAL|G_ARRAY);
        if (SvTRUE(ERRSV)) {
            Safefree(buf);
            croak("%s", SvPV_nolen(ERRSV));
        }
        SPAGAIN;
        nitems += nret;
        if (nitems > alloc) {
            alloc <<= 2;
            Renew(buf, alloc, SV*);
        }
        for (j = nret-1; j >= 0; j--) {
            /* POPs would return elements in reverse order */
            buf[d] = sp[-j];
            d++;
        }
        sp -= nret;
    }
    LEAVE;
    EXTEND(SP, nitems);
    p = buf;
    for (i = 0; i < nitems; i++)
        ST(i) = *p++;

    Safefree(buf);
    XSRETURN(nitems);
}
#line 1738 "XS.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_List__SomeUtils__XS__natatime_iterator); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS__natatime_iterator)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1216 "XS.xs"
{
    int i;
    int nret;

    /* 'cv' is the hidden argument with which
     * XS_List__SomeUtils__XS__array_iterator (this XSUB) is called. The
     * closure_arg struct is stored in this CV. */

    natatime_args *args = (natatime_args*)CvXSUBANY(cv).any_ptr;

    nret = args->natatime;

    EXTEND(SP, nret);

    for (i = 0; i < args->natatime; i++) {
        if (args->curidx < args->nsvs) {
            ST(i) = sv_2mortal(newSVsv(args->svs[args->curidx++]));
        }
        else {
            XSRETURN(i);
        }
    }

    XSRETURN(nret);
}
#line 1778 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_natatime); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_natatime)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "n, ...");
    {
	int	n = (int)SvIV(ST(0))
;
	SV *	RETVAL;
#line 1247 "XS.xs"
{
    int i;
    natatime_args * args;
    HV *stash = gv_stashpv("List::SomeUtils_na", TRUE);

    CV *closure = newXS(NULL, XS_List__SomeUtils__XS__natatime_iterator, __FILE__);

    /* must NOT set prototype on iterator: otherwise one cannot write: &$it */
    /* !! sv_setpv((SV*)closure, ""); !! */

    New(0, args, 1, natatime_args);
    New(0, args->svs, items-1, SV*);
    args->nsvs = items-1;
    args->curidx = 0;
    args->natatime = n;

    for (i = 1; i < items; i++)
        SvREFCNT_inc(args->svs[i-1] = ST(i));

    CvXSUBANY(closure).any_ptr = args;
    RETVAL = newRV_noinc((SV*)closure);

    /* in order to allow proper cleanup in DESTROY-handler */
    sv_bless(RETVAL, stash);
}
#line 1820 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_mesh); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_mesh)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
#line 1279 "XS.xs"
{
    int i, j, maxidx = -1;
    AV **avs;
    New(0, avs, items, AV*);

    for (i = 0; i < items; i++) {
        if (!arraylike(ST(i)))
            croak_xs_usage(cv,  "\\@;\\@\\@...");
        avs[i] = (AV*)SvRV(ST(i));
        if (av_len(avs[i]) > maxidx)
            maxidx = av_len(avs[i]);
    }

    EXTEND(SP, items * (maxidx + 1));
    for (i = 0; i <= maxidx; i++) {
        for (j = 0; j < items; j++) {
            SV **svp = av_fetch(avs[j], i, FALSE);
            ST(i*items + j) = svp ? sv_2mortal(newSVsv(*svp)) : &PL_sv_undef;
        }
    }

    Safefree(avs);
    XSRETURN(items * (maxidx + 1));
}
#line 1860 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_uniq); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_uniq)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
#line 1308 "XS.xs"
{
    I32 i;
    IV count = 0, seen_undef = 0;
    HV *hv = newHV();
    SV **args = &PL_stack_base[ax];
    SV *tmp = sv_newmortal();
    sv_2mortal(newRV_noinc((SV*)hv));

    /* don't build return list in scalar context */
    if (GIMME_V == G_SCALAR) {
        for (i = 0; i < items; i++) {
            SvGETMAGIC(args[i]);
            if (SvOK(args[i])) {
                sv_setsv_nomg(tmp, args[i]);
                if (!hv_exists_ent(hv, tmp, 0)) {
                    ++count;
                    hv_store_ent(hv, tmp, &PL_sv_yes, 0);
                }
            }
            else if (0 == seen_undef++) {
                ++count;
            }
        }
        ST(0) = sv_2mortal(newSVuv(count));
        XSRETURN(1);
    }

    /* list context: populate SP with mortal copies */
    for (i = 0; i < items; i++) {
        SvGETMAGIC(args[i]);
        if (SvOK(args[i])) {
            SvSetSV_nosteal(tmp, args[i]);
            if (!hv_exists_ent(hv, tmp, 0)) {
                /*ST(count) = sv_2mortal(newSVsv(ST(i)));
                  ++count;*/
                args[count++] = args[i];
                hv_store_ent(hv, tmp, &PL_sv_yes, 0);
            }
        }
        else if (0 == seen_undef++) {
            args[count++] = args[i];
        }
    }

    XSRETURN(count);
}
#line 1920 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_singleton); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_singleton)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
#line 1359 "XS.xs"
{
    I32 i;
    IV cnt = 0, count = 0, seen_undef = 0;
    HV *hv = newHV();
    SV **args = &PL_stack_base[ax];
    SV *tmp = sv_newmortal();

    sv_2mortal(newRV_noinc((SV*)hv));

    for (i = 0; i < items; i++) {
        SvGETMAGIC(args[i]);
        if (SvOK(args[i])) {
            HE *he;
            SvSetSV_nosteal(tmp, args[i]);
            he = hv_fetch_ent(hv, tmp, 0, 0);
            if (NULL == he) {
                /* ST(count) = sv_2mortal(newSVsv(ST(i))); */
                args[count++] = args[i];
                hv_store_ent(hv, tmp, newSViv(1), 0);
            }
            else {
                SV *v = HeVAL(he);
                IV how_many = SvIVX(v);
                sv_setiv(v, ++how_many);
            }
        }
        else if (0 == seen_undef++) {
            args[count++] = args[i];
        }
    }

    /* don't build return list in scalar context */
    if (GIMME_V == G_SCALAR) {
        for (i = 0; i < count; i++) {
            if (SvOK(args[i])) {
                HE *he;
                sv_setsv_nomg(tmp, args[i]);
                he = hv_fetch_ent(hv, tmp, 0, 0);
                if (he) {
                    SV *v = HeVAL(he);
                    IV how_many = SvIVX(v);
                    if ( 1 == how_many )
                        ++cnt;
                }
            }
            else if (1 == seen_undef) {
                ++cnt;
            }
        }
        ST(0) = sv_2mortal(newSViv(cnt));
        XSRETURN(1);
    }

    /* list context: populate SP with mortal copies */
    for (i = 0; i < count; i++) {
        if (SvOK(args[i])) {
            HE *he;
            SvSetSV_nosteal(tmp, args[i]);
            he = hv_fetch_ent(hv, tmp, 0, 0);
            if (he) {
                SV *v = HeVAL(he);
                IV how_many = SvIVX(v);
                if ( 1 == how_many )
                    args[cnt++] = args[i];
            }
        }
        else if (1 == seen_undef) {
            args[cnt++] = args[i];
        }
    }

    XSRETURN(cnt);
}
#line 2007 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_minmax); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_minmax)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    {
#line 1437 "XS.xs"
{
    I32 i;
    SV *minsv, *maxsv;

    if (!items)
        XSRETURN_EMPTY;

    if (items == 1) {
        EXTEND(SP, 1);
        ST(1) = sv_2mortal(newSVsv(ST(0)));
        XSRETURN(2);
    }

    minsv = maxsv = ST(0);

    for (i = 1; i < items; i += 2) {
        SV *asv = ST(i-1);
        SV *bsv = ST(i);
        int cmp = ncmp(asv, bsv);
        if (cmp < 0) {
            int min_cmp = ncmp(minsv, asv);
            int max_cmp = ncmp(maxsv, bsv);
            if (min_cmp > 0) {
                minsv = asv;
            }
            if (max_cmp < 0) {
                maxsv = bsv;
            }
        } else {
            int min_cmp = ncmp(minsv, bsv);
            int max_cmp = ncmp(maxsv, asv);
            if (min_cmp > 0) {
                minsv = bsv;
            }
            if (max_cmp < 0) {
                maxsv = asv;
            }
        }
    }

    if (items & 1) {
        SV *rsv = ST(items-1);
        if (ncmp(minsv, rsv) > 0) {
            minsv = rsv;
        }
        else if (ncmp(maxsv, rsv) < 0) {
            maxsv = rsv;
        }
    }

    ST(0) = minsv;
    ST(1) = maxsv;

    XSRETURN(2);
}
#line 2076 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_part); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_part)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
#line 1498 "XS.xs"
{
    dMULTICALL;
    int i;
    HV *stash;
    GV *gv;
    I32 gimme = G_SCALAR;
    SV **args = &PL_stack_base[ax];
    CV *_cv;

    AV **tmp = NULL;
    int last = 0;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items == 1)
        XSRETURN_EMPTY;

    _cv = sv_2cv(code, &stash, &gv, 0);
    PUSH_MULTICALL(_cv);
    SAVESPTR(GvSV(PL_defgv));

    for (i = 1 ; i < items ; ++i) {
        int idx;
        GvSV(PL_defgv) = args[i];
        MULTICALL;
        idx = SvIV(*PL_stack_sp);

        if (idx < 0 && (idx += last) < 0)
            croak("Modification of non-creatable array value attempted, subscript %i", idx);

        if (idx >= last) {
            int oldlast = last;
            last = idx + 1;
            Renew(tmp, last, AV*);
            Zero(tmp + oldlast, last - oldlast, AV*);
        }
        if (!tmp[idx])
            tmp[idx] = newAV();
        av_push(tmp[idx], newSVsv( args[i] ));
    }
    POP_MULTICALL;

    EXTEND(SP, last);
    for (i = 0; i < last; ++i) {
        if (tmp[i])
            ST(i) = sv_2mortal(newRV_noinc((SV*)tmp[i]));
        else
            ST(i) = &PL_sv_undef;
    }

    Safefree(tmp);
    XSRETURN(last);
}
#line 2146 "XS.c"
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_bsearch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_bsearch)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	SV *	RETVAL;
#line 1558 "XS.xs"
{
    dMULTICALL;
    HV *stash;
    GV *gv;
    I32 gimme = GIMME_V; /* perl-5.5.4 bus-errors out later when using GIMME
                            therefore we save its value in a fresh variable */
    SV **args = &PL_stack_base[ax];

    long i, j;
    int val = -1;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    if (items > 1) {
        CV *_cv = sv_2cv(code, &stash, &gv, 0);
        PUSH_MULTICALL(_cv);
        SAVESPTR(GvSV(PL_defgv));

        i = 0;
        j = items - 1;
        do {
            long k = (i + j) / 2;

            if (k >= items-1)
                break;

            GvSV(PL_defgv) = args[1+k];
            MULTICALL;
            val = SvIV(*PL_stack_sp);

            if (val == 0) {
                POP_MULTICALL;
                if (gimme != G_ARRAY) {
                    XSRETURN_YES;
                }
                SvREFCNT_inc(RETVAL = args[1+k]);
                goto yes;
            }
            if (val < 0) {
                i = k+1;
            } else {
                j = k-1;
            }
        } while (i <= j);
        POP_MULTICALL;
    }

    if (gimme == G_ARRAY)
        XSRETURN_EMPTY;
    else
        XSRETURN_UNDEF;
 yes:
    ;
}
#line 2218 "XS.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_bsearchidx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_bsearchidx)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "code, ...");
    {
	SV *	code = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 1621 "XS.xs"
{
    dMULTICALL;
    HV *stash;
    GV *gv;
    I32 gimme = GIMME_V; /* perl-5.5.4 bus-errors out later when using GIMME
                            therefore we save its value in a fresh variable */
    SV **args = &PL_stack_base[ax];

    long i, j;
    int val = -1;

    if (!codelike(code))
        croak_xs_usage(cv,  "code, ...");

    RETVAL = -1;

    if (items > 1) {
        CV *_cv = sv_2cv(code, &stash, &gv, 0);
        PUSH_MULTICALL(_cv);
        SAVESPTR(GvSV(PL_defgv));

        i = 0;
        j = items - 1;
        do {
            long k = (i + j) / 2;

            if (k >= items-1)
                break;

            GvSV(PL_defgv) = args[1+k];
            MULTICALL;
            val = SvIV(*PL_stack_sp);

            if (val == 0) {
                RETVAL = k;
                break;
            }
            if (val < 0) {
                i = k+1;
            } else {
                j = k-1;
            }
        } while (i <= j);
        POP_MULTICALL;
    }
}
#line 2284 "XS.c"
	XSprePUSH;
	PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_List__SomeUtils__XS_mode); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_List__SomeUtils__XS_mode)
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1674 "XS.xs"
{
    int i;
    unsigned int max = 0;
    unsigned int c = 0;
    unsigned int modality = 0;
    SV **args = &PL_stack_base[ax];
    HV *hv = newHV();
    SV *tmp = sv_newmortal();
    HE *he;

    sv_2mortal(newRV_noinc((SV*)hv));
    if (!items) {
        if (GIMME_V == G_SCALAR) {
            mPUSHi(0);
            PUTBACK;
            return;
        }
        else {
            XSRETURN_EMPTY;
        }
    }

    for (i = 0; i < items; i++) {
        SvGETMAGIC(args[i]);

        SvSetSV_nosteal(tmp, args[i]);
        he = hv_fetch_ent(hv, tmp, 0, 0);

        if (NULL == he) {
            hv_store_ent(hv, tmp, newSViv(1), 0);
        }
        else {
            SV *v = HeVAL(he);
            IV how_many = SvIVX(v);
            sv_setiv(v, ++how_many);
        }
    }

    hv_iterinit(hv);
    while ((he = hv_iternext(hv))) {
        c = SvIV(HeVAL(he));
        if (c > max) {
            max = c;
        }
    }

    i = 0;
    hv_iterinit(hv);
    while ((he = hv_iternext(hv))) {
        if (SvIV(HeVAL(he)) == max) {
            if (GIMME_V == G_SCALAR) {
                modality++;
            } else {
                XPUSHs(HeSVKEY_force(he));
            }
        }
    }

    if  (GIMME_V == G_SCALAR) {
        mXPUSHu(modality);
    }
}
#line 2364 "XS.c"
	PUTBACK;
	return;
    }
}

#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_List__SomeUtils__XS); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_List__SomeUtils__XS)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if PERL_VERSION_LE(5, 8, 999) /* PERL_VERSION_LT is 5.33+ */
    char* file = __FILE__;
#else
    const char* file = __FILE__;
#endif

    PERL_UNUSED_VAR(file);

    PERL_UNUSED_VAR(cv); /* -W */
    PERL_UNUSED_VAR(items); /* -W */
#if PERL_VERSION_LE(5, 21, 5)
    XS_VERSION_BOOTCHECK;
#  ifdef XS_APIVERSION_BOOTCHECK
    XS_APIVERSION_BOOTCHECK;
#  endif
#endif

        newXS_deffile("List::SomeUtils_ea::DESTROY", XS_List__SomeUtils_ea_DESTROY);
        newXS_deffile("List::SomeUtils_na::DESTROY", XS_List__SomeUtils_na_DESTROY);
        (void)newXSproto_portable("List::SomeUtils::XS::any", XS_List__SomeUtils__XS_any, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::all", XS_List__SomeUtils__XS_all, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::none", XS_List__SomeUtils__XS_none, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::notall", XS_List__SomeUtils__XS_notall, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::one", XS_List__SomeUtils__XS_one, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::any_u", XS_List__SomeUtils__XS_any_u, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::all_u", XS_List__SomeUtils__XS_all_u, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::none_u", XS_List__SomeUtils__XS_none_u, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::notall_u", XS_List__SomeUtils__XS_notall_u, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::one_u", XS_List__SomeUtils__XS_one_u, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::true", XS_List__SomeUtils__XS_true, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::false", XS_List__SomeUtils__XS_false, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::firstidx", XS_List__SomeUtils__XS_firstidx, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::firstval", XS_List__SomeUtils__XS_firstval, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::firstres", XS_List__SomeUtils__XS_firstres, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::onlyidx", XS_List__SomeUtils__XS_onlyidx, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::onlyval", XS_List__SomeUtils__XS_onlyval, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::onlyres", XS_List__SomeUtils__XS_onlyres, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::lastidx", XS_List__SomeUtils__XS_lastidx, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::lastval", XS_List__SomeUtils__XS_lastval, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::lastres", XS_List__SomeUtils__XS_lastres, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::insert_after", XS_List__SomeUtils__XS_insert_after, file, "&$\\@");
        (void)newXSproto_portable("List::SomeUtils::XS::insert_after_string", XS_List__SomeUtils__XS_insert_after_string, file, "$$\\@");
        (void)newXSproto_portable("List::SomeUtils::XS::apply", XS_List__SomeUtils__XS_apply, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::after", XS_List__SomeUtils__XS_after, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::after_incl", XS_List__SomeUtils__XS_after_incl, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::before", XS_List__SomeUtils__XS_before, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::before_incl", XS_List__SomeUtils__XS_before_incl, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::indexes", XS_List__SomeUtils__XS_indexes, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::_array_iterator", XS_List__SomeUtils__XS__array_iterator, file, ";$");
        (void)newXSproto_portable("List::SomeUtils::XS::each_array", XS_List__SomeUtils__XS_each_array, file, "\\@;\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@");
        newXS_deffile("List::SomeUtils::XS::each_arrayref", XS_List__SomeUtils__XS_each_arrayref);
        (void)newXSproto_portable("List::SomeUtils::XS::pairwise", XS_List__SomeUtils__XS_pairwise, file, "&\\@\\@");
        (void)newXSproto_portable("List::SomeUtils::XS::_natatime_iterator", XS_List__SomeUtils__XS__natatime_iterator, file, "");
        (void)newXSproto_portable("List::SomeUtils::XS::natatime", XS_List__SomeUtils__XS_natatime, file, "$@");
        (void)newXSproto_portable("List::SomeUtils::XS::mesh", XS_List__SomeUtils__XS_mesh, file, "\\@\\@;\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@\\@");
        (void)newXSproto_portable("List::SomeUtils::XS::uniq", XS_List__SomeUtils__XS_uniq, file, "@");
        (void)newXSproto_portable("List::SomeUtils::XS::singleton", XS_List__SomeUtils__XS_singleton, file, "@");
        (void)newXSproto_portable("List::SomeUtils::XS::minmax", XS_List__SomeUtils__XS_minmax, file, "@");
        (void)newXSproto_portable("List::SomeUtils::XS::part", XS_List__SomeUtils__XS_part, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::bsearch", XS_List__SomeUtils__XS_bsearch, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::bsearchidx", XS_List__SomeUtils__XS_bsearchidx, file, "&@");
        (void)newXSproto_portable("List::SomeUtils::XS::mode", XS_List__SomeUtils__XS_mode, file, "@");
#if PERL_VERSION_LE(5, 21, 5)
#  if PERL_VERSION_GE(5, 9, 0)
    if (PL_unitcheckav)
        call_list(PL_scopestack_ix, PL_unitcheckav);
#  endif
    XSRETURN_YES;
#else
    Perl_xs_boot_epilog(aTHX_ ax);
#endif
}

