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

#line 1 "lib/XS/JIT/Builder.xs"
#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#include "xs_jit_builder.h"

/* Store the builder pointer in the object's hash */
#define BUILDER_KEY "_builder_ptr"
#define BUILDER_KEY_LEN 12

static XS_JIT_Builder* get_builder(pTHX_ SV* self) {
    HV* hv;
    SV** svp;
    
    if (!SvROK(self) || SvTYPE(SvRV(self)) != SVt_PVHV) {
        croak("Not a valid XS::JIT::Builder object");
    }
    
    hv = (HV*)SvRV(self);
    svp = hv_fetch(hv, BUILDER_KEY, BUILDER_KEY_LEN, 0);
    
    if (!svp || !SvOK(*svp)) {
        croak("Builder object not initialized");
    }
    
    return INT2PTR(XS_JIT_Builder*, SvIV(*svp));
}

static void set_builder(pTHX_ SV* self, XS_JIT_Builder* b) {
    HV* hv = (HV*)SvRV(self);
    hv_store(hv, BUILDER_KEY, BUILDER_KEY_LEN, newSViv(PTR2IV(b)), 0);
}

#line 45 "lib/XS/JIT/Builder.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

/* simple backcompat versions of the TARGx() macros with no optimisation */
#ifndef TARGi
#  define TARGi(iv, do_taint) sv_setiv_mg(TARG, iv)
#  define TARGu(uv, do_taint) sv_setuv_mg(TARG, uv)
#  define TARGn(nv, do_taint) sv_setnv_mg(TARG, nv)
#endif

#line 196 "lib/XS/JIT/Builder.c"

XS_EUPXS(XS_XS__JIT__Builder_new); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "class, ...");
    {
	const char*	class = (const char *)SvPV_nolen(ST(0))
;
#line 68 "lib/XS/JIT/Builder.xs"
        HV* hv;
        SV* self;
        XS_JIT_Builder* b;
        int indent_width = 4;
        int use_tabs = 0;
        int i;
#line 214 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 75 "lib/XS/JIT/Builder.xs"
        /* Parse options */
        for (i = 1; i < items; i += 2) {
            if (i + 1 < items) {
                const char* key = SvPV_nolen(ST(i));
                if (strEQ(key, "indent_width")) {
                    indent_width = SvIV(ST(i + 1));
                } else if (strEQ(key, "use_tabs")) {
                    use_tabs = SvTRUE(ST(i + 1)) ? 1 : 0;
                }
            }
        }

        /* Create the builder */
        b = xs_jit_builder_new(aTHX);
        xs_jit_set_indent_width(b, indent_width);
        xs_jit_set_use_tabs(b, use_tabs);

        /* Create blessed hashref */
        hv = newHV();
        self = newRV_noinc((SV*)hv);
        sv_bless(self, gv_stashpv(class, GV_ADD));

        /* Store the pointer */
        set_builder(aTHX_ self, b);

        RETVAL = self;
#line 243 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_DESTROY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_DESTROY)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 108 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 262 "lib/XS/JIT/Builder.c"
#line 110 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_builder_free(aTHX_ b);
#line 266 "lib/XS/JIT/Builder.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_XS__JIT__Builder_code); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_code)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 117 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 283 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 119 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        RETVAL = xs_jit_builder_code(aTHX_ b);
#line 288 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_reset); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_reset)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 128 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 307 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 130 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_builder_reset(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 313 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_line); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_line)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, fmt, ...");
    {
	SV*	self = ST(0)
;
	const char*	fmt = (const char *)SvPV_nolen(ST(1))
;
#line 141 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 334 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 143 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_line(aTHX_ b, "%s", fmt);
        RETVAL = SvREFCNT_inc(self);
#line 340 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_raw); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_raw)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, text");
    {
	SV*	self = ST(0)
;
	const char*	text = (const char *)SvPV_nolen(ST(1))
;
#line 154 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 361 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 156 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_raw(aTHX_ b, "%s", text);
        RETVAL = SvREFCNT_inc(self);
#line 367 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_comment); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_comment)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, text");
    {
	SV*	self = ST(0)
;
	const char*	text = (const char *)SvPV_nolen(ST(1))
;
#line 167 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 388 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 169 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_comment(aTHX_ b, text);
        RETVAL = SvREFCNT_inc(self);
#line 394 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_blank); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_blank)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 179 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 413 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 181 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_blank(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 419 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_indent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_indent)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 191 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 438 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 193 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_indent(b);
        RETVAL = SvREFCNT_inc(self);
#line 444 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_dedent); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_dedent)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 203 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 463 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 205 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_dedent(b);
        RETVAL = SvREFCNT_inc(self);
#line 469 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_block_start); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_block_start)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 215 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 488 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 217 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_block_start(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 494 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_block_end); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_block_end)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 227 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 513 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 229 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_block_end(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 519 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xs_function); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xs_function)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 240 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 540 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 242 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_function(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 546 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xs_preamble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xs_preamble)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 252 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 565 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 254 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_preamble(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 571 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xs_end); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xs_end)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 264 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 590 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 266 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_end(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 596 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xs_return); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xs_return)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, count");
    {
	SV*	self = ST(0)
;
	int	count = (int)SvIV(ST(1))
;
#line 277 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 617 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 279 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_return(aTHX_ b, count);
        RETVAL = SvREFCNT_inc(self);
#line 623 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xs_return_undef); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xs_return_undef)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 289 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 642 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 291 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_return_undef(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 648 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_undef); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_undef)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 301 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 667 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 303 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xs_return_undef(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 673 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_croak_usage); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_croak_usage)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, usage");
    {
	SV*	self = ST(0)
;
	const char*	usage = (const char *)SvPV_nolen(ST(1))
;
#line 314 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 694 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 316 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_croak_usage(aTHX_ b, usage);
        RETVAL = SvREFCNT_inc(self);
#line 700 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_if); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_if)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, cond");
    {
	SV*	self = ST(0)
;
	const char*	cond = (const char *)SvPV_nolen(ST(1))
;
#line 327 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 721 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 329 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_if(aTHX_ b, cond);
        RETVAL = SvREFCNT_inc(self);
#line 727 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_elsif); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_elsif)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, cond");
    {
	SV*	self = ST(0)
;
	const char*	cond = (const char *)SvPV_nolen(ST(1))
;
#line 340 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 748 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 342 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_elsif(aTHX_ b, cond);
        RETVAL = SvREFCNT_inc(self);
#line 754 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_else); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_else)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 352 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 773 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 354 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_else(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 779 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_endif); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_endif)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 364 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 798 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 366 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_endif(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 804 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_for); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_for)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, init, cond, incr");
    {
	SV*	self = ST(0)
;
	const char*	init = (const char *)SvPV_nolen(ST(1))
;
	const char*	cond = (const char *)SvPV_nolen(ST(2))
;
	const char*	incr = (const char *)SvPV_nolen(ST(3))
;
#line 379 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 829 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 381 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_for(aTHX_ b, init, cond, incr);
        RETVAL = SvREFCNT_inc(self);
#line 835 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_while); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_while)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, cond");
    {
	SV*	self = ST(0)
;
	const char*	cond = (const char *)SvPV_nolen(ST(1))
;
#line 392 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 856 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 394 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_while(aTHX_ b, cond);
        RETVAL = SvREFCNT_inc(self);
#line 862 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_endloop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_endloop)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 404 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 881 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 406 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_endloop(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 887 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_endfor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_endfor)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 416 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 906 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 418 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_endloop(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 912 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_endwhile); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_endwhile)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 428 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 931 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 430 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_endloop(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 937 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_block); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_block)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 440 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 956 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 442 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_block_start(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 962 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_endblock); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_endblock)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 452 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 981 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 454 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_block_end(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 987 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "self, type, name, ...");
    {
	SV*	self = ST(0)
;
	const char*	type = (const char *)SvPV_nolen(ST(1))
;
	const char*	name = (const char *)SvPV_nolen(ST(2))
;
#line 466 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* value = NULL;
#line 1011 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 469 "lib/XS/JIT/Builder.xs"
        if (items > 3 && SvOK(ST(3))) {
            value = SvPV_nolen(ST(3));
        }
        b = get_builder(aTHX_ self);
        xs_jit_declare(aTHX_ b, type, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1020 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_sv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 484 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1043 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 486 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_sv(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1049 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_hv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_hv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 498 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1072 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 500 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_hv(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1078 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_av); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_av)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 512 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1101 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 514 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_av(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1107 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_hv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_hv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 525 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1128 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 527 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_hv(aTHX_ b, name, "newHV()");
        RETVAL = SvREFCNT_inc(self);
#line 1134 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_av); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_av)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 538 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1155 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 540 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_av(aTHX_ b, name, "newAV()");
        RETVAL = SvREFCNT_inc(self);
#line 1161 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_int); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_int)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 552 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1184 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 554 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_int(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1190 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_iv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 566 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1213 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 568 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_iv(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1219 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_nv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 580 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1242 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 582 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_nv(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1248 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_pv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, value");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 594 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1271 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 596 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_pv(aTHX_ b, name, value);
        RETVAL = SvREFCNT_inc(self);
#line 1277 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_assign); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_assign)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, var, value");
    {
	SV*	self = ST(0)
;
	const char*	var = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 608 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1300 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 610 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_assign(aTHX_ b, var, value);
        RETVAL = SvREFCNT_inc(self);
#line 1306 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_get_self); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_get_self)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 620 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1325 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 622 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_get_self(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 1331 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_get_self_hv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_get_self_hv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 632 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1350 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 634 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_get_self_hv(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 1356 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_get_self_av); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_get_self_av)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 644 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1375 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 646 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_get_self_av(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 1381 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_fetch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_fetch)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, hv, key, len, result_var");
    {
	SV*	self = ST(0)
;
	const char*	hv = (const char *)SvPV_nolen(ST(1))
;
	const char*	key = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	len = (STRLEN)SvUV(ST(3))
;
	const char*	result_var = (const char *)SvPV_nolen(ST(4))
;
#line 660 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1408 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 662 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_fetch(aTHX_ b, hv, key, len, result_var);
        RETVAL = SvREFCNT_inc(self);
#line 1414 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_fetch_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_fetch_sv)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, hv, key_expr, len_expr, result_var");
    {
	SV*	self = ST(0)
;
	const char*	hv = (const char *)SvPV_nolen(ST(1))
;
	const char*	key_expr = (const char *)SvPV_nolen(ST(2))
;
	const char*	len_expr = (const char *)SvPV_nolen(ST(3))
;
	const char*	result_var = (const char *)SvPV_nolen(ST(4))
;
#line 676 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1441 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 678 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_fetch_sv(aTHX_ b, hv, key_expr, len_expr, result_var);
        RETVAL = SvREFCNT_inc(self);
#line 1447 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_store); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_store)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, hv, key, len, value");
    {
	SV*	self = ST(0)
;
	const char*	hv = (const char *)SvPV_nolen(ST(1))
;
	const char*	key = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	len = (STRLEN)SvUV(ST(3))
;
	const char*	value = (const char *)SvPV_nolen(ST(4))
;
#line 692 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1474 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 694 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_store(aTHX_ b, hv, key, len, value);
        RETVAL = SvREFCNT_inc(self);
#line 1480 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_store_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_store_sv)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, hv, key_expr, len_expr, value");
    {
	SV*	self = ST(0)
;
	const char*	hv = (const char *)SvPV_nolen(ST(1))
;
	const char*	key_expr = (const char *)SvPV_nolen(ST(2))
;
	const char*	len_expr = (const char *)SvPV_nolen(ST(3))
;
	const char*	value = (const char *)SvPV_nolen(ST(4))
;
#line 708 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1507 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 710 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_store_sv(aTHX_ b, hv, key_expr, len_expr, value);
        RETVAL = SvREFCNT_inc(self);
#line 1513 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_fetch_return); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_fetch_return)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, hv, key, len");
    {
	SV*	self = ST(0)
;
	const char*	hv = (const char *)SvPV_nolen(ST(1))
;
	const char*	key = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	len = (STRLEN)SvUV(ST(3))
;
#line 723 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1538 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 725 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_fetch_return(aTHX_ b, hv, key, len);
        RETVAL = SvREFCNT_inc(self);
#line 1544 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_fetch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_fetch)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, av, index, result_var");
    {
	SV*	self = ST(0)
;
	const char*	av = (const char *)SvPV_nolen(ST(1))
;
	const char*	index = (const char *)SvPV_nolen(ST(2))
;
	const char*	result_var = (const char *)SvPV_nolen(ST(3))
;
#line 738 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1569 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 740 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_fetch(aTHX_ b, av, index, result_var);
        RETVAL = SvREFCNT_inc(self);
#line 1575 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_store); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_store)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, av, index, value");
    {
	SV*	self = ST(0)
;
	const char*	av = (const char *)SvPV_nolen(ST(1))
;
	const char*	index = (const char *)SvPV_nolen(ST(2))
;
	const char*	value = (const char *)SvPV_nolen(ST(3))
;
#line 753 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1600 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 755 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_store(aTHX_ b, av, index, value);
        RETVAL = SvREFCNT_inc(self);
#line 1606 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_push); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_push)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, av, value");
    {
	SV*	self = ST(0)
;
	const char*	av = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 767 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1629 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 769 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_push(aTHX_ b, av, value);
        RETVAL = SvREFCNT_inc(self);
#line 1635 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_len); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_len)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, av, result_var");
    {
	SV*	self = ST(0)
;
	const char*	av = (const char *)SvPV_nolen(ST(1))
;
	const char*	result_var = (const char *)SvPV_nolen(ST(2))
;
#line 781 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1658 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 783 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_len(aTHX_ b, av, result_var);
        RETVAL = SvREFCNT_inc(self);
#line 1664 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_sv_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_sv_iv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, value");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 795 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1687 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 797 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_sv_iv(aTHX_ b, result_var, value);
        RETVAL = SvREFCNT_inc(self);
#line 1693 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_sv_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_sv_nv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, value");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	value = (const char *)SvPV_nolen(ST(2))
;
#line 809 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1716 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 811 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_sv_nv(aTHX_ b, result_var, value);
        RETVAL = SvREFCNT_inc(self);
#line 1722 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_sv_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_sv_pv)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, result_var, str, len");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	str = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	len = (STRLEN)SvUV(ST(3))
;
#line 824 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1747 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 826 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_sv_pv(aTHX_ b, result_var, str, len);
        RETVAL = SvREFCNT_inc(self);
#line 1753 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_mortal); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_mortal)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sv");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
#line 837 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1774 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 839 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_mortal(aTHX_ b, sv);
        RETVAL = SvREFCNT_inc(self);
#line 1780 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_croak); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_croak)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, message");
    {
	SV*	self = ST(0)
;
	const char*	message = (const char *)SvPV_nolen(ST(1))
;
#line 850 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1801 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 852 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_croak(aTHX_ b, message);
        RETVAL = SvREFCNT_inc(self);
#line 1807 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_warn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_warn)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, message");
    {
	SV*	self = ST(0)
;
	const char*	message = (const char *)SvPV_nolen(ST(1))
;
#line 863 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1828 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 865 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_warn(aTHX_ b, message);
        RETVAL = SvREFCNT_inc(self);
#line 1834 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_check_items); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_check_items)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, min, max, usage");
    {
	SV*	self = ST(0)
;
	int	min = (int)SvIV(ST(1))
;
	int	max = (int)SvIV(ST(2))
;
	const char*	usage = (const char *)SvPV_nolen(ST(3))
;
#line 878 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1859 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 880 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_check_items(aTHX_ b, min, max, usage);
        RETVAL = SvREFCNT_inc(self);
#line 1865 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_check_defined); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_check_defined)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, sv, error_msg");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
	const char*	error_msg = (const char *)SvPV_nolen(ST(2))
;
#line 892 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1888 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 894 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_check_defined(aTHX_ b, sv, error_msg);
        RETVAL = SvREFCNT_inc(self);
#line 1894 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_check_hashref); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_check_hashref)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, sv, error_msg");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
	const char*	error_msg = (const char *)SvPV_nolen(ST(2))
;
#line 906 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1917 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 908 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_check_hashref(aTHX_ b, sv, error_msg);
        RETVAL = SvREFCNT_inc(self);
#line 1923 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_check_arrayref); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_check_arrayref)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, sv, error_msg");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
	const char*	error_msg = (const char *)SvPV_nolen(ST(2))
;
#line 920 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1946 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 922 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_check_arrayref(aTHX_ b, sv, error_msg);
        RETVAL = SvREFCNT_inc(self);
#line 1952 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_sv_to_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_sv_to_iv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, sv");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	sv = (const char *)SvPV_nolen(ST(2))
;
#line 934 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 1975 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 936 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_sv_to_iv(aTHX_ b, result_var, sv);
        RETVAL = SvREFCNT_inc(self);
#line 1981 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_sv_to_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_sv_to_nv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, sv");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	sv = (const char *)SvPV_nolen(ST(2))
;
#line 948 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2004 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 950 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_sv_to_nv(aTHX_ b, result_var, sv);
        RETVAL = SvREFCNT_inc(self);
#line 2010 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_sv_to_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_sv_to_pv)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, result_var, len_var, sv");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	SV*	len_var = ST(2)
;
	const char*	sv = (const char *)SvPV_nolen(ST(3))
;
#line 963 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* len_var_str = NULL;
#line 2036 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 966 "lib/XS/JIT/Builder.xs"
        if (SvOK(len_var)) {
            len_var_str = SvPV_nolen(len_var);
        }
        b = get_builder(aTHX_ self);
        xs_jit_sv_to_pv(aTHX_ b, result_var, len_var_str, sv);
        RETVAL = SvREFCNT_inc(self);
#line 2045 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_sv_to_bool); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_sv_to_bool)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, sv");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	sv = (const char *)SvPV_nolen(ST(2))
;
#line 981 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2068 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 983 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_sv_to_bool(aTHX_ b, result_var, sv);
        RETVAL = SvREFCNT_inc(self);
#line 2074 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_iv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, value");
    {
	SV*	self = ST(0)
;
	const char*	value = (const char *)SvPV_nolen(ST(1))
;
#line 994 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2095 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 996 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_iv(aTHX_ b, value);
        RETVAL = SvREFCNT_inc(self);
#line 2101 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_nv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, value");
    {
	SV*	self = ST(0)
;
	const char*	value = (const char *)SvPV_nolen(ST(1))
;
#line 1007 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2122 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1009 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_nv(aTHX_ b, value);
        RETVAL = SvREFCNT_inc(self);
#line 2128 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_pv)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, str, ...");
    {
	SV*	self = ST(0)
;
	const char*	str = (const char *)SvPV_nolen(ST(1))
;
#line 1020 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* len_str = NULL;
#line 2150 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1023 "lib/XS/JIT/Builder.xs"
        if (items > 2 && SvOK(ST(2))) {
            len_str = SvPV_nolen(ST(2));
        }
        b = get_builder(aTHX_ self);
        xs_jit_return_pv(aTHX_ b, str, len_str);
        RETVAL = SvREFCNT_inc(self);
#line 2159 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sv");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
#line 1037 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2180 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1039 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_sv(aTHX_ b, sv);
        RETVAL = SvREFCNT_inc(self);
#line 2186 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_yes); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_yes)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1049 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2205 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1051 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_yes(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 2211 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_no); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_no)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1061 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2230 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1063 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_no(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 2236 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_self); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_self)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1073 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2255 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1075 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_return_self(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 2261 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_method_start); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_method_start)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, min_args, max_args, usage");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	int	min_args = (int)SvIV(ST(2))
;
	int	max_args = (int)SvIV(ST(3))
;
	const char*	usage = (const char *)SvPV_nolen(ST(4))
;
#line 1089 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2288 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1091 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_method_start(aTHX_ b, func_name, min_args, max_args, usage);
        RETVAL = SvREFCNT_inc(self);
#line 2294 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ro_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ro_accessor)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 1104 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2319 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1106 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ro_accessor(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 2325 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_rw_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_rw_accessor)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 1119 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2350 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1121 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_rw_accessor(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 2356 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_accessor)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, attr_name, ...");
    {
	SV*	self = ST(0)
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(1))
;
#line 1132 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        int readonly = 0;
        STRLEN attr_len;
#line 2379 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1136 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_len = strlen(attr_name);
        /* Check for readonly option in hash-style args */
        if (items > 2) {
            SV* opts = ST(2);
            if (SvROK(opts) && SvTYPE(SvRV(opts)) == SVt_PVHV) {
                HV* hv = (HV*)SvRV(opts);
                SV** val = hv_fetchs(hv, "readonly", 0);
                if (val && *val && SvTRUE(*val)) {
                    readonly = 1;
                }
            }
        }
        if (readonly) {
            xs_jit_ro_accessor(aTHX_ b, attr_name, attr_name, attr_len);
        } else {
            xs_jit_rw_accessor(aTHX_ b, attr_name, attr_name, attr_len);
        }
        RETVAL = SvREFCNT_inc(self);
#line 2401 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_predicate); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_predicate)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, attr_name");
    {
	SV*	self = ST(0)
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(1))
;
#line 1163 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        char func_name[256];
        STRLEN attr_len;
#line 2424 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1167 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_len = strlen(attr_name);
        snprintf(func_name, sizeof(func_name), "has_%s", attr_name);
        xs_jit_predicate(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 2432 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_clearer); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_clearer)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, attr_name");
    {
	SV*	self = ST(0)
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(1))
;
#line 1180 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        char func_name[256];
        STRLEN attr_len;
#line 2455 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1184 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_len = strlen(attr_name);
        snprintf(func_name, sizeof(func_name), "clear_%s", attr_name);
        xs_jit_clearer(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 2463 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_constructor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_constructor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, attrs");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	AV*	attrs;
#line 1198 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_Attr* attr_array;
        int num_attrs;
        int i;
#line 2488 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    attrs = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::constructor",
				"attrs");
		}
	} STMT_END
;
#line 1203 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_attrs = av_len(attrs) + 1;

        if (num_attrs > 0) {
            Newx(attr_array, num_attrs, XS_JIT_Attr);

            for (i = 0; i < num_attrs; i++) {
                SV** elem = av_fetch(attrs, i, 0);
                if (elem && SvROK(*elem) && SvTYPE(SvRV(*elem)) == SVt_PVAV) {
                    AV* pair = (AV*)SvRV(*elem);
                    SV** name_sv = av_fetch(pair, 0, 0);
                    SV** len_sv = av_fetch(pair, 1, 0);

                    if (name_sv && len_sv) {
                        attr_array[i].name = SvPV_nolen(*name_sv);
                        attr_array[i].len = SvIV(*len_sv);
                    }
                } else if (elem && SvPOK(*elem)) {
                    /* Simple string attribute name */
                    attr_array[i].name = SvPV_nolen(*elem);
                    attr_array[i].len = SvCUR(*elem);
                }
            }

            xs_jit_constructor(aTHX_ b, func_name, NULL, attr_array, num_attrs);
            Safefree(attr_array);
        } else {
            xs_jit_constructor(aTHX_ b, func_name, NULL, NULL, 0);
        }

        RETVAL = SvREFCNT_inc(self);
#line 2536 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_simple); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_simple)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1242 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2557 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1244 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_simple(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 2563 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_hash); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_hash)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1255 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2584 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1257 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_hash(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 2590 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_array); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_array)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, num_slots");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	int	num_slots = (int)SvIV(ST(2))
;
#line 1269 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2613 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1271 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_array(aTHX_ b, func_name, num_slots);
        RETVAL = SvREFCNT_inc(self);
#line 2619 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_with_build); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_with_build)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1282 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2640 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1284 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_new_with_build(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 2646 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_clone_hash); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_clone_hash)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1295 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2667 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1297 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_clone_hash(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 2673 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_clone_array); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_clone_array)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1308 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2694 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1310 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_clone_array(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 2700 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_with_required); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_with_required)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, required_av");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	AV*	required_av;
#line 1322 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char** required_attrs;
        STRLEN* required_lens;
        int num_required;
        int i;
#line 2726 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    required_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::new_with_required",
				"required_av");
		}
	} STMT_END
;
#line 1328 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_required = av_len(required_av) + 1;
        if (num_required > 0) {
            Newx(required_attrs, num_required, const char*);
            Newx(required_lens, num_required, STRLEN);
            for (i = 0; i < num_required; i++) {
                SV** elem = av_fetch(required_av, i, 0);
                if (elem && *elem) {
                    required_attrs[i] = SvPV(*elem, required_lens[i]);
                } else {
                    required_attrs[i] = "";
                    required_lens[i] = 0;
                }
            }
            xs_jit_new_with_required(aTHX_ b, func_name, required_attrs, required_lens, num_required);
            Safefree(required_attrs);
            Safefree(required_lens);
        } else {
            xs_jit_new_with_required(aTHX_ b, func_name, NULL, NULL, 0);
        }
        RETVAL = SvREFCNT_inc(self);
#line 2764 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_typed); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_typed)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, type, error_msg");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	int	type = (int)SvIV(ST(4))
;
	const char*	error_msg = (const char *)SvPV_nolen(ST(5))
;
#line 1361 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2793 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1363 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_rw_accessor_typed(aTHX_ b, func_name, attr_name, attr_len, type, error_msg);
        RETVAL = SvREFCNT_inc(self);
#line 2799 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_weak); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_weak)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 1376 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2824 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1378 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_rw_accessor_weak(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 2830 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_hv_store_weak); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_hv_store_weak)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, hv_name, key, key_len, value_expr");
    {
	SV*	self = ST(0)
;
	const char*	hv_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	key = (const char *)SvPV_nolen(ST(2))
;
	int	key_len = (int)SvIV(ST(3))
;
	const char*	value_expr = (const char *)SvPV_nolen(ST(4))
;
#line 1392 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 2857 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1394 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_hv_store_weak(aTHX_ b, hv_name, key, key_len, value_expr);
        RETVAL = SvREFCNT_inc(self);
#line 2863 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_new_complete); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_new_complete)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attrs_av, call_build");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	AV*	attrs_av;
	int	call_build = (int)SvIV(ST(3))
;
#line 1407 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_AttrSpec* attrs;
        int num_attrs;
        int i;
#line 2890 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    attrs_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::new_complete",
				"attrs_av");
		}
	} STMT_END
;
#line 1412 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_attrs = av_len(attrs_av) + 1;

        if (num_attrs > 0) {
            Newxz(attrs, num_attrs, XS_JIT_AttrSpec);

            for (i = 0; i < num_attrs; i++) {
                SV** elem = av_fetch(attrs_av, i, 0);
                if (elem && SvROK(*elem) && SvTYPE(SvRV(*elem)) == SVt_PVHV) {
                    HV* spec = (HV*)SvRV(*elem);
                    SV** val;

                    /* Required: name */
                    val = hv_fetchs(spec, "name", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].name = SvPV(*val, attrs[i].len);
                    }

                    /* Optional: required */
                    val = hv_fetchs(spec, "required", 0);
                    if (val && SvTRUE(*val)) {
                        attrs[i].required = 1;
                    }

                    /* Optional: type */
                    val = hv_fetchs(spec, "type", 0);
                    if (val && SvIOK(*val)) {
                        attrs[i].type = SvIV(*val);
                    }

                    /* Optional: type_msg */
                    val = hv_fetchs(spec, "type_msg", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].type_msg = SvPV_nolen(*val);
                    }

                    /* Optional: weak */
                    val = hv_fetchs(spec, "weak", 0);
                    if (val && SvTRUE(*val)) {
                        attrs[i].weak = 1;
                    }

                    /* Optional: coerce */
                    val = hv_fetchs(spec, "coerce", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].coerce = SvPV(*val, attrs[i].coerce_len);
                    }

                    /* Optional: default_iv */
                    val = hv_fetchs(spec, "default_iv", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].has_default = XS_JIT_DEFAULT_IV;
                        attrs[i].default_iv = SvIV(*val);
                    }

                    /* Optional: default_nv */
                    val = hv_fetchs(spec, "default_nv", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].has_default = XS_JIT_DEFAULT_NV;
                        attrs[i].default_nv = SvNV(*val);
                    }

                    /* Optional: default_pv */
                    val = hv_fetchs(spec, "default_pv", 0);
                    if (val && SvOK(*val)) {
                        attrs[i].has_default = XS_JIT_DEFAULT_PV;
                        attrs[i].default_pv = SvPV(*val, attrs[i].default_pv_len);
                    }

                    /* Optional: default_av (creates empty []) */
                    val = hv_fetchs(spec, "default_av", 0);
                    if (val && SvTRUE(*val)) {
                        attrs[i].has_default = XS_JIT_DEFAULT_AV;
                    }

                    /* Optional: default_hv (creates empty {}) */
                    val = hv_fetchs(spec, "default_hv", 0);
                    if (val && SvTRUE(*val)) {
                        attrs[i].has_default = XS_JIT_DEFAULT_HV;
                    }
                }
            }

            xs_jit_new_complete(aTHX_ b, func_name, attrs, num_attrs, call_build);
            Safefree(attrs);
        } else {
            xs_jit_new_complete(aTHX_ b, func_name, NULL, 0, call_build);
        }

        RETVAL = SvREFCNT_inc(self);
#line 2997 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_call_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_call_sv)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, cv_expr, args_av");
    {
	SV*	self = ST(0)
;
	const char*	cv_expr = (const char *)SvPV_nolen(ST(1))
;
	AV*	args_av;
#line 1511 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char** args;
        int num_args;
        int i;
#line 3022 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    args_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::call_sv",
				"args_av");
		}
	} STMT_END
;
#line 1516 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_args = av_len(args_av) + 1;

        if (num_args > 0) {
            Newxz(args, num_args, const char*);
            for (i = 0; i < num_args; i++) {
                SV** elem = av_fetch(args_av, i, 0);
                if (elem && SvOK(*elem)) {
                    args[i] = SvPV_nolen(*elem);
                } else {
                    args[i] = "NULL";
                }
            }
            xs_jit_call_sv(aTHX_ b, cv_expr, args, num_args);
            Safefree(args);
        } else {
            xs_jit_call_sv(aTHX_ b, cv_expr, NULL, 0);
        }

        RETVAL = SvREFCNT_inc(self);
#line 3059 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_call_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_call_method)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, method_name, invocant, args_av");
    {
	SV*	self = ST(0)
;
	const char*	method_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	invocant = (const char *)SvPV_nolen(ST(2))
;
	AV*	args_av;
#line 1546 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char** args;
        int num_args;
        int i;
#line 3086 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(3);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    args_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::call_method",
				"args_av");
		}
	} STMT_END
;
#line 1551 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_args = av_len(args_av) + 1;

        if (num_args > 0) {
            Newxz(args, num_args, const char*);
            for (i = 0; i < num_args; i++) {
                SV** elem = av_fetch(args_av, i, 0);
                if (elem && SvOK(*elem)) {
                    args[i] = SvPV_nolen(*elem);
                } else {
                    args[i] = "NULL";
                }
            }
            xs_jit_call_method(aTHX_ b, method_name, invocant, args, num_args);
            Safefree(args);
        } else {
            xs_jit_call_method(aTHX_ b, method_name, invocant, NULL, 0);
        }

        RETVAL = SvREFCNT_inc(self);
#line 3123 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_trigger); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_rw_accessor_trigger)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, trigger_method");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	const char*	trigger_method = (const char *)SvPV_nolen(ST(4))
;
#line 1582 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3150 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1584 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_rw_accessor_trigger(aTHX_ b, func_name, attr_name, attr_len, trigger_method);
        RETVAL = SvREFCNT_inc(self);
#line 3156 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_accessor_lazy_builder); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_accessor_lazy_builder)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, builder_method");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	const char*	builder_method = (const char *)SvPV_nolen(ST(4))
;
#line 1598 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3183 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1600 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_accessor_lazy_builder(aTHX_ b, func_name, attr_name, attr_len, builder_method);
        RETVAL = SvREFCNT_inc(self);
#line 3189 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_destroy_with_demolish); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_destroy_with_demolish)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, func_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
#line 1611 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3210 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1613 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_destroy_with_demolish(aTHX_ b, func_name);
        RETVAL = SvREFCNT_inc(self);
#line 3216 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_do_loop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_do_loop)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1623 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3235 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1625 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_do(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 3241 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_end_do_while); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_end_do_while)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, condition");
    {
	SV*	self = ST(0)
;
	const char*	condition = (const char *)SvPV_nolen(ST(1))
;
#line 1636 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3262 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1638 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_end_do_while(aTHX_ b, condition);
        RETVAL = SvREFCNT_inc(self);
#line 3268 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_if_list_context); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_if_list_context)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1648 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3287 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1650 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_if_list_context(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 3293 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_if_scalar_context); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_if_scalar_context)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1660 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3312 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1662 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_if_scalar_context(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 3318 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_extend_stack); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_extend_stack)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, count_expr");
    {
	SV*	self = ST(0)
;
	const char*	count_expr = (const char *)SvPV_nolen(ST(1))
;
#line 1673 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3339 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1675 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_extend_stack(aTHX_ b, count_expr);
        RETVAL = SvREFCNT_inc(self);
#line 3345 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_return_list); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_return_list)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, values_av");
    {
	SV*	self = ST(0)
;
	AV*	values_av;
#line 1686 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char** values;
        int num_values;
        int i;
#line 3368 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(1);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    values_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::return_list",
				"values_av");
		}
	} STMT_END
;
#line 1691 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        num_values = av_len(values_av) + 1;

        if (num_values > 0) {
            Newxz(values, num_values, const char*);
            for (i = 0; i < num_values; i++) {
                SV** elem = av_fetch(values_av, i, 0);
                if (elem && SvOK(*elem)) {
                    values[i] = SvPV_nolen(*elem);
                } else {
                    values[i] = "&PL_sv_undef";
                }
            }
            xs_jit_return_list(aTHX_ b, values, num_values);
            Safefree(values);
        } else {
            xs_jit_return_list(aTHX_ b, NULL, 0);
        }

        RETVAL = SvREFCNT_inc(self);
#line 3405 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_declare_ternary); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_declare_ternary)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "self, type, name, cond, true_expr, false_expr");
    {
	SV*	self = ST(0)
;
	const char*	type = (const char *)SvPV_nolen(ST(1))
;
	const char*	name = (const char *)SvPV_nolen(ST(2))
;
	const char*	cond = (const char *)SvPV_nolen(ST(3))
;
	const char*	true_expr = (const char *)SvPV_nolen(ST(4))
;
	const char*	false_expr = (const char *)SvPV_nolen(ST(5))
;
#line 1723 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3434 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1725 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_declare_ternary(aTHX_ b, type, name, cond, true_expr, false_expr);
        RETVAL = SvREFCNT_inc(self);
#line 3440 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_assign_ternary); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_assign_ternary)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, var, cond, true_expr, false_expr");
    {
	SV*	self = ST(0)
;
	const char*	var = (const char *)SvPV_nolen(ST(1))
;
	const char*	cond = (const char *)SvPV_nolen(ST(2))
;
	const char*	true_expr = (const char *)SvPV_nolen(ST(3))
;
	const char*	false_expr = (const char *)SvPV_nolen(ST(4))
;
#line 1739 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3467 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1741 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_assign_ternary(aTHX_ b, var, cond, true_expr, false_expr);
        RETVAL = SvREFCNT_inc(self);
#line 3473 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_delegate_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_delegate_method)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, target_method");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	const char*	target_method = (const char *)SvPV_nolen(ST(4))
;
#line 1755 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3500 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1757 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_delegate_method(aTHX_ b, func_name, attr_name, attr_len, target_method);
        RETVAL = SvREFCNT_inc(self);
#line 3506 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_singleton_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_singleton_accessor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, class_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	class_name = (const char *)SvPV_nolen(ST(2))
;
#line 1769 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3529 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1771 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_singleton_accessor(aTHX_ b, func_name, class_name);
        RETVAL = SvREFCNT_inc(self);
#line 3535 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_singleton_reset); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_singleton_reset)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, class_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	class_name = (const char *)SvPV_nolen(ST(2))
;
#line 1783 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3558 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1785 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_singleton_reset(aTHX_ b, func_name, class_name);
        RETVAL = SvREFCNT_inc(self);
#line 3564 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_registry_add); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_registry_add)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, registry_attr");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	SV*	registry_attr = ST(2)
;
#line 1797 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* attr_str;
        STRLEN attr_len;
#line 3589 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1801 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_str = SvPV(registry_attr, attr_len);
        xs_jit_registry_add(aTHX_ b, func_name, attr_str, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 3596 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_registry_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_registry_get)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, registry_attr");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	SV*	registry_attr = ST(2)
;
#line 1814 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* attr_str;
        STRLEN attr_len;
#line 3621 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1818 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_str = SvPV(registry_attr, attr_len);
        xs_jit_registry_get(aTHX_ b, func_name, attr_str, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 3628 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_registry_remove); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_registry_remove)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, registry_attr");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	SV*	registry_attr = ST(2)
;
#line 1831 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* attr_str;
        STRLEN attr_len;
#line 3653 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1835 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_str = SvPV(registry_attr, attr_len);
        xs_jit_registry_remove(aTHX_ b, func_name, attr_str, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 3660 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_registry_all); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_registry_all)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, registry_attr");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	SV*	registry_attr = ST(2)
;
#line 1848 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* attr_str;
        STRLEN attr_len;
#line 3685 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1852 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        attr_str = SvPV(registry_attr, attr_len);
        xs_jit_registry_all(aTHX_ b, func_name, attr_str, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 3692 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_wrap_before); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_wrap_before)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, orig_name, before_cv_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	orig_name = (const char *)SvPV_nolen(ST(2))
;
	const char*	before_cv_name = (const char *)SvPV_nolen(ST(3))
;
#line 1866 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3717 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1868 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_wrap_before(aTHX_ b, func_name, orig_name, before_cv_name);
        RETVAL = SvREFCNT_inc(self);
#line 3723 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_wrap_after); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_wrap_after)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, orig_name, after_cv_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	orig_name = (const char *)SvPV_nolen(ST(2))
;
	const char*	after_cv_name = (const char *)SvPV_nolen(ST(3))
;
#line 1881 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3748 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1883 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_wrap_after(aTHX_ b, func_name, orig_name, after_cv_name);
        RETVAL = SvREFCNT_inc(self);
#line 3754 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_wrap_around); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_wrap_around)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, orig_name, around_cv_name");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	orig_name = (const char *)SvPV_nolen(ST(2))
;
	const char*	around_cv_name = (const char *)SvPV_nolen(ST(3))
;
#line 1896 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3779 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1898 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_wrap_around(aTHX_ b, func_name, orig_name, around_cv_name);
        RETVAL = SvREFCNT_inc(self);
#line 3785 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_op_ro_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_op_ro_accessor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, slot");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
#line 1910 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3808 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1912 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_op_ro_accessor(aTHX_ b, func_name, slot);
        RETVAL = SvREFCNT_inc(self);
#line 3814 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_op_rw_accessor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_op_rw_accessor)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, slot");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
#line 1924 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3837 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1926 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_op_rw_accessor(aTHX_ b, func_name, slot);
        RETVAL = SvREFCNT_inc(self);
#line 3843 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_inline_init); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_inline_init)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1935 "lib/XS/JIT/Builder.xs"
        xs_jit_inline_init(aTHX);
#line 3860 "lib/XS/JIT/Builder.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_XS__JIT__Builder_inline_register); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_inline_register)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "cv, type, slot, ...");
    {
	CV*	cv;
	int	type = (int)SvIV(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
#line 1943 "lib/XS/JIT/Builder.xs"
        const char* key = NULL;
        STRLEN key_len = 0;
#line 3881 "lib/XS/JIT/Builder.c"
	int	RETVAL;
	dXSTARG;

	STMT_START {
                HV *st;
                GV *gvp;
		SV * const xsub_tmp_sv = ST(0);
		SvGETMAGIC(xsub_tmp_sv);
                cv = sv_2cv(xsub_tmp_sv, &st, &gvp, 0);
		if (!cv) {
		    Perl_croak_nocontext("%s: %s is not a CODE reference",
				"XS::JIT::Builder::inline_register",
				"cv");
		}
	} STMT_END
;
#line 1946 "lib/XS/JIT/Builder.xs"
        /* Optional key for hash-based accessors */
        if (items > 3) {
            key = SvPV(ST(3), key_len);
        }
        RETVAL = xs_jit_inline_register(aTHX_ cv, (XS_JIT_InlineType)type, slot, key, key_len);
#line 3904 "lib/XS/JIT/Builder.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_inline_get_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_inline_get_type)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "cv");
    {
	CV*	cv;
	int	RETVAL;
	dXSTARG;

	STMT_START {
                HV *st;
                GV *gvp;
		SV * const xsub_tmp_sv = ST(0);
		SvGETMAGIC(xsub_tmp_sv);
                cv = sv_2cv(xsub_tmp_sv, &st, &gvp, 0);
		if (!cv) {
		    Perl_croak_nocontext("%s: %s is not a CODE reference",
				"XS::JIT::Builder::inline_get_type",
				"cv");
		}
	} STMT_END
;
#line 1958 "lib/XS/JIT/Builder.xs"
        RETVAL = (int)xs_jit_inline_get_type(aTHX_ cv);
#line 3938 "lib/XS/JIT/Builder.c"
	TARGi((IV)RETVAL, 1);
	ST(0) = TARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_start); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_start)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 1971 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3959 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1973 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_start(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 3965 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_end); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_end)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1983 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 3984 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1985 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_end(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 3990 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_dsp); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_dsp)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 1995 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4009 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 1997 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_dsp(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4015 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_get_self); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_get_self)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2007 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4034 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2009 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_get_self(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4040 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_pop_self); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_pop_self)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2019 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4059 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2021 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_pop_self(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4065 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_pop_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_pop_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 2032 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4086 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2034 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_pop_sv(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 4092 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_pop_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_pop_nv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 2045 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4113 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2047 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_pop_nv(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 4119 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_pop_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_pop_iv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 2058 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4140 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2060 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_pop_iv(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 4146 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_get_slots); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_get_slots)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2070 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4165 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2072 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_get_slots(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4171 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_slot); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_slot)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, slot");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
#line 2084 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4194 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2086 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_slot(aTHX_ b, name, slot);
        RETVAL = SvREFCNT_inc(self);
#line 4200 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_return_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_return_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, sv_expr");
    {
	SV*	self = ST(0)
;
	const char*	sv_expr = (const char *)SvPV_nolen(ST(1))
;
#line 2097 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4221 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2099 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_return_sv(aTHX_ b, sv_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4227 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_return_nv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_return_nv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, nv_expr");
    {
	SV*	self = ST(0)
;
	const char*	nv_expr = (const char *)SvPV_nolen(ST(1))
;
#line 2110 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4248 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2112 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_return_nv(aTHX_ b, nv_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4254 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_return_iv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_return_iv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, iv_expr");
    {
	SV*	self = ST(0)
;
	const char*	iv_expr = (const char *)SvPV_nolen(ST(1))
;
#line 2123 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4275 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2125 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_return_iv(aTHX_ b, iv_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4281 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_return_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_return_pv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, pv_expr");
    {
	SV*	self = ST(0)
;
	const char*	pv_expr = (const char *)SvPV_nolen(ST(1))
;
#line 2136 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4302 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2138 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_return_pv(aTHX_ b, pv_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4308 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_pp_return); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_pp_return)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2148 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4327 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2150 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_pp_return(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4333 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_start); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_start)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, name");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
#line 2165 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4354 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2167 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_start(aTHX_ b, name);
        RETVAL = SvREFCNT_inc(self);
#line 4360 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_end); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_end)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2177 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4379 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2179 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_end(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4385 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_preamble); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_preamble)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2189 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4404 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2191 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_preamble(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4410 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_build_unop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_build_unop)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, pp_func, targ_expr");
    {
	SV*	self = ST(0)
;
	const char*	pp_func = (const char *)SvPV_nolen(ST(1))
;
	const char*	targ_expr = (const char *)SvPV_nolen(ST(2))
;
#line 2203 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4433 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2205 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_build_unop(aTHX_ b, pp_func, targ_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4439 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_build_binop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_build_binop)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, pp_func, targ_expr");
    {
	SV*	self = ST(0)
;
	const char*	pp_func = (const char *)SvPV_nolen(ST(1))
;
	const char*	targ_expr = (const char *)SvPV_nolen(ST(2))
;
#line 2217 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4462 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2219 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_build_binop(aTHX_ b, pp_func, targ_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4468 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_ck_fallback); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_ck_fallback)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    {
	SV*	self = ST(0)
;
#line 2229 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4487 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2231 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_ck_fallback(aTHX_ b);
        RETVAL = SvREFCNT_inc(self);
#line 4493 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_xop_declare); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_xop_declare)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, name, pp_func, desc");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	pp_func = (const char *)SvPV_nolen(ST(2))
;
	const char*	desc = (const char *)SvPV_nolen(ST(3))
;
#line 2248 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4518 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2250 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_xop_declare(aTHX_ b, name, pp_func, desc);
        RETVAL = SvREFCNT_inc(self);
#line 4524 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_register_checker); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_register_checker)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, cv_expr, ck_func, ckobj_expr");
    {
	SV*	self = ST(0)
;
	const char*	cv_expr = (const char *)SvPV_nolen(ST(1))
;
	const char*	ck_func = (const char *)SvPV_nolen(ST(2))
;
	const char*	ckobj_expr = (const char *)SvPV_nolen(ST(3))
;
#line 2263 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4549 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2265 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_register_checker(aTHX_ b, cv_expr, ck_func, ckobj_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4555 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_direct); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_direct)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, result_var, av_expr");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	av_expr = (const char *)SvPV_nolen(ST(2))
;
#line 2281 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4578 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2283 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_direct(aTHX_ b, result_var, av_expr);
        RETVAL = SvREFCNT_inc(self);
#line 4584 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_slot_read); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_slot_read)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, result_var, slots_var, slot");
    {
	SV*	self = ST(0)
;
	const char*	result_var = (const char *)SvPV_nolen(ST(1))
;
	const char*	slots_var = (const char *)SvPV_nolen(ST(2))
;
	IV	slot = (IV)SvIV(ST(3))
;
#line 2296 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4609 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2298 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_slot_read(aTHX_ b, result_var, slots_var, slot);
        RETVAL = SvREFCNT_inc(self);
#line 4615 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_av_slot_write); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_av_slot_write)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, slots_var, slot, value");
    {
	SV*	self = ST(0)
;
	const char*	slots_var = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
	const char*	value = (const char *)SvPV_nolen(ST(3))
;
#line 2311 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4640 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2313 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_av_slot_write(aTHX_ b, slots_var, slot, value);
        RETVAL = SvREFCNT_inc(self);
#line 4646 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_check_value_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_check_value_type)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "self, sv, type, ...");
    {
	SV*	self = ST(0)
;
	const char*	sv = (const char *)SvPV_nolen(ST(1))
;
	IV	type = (IV)SvIV(ST(2))
;
#line 2329 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        const char* classname = NULL;
        const char* error_msg = "Type check failed";
#line 4671 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2333 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        if (items > 3) {
            classname = SvPV_nolen(ST(3));
        }
        if (items > 4) {
            error_msg = SvPV_nolen(ST(4));
        }
        xs_jit_check_value_type(aTHX_ b, sv, (XS_JIT_TypeCheck)type, classname, error_msg);
        RETVAL = SvREFCNT_inc(self);
#line 4683 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_lazy_init_dor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_lazy_init_dor)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, default_expr, is_mortal");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	const char*	default_expr = (const char *)SvPV_nolen(ST(4))
;
	int	is_mortal = (int)SvIV(ST(5))
;
#line 2358 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4712 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2360 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_lazy_init_dor(aTHX_ b, func_name, attr_name, attr_len, default_expr, is_mortal);
        RETVAL = SvREFCNT_inc(self);
#line 4718 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_lazy_init_or); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_lazy_init_or)
{
    dVAR; dXSARGS;
    if (items != 6)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len, default_expr, is_mortal");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
	const char*	default_expr = (const char *)SvPV_nolen(ST(4))
;
	int	is_mortal = (int)SvIV(ST(5))
;
#line 2375 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4747 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2377 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_lazy_init_or(aTHX_ b, func_name, attr_name, attr_len, default_expr, is_mortal);
        RETVAL = SvREFCNT_inc(self);
#line 4753 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_slot_lazy_init_dor); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_slot_lazy_init_dor)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, slot, default_expr, is_mortal");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
	const char*	default_expr = (const char *)SvPV_nolen(ST(3))
;
	int	is_mortal = (int)SvIV(ST(4))
;
#line 2391 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4780 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2393 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_slot_lazy_init_dor(aTHX_ b, func_name, slot, default_expr, is_mortal);
        RETVAL = SvREFCNT_inc(self);
#line 4786 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_slot_lazy_init_or); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_slot_lazy_init_or)
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "self, func_name, slot, default_expr, is_mortal");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
	const char*	default_expr = (const char *)SvPV_nolen(ST(3))
;
	int	is_mortal = (int)SvIV(ST(4))
;
#line 2407 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4813 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2409 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_slot_lazy_init_or(aTHX_ b, func_name, slot, default_expr, is_mortal);
        RETVAL = SvREFCNT_inc(self);
#line 4819 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_setter_chain); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_setter_chain)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2426 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4844 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2428 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_setter_chain(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 4850 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_slot_setter_chain); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_slot_setter_chain)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, slot");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	IV	slot = (IV)SvIV(ST(2))
;
#line 2440 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4873 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2442 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_slot_setter_chain(aTHX_ b, func_name, slot);
        RETVAL = SvREFCNT_inc(self);
#line 4879 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_setter_return_value); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_setter_return_value)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2455 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4904 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2457 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_setter_return_value(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 4910 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_push); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_push)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2474 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4935 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2476 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_push(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 4941 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_pop); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_pop)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2489 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4966 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2491 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_pop(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 4972 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_shift); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_shift)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2504 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 4997 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2506 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_shift(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5003 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_unshift); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_unshift)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2519 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5028 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2521 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_unshift(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5034 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_count); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_count)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2534 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5059 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2536 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_count(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5065 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_clear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_clear)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2549 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5090 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2551 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_clear(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5096 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_keys); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_keys)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2568 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5121 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2570 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_keys(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5127 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_values); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_values)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2583 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5152 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2585 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_values(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5158 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_delete); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_delete)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2598 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5183 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2600 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_delete(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5189 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_attr_hash_clear); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_attr_hash_clear)
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "self, func_name, attr_name, attr_len");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	attr_name = (const char *)SvPV_nolen(ST(2))
;
	STRLEN	attr_len = (STRLEN)SvUV(ST(3))
;
#line 2613 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
#line 5214 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2615 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        xs_jit_attr_hash_clear(aTHX_ b, func_name, attr_name, attr_len);
        RETVAL = SvREFCNT_inc(self);
#line 5220 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_conditional); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_conditional)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "self, struct_hv");
    {
	SV*	self = ST(0)
;
	HV*	struct_hv;
#line 2626 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_Conditional cond;
        XS_JIT_Given given_struct;
        SV** val;
        int is_given = 0;
#line 5244 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(1);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVHV){
		    struct_hv = (HV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not a HASH reference",
				"XS::JIT::Builder::conditional",
				"struct_hv");
		}
	} STMT_END
;
#line 2632 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        memset(&cond, 0, sizeof(cond));
        memset(&given_struct, 0, sizeof(given_struct));

        /* Check if this is a 'given' structure */
        val = hv_fetchs(struct_hv, "given", 0);
        if (val && SvOK(*val) && SvROK(*val) && SvTYPE(SvRV(*val)) == SVt_PVHV) {
            is_given = 1;
            HV* given_hv = (HV*)SvRV(*val);
            SV** key_val;
            SV** when_val;
            SV** default_val;

            /* Get key */
            key_val = hv_fetchs(given_hv, "key", 0);
            if (key_val && SvOK(*key_val)) {
                given_struct.key = SvPV_nolen(*key_val);
            }

            /* Parse 'when' - can be hash or array */
            when_val = hv_fetchs(given_hv, "when", 0);
            if (when_val && SvOK(*when_val) && SvROK(*when_val)) {
                if (SvTYPE(SvRV(*when_val)) == SVt_PVHV) {
                    /* Hash-style when: { val1 => {...}, val2 => {...}, default => {...} } */
                    HV* when_hv = (HV*)SvRV(*when_val);
                    I32 num_keys = hv_iterinit(when_hv);
                    HE* entry;
                    int i = 0;

                    /* Count non-default keys */
                    given_struct.num_when = 0;
                    hv_iterinit(when_hv);
                    while ((entry = hv_iternext(when_hv))) {
                        STRLEN klen;
                        const char* key = HePV(entry, klen);
                        if (!strEQ(key, "default")) {
                            given_struct.num_when++;
                        }
                    }

                    if (given_struct.num_when > 0) {
                        Newxz(given_struct.when_clauses, given_struct.num_when, XS_JIT_Clause*);

                        hv_iterinit(when_hv);
                        while ((entry = hv_iternext(when_hv))) {
                            STRLEN klen;
                            const char* key = HePV(entry, klen);
                            SV* val = HeVAL(entry);

                            if (strEQ(key, "default")) {
                                /* Handle default separately */
                                if (SvROK(val) && SvTYPE(SvRV(val)) == SVt_PVHV) {
                                    given_struct.default_actions = xs_jit_parse_actions(aTHX_ val, &given_struct.num_default_actions);
                                }
                            } else {
                                /* Create a clause for this when value */
                                XS_JIT_Clause* clause;
                                Newxz(clause, 1, XS_JIT_Clause);
                                clause->key = given_struct.key;
                                clause->expr_type = XS_JIT_EXPR_EQ;
                                clause->expr_value = key;
                                clause->expr_value_len = klen;

                                /* Parse actions from value */
                                if (SvROK(val) && SvTYPE(SvRV(val)) == SVt_PVHV) {
                                    clause->actions = xs_jit_parse_actions(aTHX_ val, &clause->num_actions);
                                }

                                given_struct.when_clauses[i++] = clause;
                            }
                        }
                    }
                }
                else if (SvTYPE(SvRV(*when_val)) == SVt_PVAV) {
                    /* Array-style when: [ { m => 'foo', then => {...} }, ... ] */
                    AV* when_av = (AV*)SvRV(*when_val);
                    I32 len = av_len(when_av) + 1;
                    int i;

                    if (len > 0) {
                        Newxz(given_struct.when_clauses, len, XS_JIT_Clause*);

                        for (i = 0; i < len; i++) {
                            SV** elem = av_fetch(when_av, i, 0);
                            if (elem && SvOK(*elem) && SvROK(*elem) && SvTYPE(SvRV(*elem)) == SVt_PVHV) {
                                given_struct.when_clauses[given_struct.num_when] =
                                    xs_jit_parse_clause(aTHX_ (HV*)SvRV(*elem));
                                given_struct.num_when++;
                            }
                        }
                    }
                }
            }

            /* Parse default if not already done */
            default_val = hv_fetchs(given_hv, "default", 0);
            if (default_val && SvOK(*default_val) && given_struct.num_default_actions == 0) {
                given_struct.default_actions = xs_jit_parse_actions(aTHX_ *default_val, &given_struct.num_default_actions);
            }

            xs_jit_given(aTHX_ b, &given_struct);
            xs_jit_free_given(aTHX_ &given_struct);
        }
        else {
            /* Standard if/elsif/else structure */

            /* Parse 'if' clause */
            val = hv_fetchs(struct_hv, "if", 0);
            if (val && SvOK(*val) && SvROK(*val) && SvTYPE(SvRV(*val)) == SVt_PVHV) {
                cond.if_clause = xs_jit_parse_clause(aTHX_ (HV*)SvRV(*val));
            }

            /* Parse 'elsif' - can be single hash or array */
            val = hv_fetchs(struct_hv, "elsif", 0);
            if (val && SvOK(*val) && SvROK(*val)) {
                if (SvTYPE(SvRV(*val)) == SVt_PVHV) {
                    /* Single elsif */
                    Newxz(cond.elsif_clauses, 1, XS_JIT_Clause*);
                    cond.elsif_clauses[0] = xs_jit_parse_clause(aTHX_ (HV*)SvRV(*val));
                    cond.num_elsif = 1;
                }
                else if (SvTYPE(SvRV(*val)) == SVt_PVAV) {
                    /* Array of elsif */
                    AV* elsif_av = (AV*)SvRV(*val);
                    I32 len = av_len(elsif_av) + 1;
                    int i;

                    if (len > 0) {
                        Newxz(cond.elsif_clauses, len, XS_JIT_Clause*);

                        for (i = 0; i < len; i++) {
                            SV** elem = av_fetch(elsif_av, i, 0);
                            if (elem && SvOK(*elem) && SvROK(*elem) && SvTYPE(SvRV(*elem)) == SVt_PVHV) {
                                cond.elsif_clauses[cond.num_elsif] =
                                    xs_jit_parse_clause(aTHX_ (HV*)SvRV(*elem));
                                cond.num_elsif++;
                            }
                        }
                    }
                }
            }

            /* Parse 'else' */
            val = hv_fetchs(struct_hv, "else", 0);
            if (val && SvOK(*val) && SvROK(*val) && SvTYPE(SvRV(*val)) == SVt_PVHV) {
                HV* else_hv = (HV*)SvRV(*val);
                SV** then_val = hv_fetchs(else_hv, "then", 0);
                if (then_val && SvOK(*then_val)) {
                    cond.else_actions = xs_jit_parse_actions(aTHX_ *then_val, &cond.num_else_actions);
                }
            }

            xs_jit_conditional(aTHX_ b, &cond);
            xs_jit_free_conditional(aTHX_ &cond);
        }

        RETVAL = SvREFCNT_inc(self);
#line 5418 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_switch); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_switch)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "self, key, cases_av, ...");
    {
	SV*	self = ST(0)
;
	const char*	key = (const char *)SvPV_nolen(ST(1))
;
	AV*	cases_av;
#line 2798 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_Switch sw;
        I32 cases_len;
        I32 i;
        SV* default_sv = NULL;
#line 5444 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    cases_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::switch",
				"cases_av");
		}
	} STMT_END
;
#line 2804 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        memset(&sw, 0, sizeof(sw));

        sw.key = key;

        /* Check for optional default argument */
        if (items > 3 && SvOK(ST(3))) {
            default_sv = ST(3);
        }

        /* Parse cases array */
        cases_len = av_len(cases_av) + 1;
        if (cases_len > 0) {
            Newxz(sw.cases, cases_len, XS_JIT_Clause*);

            for (i = 0; i < cases_len; i++) {
                SV** elem = av_fetch(cases_av, i, 0);
                if (elem && SvOK(*elem) && SvROK(*elem) && SvTYPE(SvRV(*elem)) == SVt_PVHV) {
                    HV* case_hv = (HV*)SvRV(*elem);
                    XS_JIT_Clause* clause;

                    /* Parse the clause and set the key */
                    clause = xs_jit_parse_clause(aTHX_ case_hv);
                    clause->key = key;
                    sw.cases[sw.num_cases] = clause;
                    sw.num_cases++;
                }
            }
        }

        /* Parse default actions if provided */
        if (default_sv && SvROK(default_sv) && SvTYPE(SvRV(default_sv)) == SVt_PVHV) {
            sw.default_actions = xs_jit_parse_actions(aTHX_ default_sv, &sw.num_default_actions);
        }

        xs_jit_switch(aTHX_ b, &sw);
        xs_jit_free_switch(aTHX_ &sw);

        RETVAL = SvREFCNT_inc(self);
#line 5500 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_enum); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_enum)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "self, name_sv, values_av, ...");
    {
	SV*	self = ST(0)
;
	SV*	name_sv = ST(1)
;
	AV*	values_av;
#line 2852 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_EnumValue* values = NULL;
        XS_JIT_EnumOpts opts;
        XS_JIT_EnumOpts* opts_ptr = NULL;
        I32 num_values;
        I32 i;
        const char* name;
#line 5528 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;

	STMT_START {
		SV* const xsub_tmp_sv = ST(2);
		SvGETMAGIC(xsub_tmp_sv);
		if (SvROK(xsub_tmp_sv) && SvTYPE(SvRV(xsub_tmp_sv)) == SVt_PVAV){
		    values_av = (AV*)SvRV(xsub_tmp_sv);
		}
		else{
		    Perl_croak_nocontext("%s: %s is not an ARRAY reference",
				"XS::JIT::Builder::enum",
				"values_av");
		}
	} STMT_END
;
#line 2860 "lib/XS/JIT/Builder.xs"
        if (!SvOK(name_sv) || !SvPOK(name_sv) || SvCUR(name_sv) == 0) {
            croak("enum requires a name");
        }
        name = SvPV_nolen(name_sv);

        b = get_builder(aTHX_ self);

        memset(&opts, 0, sizeof(opts));

        /* Parse values array */
        num_values = av_len(values_av) + 1;
        if (num_values <= 0) {
            croak("enum requires a non-empty values array");
        }

        Newxz(values, num_values, XS_JIT_EnumValue);
        for (i = 0; i < num_values; i++) {
            SV** elem = av_fetch(values_av, i, 0);
            if (elem && SvOK(*elem)) {
                STRLEN len;
                const char* pv = SvPV(*elem, len);
                values[i].name = pv;
                values[i].name_len = len;
            }
        }

        /* Check for optional opts hash */
        if (items > 3 && SvOK(ST(3)) && SvROK(ST(3)) && SvTYPE(SvRV(ST(3))) == SVt_PVHV) {
            HV* opts_hv = (HV*)SvRV(ST(3));
            SV** start_sv = hv_fetchs(opts_hv, "start", 0);
            SV** prefix_sv = hv_fetchs(opts_hv, "prefix", 0);

            if (start_sv && SvOK(*start_sv)) {
                opts.start = SvIV(*start_sv);
            }
            if (prefix_sv && SvOK(*prefix_sv)) {
                opts.prefix = SvPV(*prefix_sv, opts.prefix_len);
            }
            opts_ptr = &opts;
        }

        xs_jit_enum(aTHX_ b, name, values, num_values, opts_ptr);

        Safefree(values);

        RETVAL = SvREFCNT_inc(self);
#line 5591 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_memoize); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_memoize)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, func_name_sv, ...");
    {
	SV*	self = ST(0)
;
	SV*	func_name_sv = ST(1)
;
#line 2914 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_MemoizeOpts opts;
        XS_JIT_MemoizeOpts* opts_ptr = NULL;
        const char* func_name;
#line 5615 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2919 "lib/XS/JIT/Builder.xs"
        if (!SvOK(func_name_sv) || !SvPOK(func_name_sv) || SvCUR(func_name_sv) == 0) {
            croak("memoize requires a function name");
        }
        func_name = SvPV_nolen(func_name_sv);
        b = get_builder(aTHX_ self);

        memset(&opts, 0, sizeof(opts));

        /* Check for optional opts hash */
        if (items > 2 && SvOK(ST(2)) && SvROK(ST(2)) && SvTYPE(SvRV(ST(2))) == SVt_PVHV) {
            HV* opts_hv = (HV*)SvRV(ST(2));
            SV** cache_sv = hv_fetchs(opts_hv, "cache", 0);
            SV** ttl_sv = hv_fetchs(opts_hv, "ttl", 0);

            if (cache_sv && SvOK(*cache_sv)) {
                opts.cache_attr = SvPV(*cache_sv, opts.cache_attr_len);
            }
            if (ttl_sv && SvOK(*ttl_sv)) {
                opts.ttl = SvIV(*ttl_sv);
            }
            opts_ptr = &opts;
        }

        xs_jit_memoize(aTHX_ b, func_name, opts_ptr);

        RETVAL = SvREFCNT_inc(self);
#line 5644 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_enum_functions); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_enum_functions)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, name, package");
    {
	SV*	self = ST(0)
;
	const char*	name = (const char *)SvPV_nolen(ST(1))
;
	const char*	package = (const char *)SvPV_nolen(ST(2))
;
#line 2954 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        HV* result;
#line 5668 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2957 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        result = xs_jit_enum_functions(aTHX_ b, name, package);
        RETVAL = newRV_noinc((SV*)result);
#line 5674 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_memoize_functions); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_memoize_functions)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "self, func_name, package");
    {
	SV*	self = ST(0)
;
	const char*	func_name = (const char *)SvPV_nolen(ST(1))
;
	const char*	package = (const char *)SvPV_nolen(ST(2))
;
#line 2969 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        HV* result;
#line 5698 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2972 "lib/XS/JIT/Builder.xs"
        b = get_builder(aTHX_ self);
        result = xs_jit_memoize_functions(aTHX_ b, func_name, package);
        RETVAL = newRV_noinc((SV*)result);
#line 5704 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_role); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_role)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, role_name_sv, ...");
    {
	SV*	self = ST(0)
;
	SV*	role_name_sv = ST(1)
;
#line 2983 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        XS_JIT_RoleType role_type;
        XS_JIT_RoleOpts opts;
        XS_JIT_RoleOpts* opts_ptr = NULL;
        const char* role_name;
#line 5729 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 2989 "lib/XS/JIT/Builder.xs"
        if (!SvOK(role_name_sv) || !SvPOK(role_name_sv) || SvCUR(role_name_sv) == 0) {
            croak("role requires a role name");
        }
        role_name = SvPV_nolen(role_name_sv);
        b = get_builder(aTHX_ self);

        /* Map role name to type */
        if (strEQ(role_name, "Comparable")) {
            role_type = XS_JIT_ROLE_COMPARABLE;
        } else if (strEQ(role_name, "Cloneable")) {
            role_type = XS_JIT_ROLE_CLONEABLE;
        } else if (strEQ(role_name, "Serializable")) {
            role_type = XS_JIT_ROLE_SERIALIZABLE;
        } else if (strEQ(role_name, "Observable")) {
            role_type = XS_JIT_ROLE_OBSERVABLE;
        } else {
            croak("Unknown role: '%s'. Valid roles: Comparable, Cloneable, Serializable, Observable", role_name);
        }

        memset(&opts, 0, sizeof(opts));

        /* Check for optional opts hash */
        if (items > 2 && SvOK(ST(2)) && SvROK(ST(2)) && SvTYPE(SvRV(ST(2))) == SVt_PVHV) {
            HV* opts_hv = (HV*)SvRV(ST(2));
            SV** compare_key_sv = hv_fetchs(opts_hv, "compare_key", 0);
            SV** observers_attr_sv = hv_fetchs(opts_hv, "observers_attr", 0);

            if (compare_key_sv && SvOK(*compare_key_sv)) {
                opts.compare_key = SvPV(*compare_key_sv, opts.compare_key_len);
            }
            if (observers_attr_sv && SvOK(*observers_attr_sv)) {
                opts.observers_attr = SvPV(*observers_attr_sv, opts.observers_attr_len);
            }
            opts_ptr = &opts;
        }

        xs_jit_role(aTHX_ b, role_type, opts_ptr);
        RETVAL = SvREFCNT_inc(self);
#line 5770 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_XS__JIT__Builder_with_roles); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_XS__JIT__Builder_with_roles)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "self, roles_av, ...");
    {
	SV*	self = ST(0)
;
	SV*	roles_av = ST(1)
;
#line 3035 "lib/XS/JIT/Builder.xs"
        XS_JIT_Builder* b;
        AV* roles;
        SSize_t i, len;
        HV* opts_hv = NULL;
#line 5794 "lib/XS/JIT/Builder.c"
	SV *	RETVAL;
#line 3040 "lib/XS/JIT/Builder.xs"
        if (!SvROK(roles_av) || SvTYPE(SvRV(roles_av)) != SVt_PVAV) {
            croak("with_roles requires an arrayref of role names");
        }
        b = get_builder(aTHX_ self);
        roles = (AV*)SvRV(roles_av);
        len = av_len(roles) + 1;

        /* Check for optional opts hash */
        if (items > 2 && SvOK(ST(2)) && SvROK(ST(2)) && SvTYPE(SvRV(ST(2))) == SVt_PVHV) {
            opts_hv = (HV*)SvRV(ST(2));
        }

        for (i = 0; i < len; i++) {
            SV** role_svp = av_fetch(roles, i, 0);
            if (role_svp && SvOK(*role_svp)) {
                const char* role_name = SvPV_nolen(*role_svp);
                XS_JIT_RoleType role_type;
                XS_JIT_RoleOpts opts;
                XS_JIT_RoleOpts* opts_ptr = NULL;

                /* Map role name to type */
                if (strEQ(role_name, "Comparable")) {
                    role_type = XS_JIT_ROLE_COMPARABLE;
                } else if (strEQ(role_name, "Cloneable")) {
                    role_type = XS_JIT_ROLE_CLONEABLE;
                } else if (strEQ(role_name, "Serializable")) {
                    role_type = XS_JIT_ROLE_SERIALIZABLE;
                } else if (strEQ(role_name, "Observable")) {
                    role_type = XS_JIT_ROLE_OBSERVABLE;
                } else {
                    croak("Unknown role: '%s'. Valid roles: Comparable, Cloneable, Serializable, Observable", role_name);
                }

                memset(&opts, 0, sizeof(opts));

                /* Apply opts if provided */
                if (opts_hv) {
                    SV** compare_key_sv = hv_fetchs(opts_hv, "compare_key", 0);
                    SV** observers_attr_sv = hv_fetchs(opts_hv, "observers_attr", 0);

                    if (compare_key_sv && SvOK(*compare_key_sv)) {
                        opts.compare_key = SvPV(*compare_key_sv, opts.compare_key_len);
                    }
                    if (observers_attr_sv && SvOK(*observers_attr_sv)) {
                        opts.observers_attr = SvPV(*observers_attr_sv, opts.observers_attr_len);
                    }
                    opts_ptr = &opts;
                }

                xs_jit_role(aTHX_ b, role_type, opts_ptr);
            }
        }
        RETVAL = SvREFCNT_inc(self);
#line 5850 "lib/XS/JIT/Builder.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}

#ifdef __cplusplus
extern "C" {
#endif
XS_EXTERNAL(boot_XS__JIT__Builder); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_XS__JIT__Builder)
{
#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("XS::JIT::Builder::new", XS_XS__JIT__Builder_new);
        newXS_deffile("XS::JIT::Builder::DESTROY", XS_XS__JIT__Builder_DESTROY);
        newXS_deffile("XS::JIT::Builder::code", XS_XS__JIT__Builder_code);
        newXS_deffile("XS::JIT::Builder::reset", XS_XS__JIT__Builder_reset);
        newXS_deffile("XS::JIT::Builder::line", XS_XS__JIT__Builder_line);
        newXS_deffile("XS::JIT::Builder::raw", XS_XS__JIT__Builder_raw);
        newXS_deffile("XS::JIT::Builder::comment", XS_XS__JIT__Builder_comment);
        newXS_deffile("XS::JIT::Builder::blank", XS_XS__JIT__Builder_blank);
        newXS_deffile("XS::JIT::Builder::indent", XS_XS__JIT__Builder_indent);
        newXS_deffile("XS::JIT::Builder::dedent", XS_XS__JIT__Builder_dedent);
        newXS_deffile("XS::JIT::Builder::block_start", XS_XS__JIT__Builder_block_start);
        newXS_deffile("XS::JIT::Builder::block_end", XS_XS__JIT__Builder_block_end);
        newXS_deffile("XS::JIT::Builder::xs_function", XS_XS__JIT__Builder_xs_function);
        newXS_deffile("XS::JIT::Builder::xs_preamble", XS_XS__JIT__Builder_xs_preamble);
        newXS_deffile("XS::JIT::Builder::xs_end", XS_XS__JIT__Builder_xs_end);
        newXS_deffile("XS::JIT::Builder::xs_return", XS_XS__JIT__Builder_xs_return);
        newXS_deffile("XS::JIT::Builder::xs_return_undef", XS_XS__JIT__Builder_xs_return_undef);
        newXS_deffile("XS::JIT::Builder::return_undef", XS_XS__JIT__Builder_return_undef);
        newXS_deffile("XS::JIT::Builder::croak_usage", XS_XS__JIT__Builder_croak_usage);
        newXS_deffile("XS::JIT::Builder::if", XS_XS__JIT__Builder_if);
        newXS_deffile("XS::JIT::Builder::elsif", XS_XS__JIT__Builder_elsif);
        newXS_deffile("XS::JIT::Builder::else", XS_XS__JIT__Builder_else);
        newXS_deffile("XS::JIT::Builder::endif", XS_XS__JIT__Builder_endif);
        newXS_deffile("XS::JIT::Builder::for", XS_XS__JIT__Builder_for);
        newXS_deffile("XS::JIT::Builder::while", XS_XS__JIT__Builder_while);
        newXS_deffile("XS::JIT::Builder::endloop", XS_XS__JIT__Builder_endloop);
        newXS_deffile("XS::JIT::Builder::endfor", XS_XS__JIT__Builder_endfor);
        newXS_deffile("XS::JIT::Builder::endwhile", XS_XS__JIT__Builder_endwhile);
        newXS_deffile("XS::JIT::Builder::block", XS_XS__JIT__Builder_block);
        newXS_deffile("XS::JIT::Builder::endblock", XS_XS__JIT__Builder_endblock);
        newXS_deffile("XS::JIT::Builder::declare", XS_XS__JIT__Builder_declare);
        newXS_deffile("XS::JIT::Builder::declare_sv", XS_XS__JIT__Builder_declare_sv);
        newXS_deffile("XS::JIT::Builder::declare_hv", XS_XS__JIT__Builder_declare_hv);
        newXS_deffile("XS::JIT::Builder::declare_av", XS_XS__JIT__Builder_declare_av);
        newXS_deffile("XS::JIT::Builder::new_hv", XS_XS__JIT__Builder_new_hv);
        newXS_deffile("XS::JIT::Builder::new_av", XS_XS__JIT__Builder_new_av);
        newXS_deffile("XS::JIT::Builder::declare_int", XS_XS__JIT__Builder_declare_int);
        newXS_deffile("XS::JIT::Builder::declare_iv", XS_XS__JIT__Builder_declare_iv);
        newXS_deffile("XS::JIT::Builder::declare_nv", XS_XS__JIT__Builder_declare_nv);
        newXS_deffile("XS::JIT::Builder::declare_pv", XS_XS__JIT__Builder_declare_pv);
        newXS_deffile("XS::JIT::Builder::assign", XS_XS__JIT__Builder_assign);
        newXS_deffile("XS::JIT::Builder::get_self", XS_XS__JIT__Builder_get_self);
        newXS_deffile("XS::JIT::Builder::get_self_hv", XS_XS__JIT__Builder_get_self_hv);
        newXS_deffile("XS::JIT::Builder::get_self_av", XS_XS__JIT__Builder_get_self_av);
        newXS_deffile("XS::JIT::Builder::hv_fetch", XS_XS__JIT__Builder_hv_fetch);
        newXS_deffile("XS::JIT::Builder::hv_fetch_sv", XS_XS__JIT__Builder_hv_fetch_sv);
        newXS_deffile("XS::JIT::Builder::hv_store", XS_XS__JIT__Builder_hv_store);
        newXS_deffile("XS::JIT::Builder::hv_store_sv", XS_XS__JIT__Builder_hv_store_sv);
        newXS_deffile("XS::JIT::Builder::hv_fetch_return", XS_XS__JIT__Builder_hv_fetch_return);
        newXS_deffile("XS::JIT::Builder::av_fetch", XS_XS__JIT__Builder_av_fetch);
        newXS_deffile("XS::JIT::Builder::av_store", XS_XS__JIT__Builder_av_store);
        newXS_deffile("XS::JIT::Builder::av_push", XS_XS__JIT__Builder_av_push);
        newXS_deffile("XS::JIT::Builder::av_len", XS_XS__JIT__Builder_av_len);
        newXS_deffile("XS::JIT::Builder::new_sv_iv", XS_XS__JIT__Builder_new_sv_iv);
        newXS_deffile("XS::JIT::Builder::new_sv_nv", XS_XS__JIT__Builder_new_sv_nv);
        newXS_deffile("XS::JIT::Builder::new_sv_pv", XS_XS__JIT__Builder_new_sv_pv);
        newXS_deffile("XS::JIT::Builder::mortal", XS_XS__JIT__Builder_mortal);
        newXS_deffile("XS::JIT::Builder::croak", XS_XS__JIT__Builder_croak);
        newXS_deffile("XS::JIT::Builder::warn", XS_XS__JIT__Builder_warn);
        newXS_deffile("XS::JIT::Builder::check_items", XS_XS__JIT__Builder_check_items);
        newXS_deffile("XS::JIT::Builder::check_defined", XS_XS__JIT__Builder_check_defined);
        newXS_deffile("XS::JIT::Builder::check_hashref", XS_XS__JIT__Builder_check_hashref);
        newXS_deffile("XS::JIT::Builder::check_arrayref", XS_XS__JIT__Builder_check_arrayref);
        newXS_deffile("XS::JIT::Builder::sv_to_iv", XS_XS__JIT__Builder_sv_to_iv);
        newXS_deffile("XS::JIT::Builder::sv_to_nv", XS_XS__JIT__Builder_sv_to_nv);
        newXS_deffile("XS::JIT::Builder::sv_to_pv", XS_XS__JIT__Builder_sv_to_pv);
        newXS_deffile("XS::JIT::Builder::sv_to_bool", XS_XS__JIT__Builder_sv_to_bool);
        newXS_deffile("XS::JIT::Builder::return_iv", XS_XS__JIT__Builder_return_iv);
        newXS_deffile("XS::JIT::Builder::return_nv", XS_XS__JIT__Builder_return_nv);
        newXS_deffile("XS::JIT::Builder::return_pv", XS_XS__JIT__Builder_return_pv);
        newXS_deffile("XS::JIT::Builder::return_sv", XS_XS__JIT__Builder_return_sv);
        newXS_deffile("XS::JIT::Builder::return_yes", XS_XS__JIT__Builder_return_yes);
        newXS_deffile("XS::JIT::Builder::return_no", XS_XS__JIT__Builder_return_no);
        newXS_deffile("XS::JIT::Builder::return_self", XS_XS__JIT__Builder_return_self);
        newXS_deffile("XS::JIT::Builder::method_start", XS_XS__JIT__Builder_method_start);
        newXS_deffile("XS::JIT::Builder::ro_accessor", XS_XS__JIT__Builder_ro_accessor);
        newXS_deffile("XS::JIT::Builder::rw_accessor", XS_XS__JIT__Builder_rw_accessor);
        newXS_deffile("XS::JIT::Builder::accessor", XS_XS__JIT__Builder_accessor);
        newXS_deffile("XS::JIT::Builder::predicate", XS_XS__JIT__Builder_predicate);
        newXS_deffile("XS::JIT::Builder::clearer", XS_XS__JIT__Builder_clearer);
        newXS_deffile("XS::JIT::Builder::constructor", XS_XS__JIT__Builder_constructor);
        newXS_deffile("XS::JIT::Builder::new_simple", XS_XS__JIT__Builder_new_simple);
        newXS_deffile("XS::JIT::Builder::new_hash", XS_XS__JIT__Builder_new_hash);
        newXS_deffile("XS::JIT::Builder::new_array", XS_XS__JIT__Builder_new_array);
        newXS_deffile("XS::JIT::Builder::new_with_build", XS_XS__JIT__Builder_new_with_build);
        newXS_deffile("XS::JIT::Builder::clone_hash", XS_XS__JIT__Builder_clone_hash);
        newXS_deffile("XS::JIT::Builder::clone_array", XS_XS__JIT__Builder_clone_array);
        newXS_deffile("XS::JIT::Builder::new_with_required", XS_XS__JIT__Builder_new_with_required);
        newXS_deffile("XS::JIT::Builder::rw_accessor_typed", XS_XS__JIT__Builder_rw_accessor_typed);
        newXS_deffile("XS::JIT::Builder::rw_accessor_weak", XS_XS__JIT__Builder_rw_accessor_weak);
        newXS_deffile("XS::JIT::Builder::hv_store_weak", XS_XS__JIT__Builder_hv_store_weak);
        newXS_deffile("XS::JIT::Builder::new_complete", XS_XS__JIT__Builder_new_complete);
        newXS_deffile("XS::JIT::Builder::call_sv", XS_XS__JIT__Builder_call_sv);
        newXS_deffile("XS::JIT::Builder::call_method", XS_XS__JIT__Builder_call_method);
        newXS_deffile("XS::JIT::Builder::rw_accessor_trigger", XS_XS__JIT__Builder_rw_accessor_trigger);
        newXS_deffile("XS::JIT::Builder::accessor_lazy_builder", XS_XS__JIT__Builder_accessor_lazy_builder);
        newXS_deffile("XS::JIT::Builder::destroy_with_demolish", XS_XS__JIT__Builder_destroy_with_demolish);
        newXS_deffile("XS::JIT::Builder::do_loop", XS_XS__JIT__Builder_do_loop);
        newXS_deffile("XS::JIT::Builder::end_do_while", XS_XS__JIT__Builder_end_do_while);
        newXS_deffile("XS::JIT::Builder::if_list_context", XS_XS__JIT__Builder_if_list_context);
        newXS_deffile("XS::JIT::Builder::if_scalar_context", XS_XS__JIT__Builder_if_scalar_context);
        newXS_deffile("XS::JIT::Builder::extend_stack", XS_XS__JIT__Builder_extend_stack);
        newXS_deffile("XS::JIT::Builder::return_list", XS_XS__JIT__Builder_return_list);
        newXS_deffile("XS::JIT::Builder::declare_ternary", XS_XS__JIT__Builder_declare_ternary);
        newXS_deffile("XS::JIT::Builder::assign_ternary", XS_XS__JIT__Builder_assign_ternary);
        newXS_deffile("XS::JIT::Builder::delegate_method", XS_XS__JIT__Builder_delegate_method);
        newXS_deffile("XS::JIT::Builder::singleton_accessor", XS_XS__JIT__Builder_singleton_accessor);
        newXS_deffile("XS::JIT::Builder::singleton_reset", XS_XS__JIT__Builder_singleton_reset);
        newXS_deffile("XS::JIT::Builder::registry_add", XS_XS__JIT__Builder_registry_add);
        newXS_deffile("XS::JIT::Builder::registry_get", XS_XS__JIT__Builder_registry_get);
        newXS_deffile("XS::JIT::Builder::registry_remove", XS_XS__JIT__Builder_registry_remove);
        newXS_deffile("XS::JIT::Builder::registry_all", XS_XS__JIT__Builder_registry_all);
        newXS_deffile("XS::JIT::Builder::wrap_before", XS_XS__JIT__Builder_wrap_before);
        newXS_deffile("XS::JIT::Builder::wrap_after", XS_XS__JIT__Builder_wrap_after);
        newXS_deffile("XS::JIT::Builder::wrap_around", XS_XS__JIT__Builder_wrap_around);
        newXS_deffile("XS::JIT::Builder::op_ro_accessor", XS_XS__JIT__Builder_op_ro_accessor);
        newXS_deffile("XS::JIT::Builder::op_rw_accessor", XS_XS__JIT__Builder_op_rw_accessor);
        newXS_deffile("XS::JIT::Builder::inline_init", XS_XS__JIT__Builder_inline_init);
        newXS_deffile("XS::JIT::Builder::inline_register", XS_XS__JIT__Builder_inline_register);
        newXS_deffile("XS::JIT::Builder::inline_get_type", XS_XS__JIT__Builder_inline_get_type);
        newXS_deffile("XS::JIT::Builder::pp_start", XS_XS__JIT__Builder_pp_start);
        newXS_deffile("XS::JIT::Builder::pp_end", XS_XS__JIT__Builder_pp_end);
        newXS_deffile("XS::JIT::Builder::pp_dsp", XS_XS__JIT__Builder_pp_dsp);
        newXS_deffile("XS::JIT::Builder::pp_get_self", XS_XS__JIT__Builder_pp_get_self);
        newXS_deffile("XS::JIT::Builder::pp_pop_self", XS_XS__JIT__Builder_pp_pop_self);
        newXS_deffile("XS::JIT::Builder::pp_pop_sv", XS_XS__JIT__Builder_pp_pop_sv);
        newXS_deffile("XS::JIT::Builder::pp_pop_nv", XS_XS__JIT__Builder_pp_pop_nv);
        newXS_deffile("XS::JIT::Builder::pp_pop_iv", XS_XS__JIT__Builder_pp_pop_iv);
        newXS_deffile("XS::JIT::Builder::pp_get_slots", XS_XS__JIT__Builder_pp_get_slots);
        newXS_deffile("XS::JIT::Builder::pp_slot", XS_XS__JIT__Builder_pp_slot);
        newXS_deffile("XS::JIT::Builder::pp_return_sv", XS_XS__JIT__Builder_pp_return_sv);
        newXS_deffile("XS::JIT::Builder::pp_return_nv", XS_XS__JIT__Builder_pp_return_nv);
        newXS_deffile("XS::JIT::Builder::pp_return_iv", XS_XS__JIT__Builder_pp_return_iv);
        newXS_deffile("XS::JIT::Builder::pp_return_pv", XS_XS__JIT__Builder_pp_return_pv);
        newXS_deffile("XS::JIT::Builder::pp_return", XS_XS__JIT__Builder_pp_return);
        newXS_deffile("XS::JIT::Builder::ck_start", XS_XS__JIT__Builder_ck_start);
        newXS_deffile("XS::JIT::Builder::ck_end", XS_XS__JIT__Builder_ck_end);
        newXS_deffile("XS::JIT::Builder::ck_preamble", XS_XS__JIT__Builder_ck_preamble);
        newXS_deffile("XS::JIT::Builder::ck_build_unop", XS_XS__JIT__Builder_ck_build_unop);
        newXS_deffile("XS::JIT::Builder::ck_build_binop", XS_XS__JIT__Builder_ck_build_binop);
        newXS_deffile("XS::JIT::Builder::ck_fallback", XS_XS__JIT__Builder_ck_fallback);
        newXS_deffile("XS::JIT::Builder::xop_declare", XS_XS__JIT__Builder_xop_declare);
        newXS_deffile("XS::JIT::Builder::register_checker", XS_XS__JIT__Builder_register_checker);
        newXS_deffile("XS::JIT::Builder::av_direct", XS_XS__JIT__Builder_av_direct);
        newXS_deffile("XS::JIT::Builder::av_slot_read", XS_XS__JIT__Builder_av_slot_read);
        newXS_deffile("XS::JIT::Builder::av_slot_write", XS_XS__JIT__Builder_av_slot_write);
        newXS_deffile("XS::JIT::Builder::check_value_type", XS_XS__JIT__Builder_check_value_type);
        newXS_deffile("XS::JIT::Builder::lazy_init_dor", XS_XS__JIT__Builder_lazy_init_dor);
        newXS_deffile("XS::JIT::Builder::lazy_init_or", XS_XS__JIT__Builder_lazy_init_or);
        newXS_deffile("XS::JIT::Builder::slot_lazy_init_dor", XS_XS__JIT__Builder_slot_lazy_init_dor);
        newXS_deffile("XS::JIT::Builder::slot_lazy_init_or", XS_XS__JIT__Builder_slot_lazy_init_or);
        newXS_deffile("XS::JIT::Builder::setter_chain", XS_XS__JIT__Builder_setter_chain);
        newXS_deffile("XS::JIT::Builder::slot_setter_chain", XS_XS__JIT__Builder_slot_setter_chain);
        newXS_deffile("XS::JIT::Builder::setter_return_value", XS_XS__JIT__Builder_setter_return_value);
        newXS_deffile("XS::JIT::Builder::attr_push", XS_XS__JIT__Builder_attr_push);
        newXS_deffile("XS::JIT::Builder::attr_pop", XS_XS__JIT__Builder_attr_pop);
        newXS_deffile("XS::JIT::Builder::attr_shift", XS_XS__JIT__Builder_attr_shift);
        newXS_deffile("XS::JIT::Builder::attr_unshift", XS_XS__JIT__Builder_attr_unshift);
        newXS_deffile("XS::JIT::Builder::attr_count", XS_XS__JIT__Builder_attr_count);
        newXS_deffile("XS::JIT::Builder::attr_clear", XS_XS__JIT__Builder_attr_clear);
        newXS_deffile("XS::JIT::Builder::attr_keys", XS_XS__JIT__Builder_attr_keys);
        newXS_deffile("XS::JIT::Builder::attr_values", XS_XS__JIT__Builder_attr_values);
        newXS_deffile("XS::JIT::Builder::attr_delete", XS_XS__JIT__Builder_attr_delete);
        newXS_deffile("XS::JIT::Builder::attr_hash_clear", XS_XS__JIT__Builder_attr_hash_clear);
        newXS_deffile("XS::JIT::Builder::conditional", XS_XS__JIT__Builder_conditional);
        newXS_deffile("XS::JIT::Builder::switch", XS_XS__JIT__Builder_switch);
        newXS_deffile("XS::JIT::Builder::enum", XS_XS__JIT__Builder_enum);
        newXS_deffile("XS::JIT::Builder::memoize", XS_XS__JIT__Builder_memoize);
        newXS_deffile("XS::JIT::Builder::enum_functions", XS_XS__JIT__Builder_enum_functions);
        newXS_deffile("XS::JIT::Builder::memoize_functions", XS_XS__JIT__Builder_memoize_functions);
        newXS_deffile("XS::JIT::Builder::role", XS_XS__JIT__Builder_role);
        newXS_deffile("XS::JIT::Builder::with_roles", XS_XS__JIT__Builder_with_roles);

    /* Initialisation Section */

#line 40 "lib/XS/JIT/Builder.xs"
{
    HV* stash = gv_stashpv("XS::JIT::Builder", GV_ADD);

    /* Inline op type constants */
    newCONSTSUB(stash, "INLINE_NONE",      newSViv(XS_JIT_INLINE_NONE));
    newCONSTSUB(stash, "INLINE_GETTER",    newSViv(XS_JIT_INLINE_GETTER));
    newCONSTSUB(stash, "INLINE_SETTER",    newSViv(XS_JIT_INLINE_SETTER));
    newCONSTSUB(stash, "INLINE_HV_GETTER", newSViv(XS_JIT_INLINE_HV_GETTER));
    newCONSTSUB(stash, "INLINE_HV_SETTER", newSViv(XS_JIT_INLINE_HV_SETTER));

    /* Type check constants */
    newCONSTSUB(stash, "TYPE_ANY",       newSViv(XS_JIT_TYPE_ANY));
    newCONSTSUB(stash, "TYPE_DEFINED",   newSViv(XS_JIT_TYPE_DEFINED));
    newCONSTSUB(stash, "TYPE_INT",       newSViv(XS_JIT_TYPE_INT));
    newCONSTSUB(stash, "TYPE_NUM",       newSViv(XS_JIT_TYPE_NUM));
    newCONSTSUB(stash, "TYPE_STR",       newSViv(XS_JIT_TYPE_STR));
    newCONSTSUB(stash, "TYPE_REF",       newSViv(XS_JIT_TYPE_REF));
    newCONSTSUB(stash, "TYPE_ARRAYREF",  newSViv(XS_JIT_TYPE_ARRAYREF));
    newCONSTSUB(stash, "TYPE_HASHREF",   newSViv(XS_JIT_TYPE_HASHREF));
    newCONSTSUB(stash, "TYPE_CODEREF",   newSViv(XS_JIT_TYPE_CODEREF));
    newCONSTSUB(stash, "TYPE_OBJECT",    newSViv(XS_JIT_TYPE_OBJECT));
    newCONSTSUB(stash, "TYPE_BLESSED",   newSViv(XS_JIT_TYPE_BLESSED));
}

#line 6085 "lib/XS/JIT/Builder.c"

    /* End of Initialisation Section */

#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
}

#ifdef __cplusplus
}
#endif
