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

#line 1 "RealPPPort.xs"
/*******************************************************************************
*
*  !!!!! Do NOT edit this file directly! -- Edit PPPort_xs.PL instead. !!!!!
*
*  This file was automatically generated from the definition files in the
*  parts/inc/ subdirectory by PPPort_xs.PL. To learn more about how all this
*  works, please read the F<HACKERS> file that came with this distribution.
*
********************************************************************************
*
*  Perl/Pollution/Portability
*
********************************************************************************
*
*  Version 3.x, Copyright (C) 2004-2013, Marcus Holland-Moritz.
*  Version 2.x, Copyright (C) 2001, Paul Marquess.
*  Version 1.x, Copyright (C) 1999, Kenneth Albanowski.
*
*  This program is free software; you can redistribute it and/or
*  modify it under the same terms as Perl itself.
*
*******************************************************************************/

/* ========== BEGIN XSHEAD ================================================== */

#define PERL_NO_GET_CONTEXT

/* =========== END XSHEAD =================================================== */

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

/* ========== BEGIN XSINIT ================================================== */

/* ---- code from parts/inc/SvPV ---- */
#define NEED_sv_2pv_flags
#define NEED_sv_pvn_force_flags
#define NEED_sv_2pvbyte

/* ---- code from parts/inc/call ---- */
#define NEED_eval_pv
#define NEED_load_module
#define NEED_vload_module

/* ---- code from parts/inc/cop ---- */
#define NEED_caller_cx

/* ---- code from parts/inc/grok ---- */
#define NEED_grok_number
#define NEED_grok_numeric_radix
#define NEED_grok_bin
#define NEED_grok_hex
#define NEED_grok_oct

/* ---- code from parts/inc/gv ---- */
#define NEED_gv_fetchpvn_flags

/* ---- code from parts/inc/magic ---- */
#define NEED_mg_findext
#define NEED_sv_unmagicext

#ifndef STATIC
#define STATIC static
#endif

STATIC MGVTBL null_mg_vtbl = {
    NULL, /* get */
    NULL, /* set */
    NULL, /* len */
    NULL, /* clear */
    NULL, /* free */
#if MGf_COPY
    NULL, /* copy */
#endif /* MGf_COPY */
#if MGf_DUP
    NULL, /* dup */
#endif /* MGf_DUP */
#if MGf_LOCAL
    NULL, /* local */
#endif /* MGf_LOCAL */
};

STATIC MGVTBL other_mg_vtbl = {
    NULL, /* get */
    NULL, /* set */
    NULL, /* len */
    NULL, /* clear */
    NULL, /* free */
#if MGf_COPY
    NULL, /* copy */
#endif /* MGf_COPY */
#if MGf_DUP
    NULL, /* dup */
#endif /* MGf_DUP */
#if MGf_LOCAL
    NULL, /* local */
#endif /* MGf_LOCAL */
};

/* ---- code from parts/inc/mess ---- */
#define NEED_die_sv
#define NEED_mess_sv
#define NEED_croak_xs_usage

/* ---- code from parts/inc/misc ---- */
#define NEED_SvRX

/* ---- code from parts/inc/newCONSTSUB ---- */
#define NEED_newCONSTSUB

/* ---- code from parts/inc/newRV ---- */
#define NEED_newRV_noinc

/* ---- code from parts/inc/newSV_type ---- */
#define NEED_newSV_type

/* ---- code from parts/inc/newSVpv ---- */
#define NEED_newSVpvn_flags

/* ---- code from parts/inc/pv_tools ---- */
#define NEED_pv_escape
#define NEED_pv_pretty
#define NEED_pv_display

/* ---- code from parts/inc/pvs ---- */
#define NEED_newSVpvn_share

/* ---- code from parts/inc/shared_pv ---- */
#define NEED_newSVpvn_share

/* ---- code from parts/inc/snprintf ---- */
#define NEED_my_snprintf

/* ---- code from parts/inc/sprintf ---- */
#define NEED_my_sprintf

/* ---- code from parts/inc/strlfuncs ---- */
#define NEED_my_strlcat
#define NEED_my_strlcpy

/* ---- code from parts/inc/sv_xpvf ---- */
#define NEED_vnewSVpvf
#define NEED_sv_catpvf_mg
#define NEED_sv_catpvf_mg_nocontext
#define NEED_sv_setpvf_mg
#define NEED_sv_setpvf_mg_nocontext

/* ---- code from parts/inc/variables ---- */
#define NEED_PL_signals
#define NEED_PL_parser
#define DPPP_PL_parser_NO_DUMMY_WARNING

/* ---- code from parts/inc/warn ---- */
#define NEED_warner

/* =========== END XSINIT =================================================== */

#include "ppport.h"

/* ========== BEGIN XSMISC ================================================== */

/* ---- code from parts/inc/MY_CXT ---- */
#define MY_CXT_KEY "Devel::PPPort::_guts" XS_VERSION

typedef struct {
  /* Put Global Data in here */
  int dummy;
} my_cxt_t;

START_MY_CXT

/* ---- code from parts/inc/exception ---- */
/* defined in module3.c */
int exception(int throw_e);

/* ---- code from parts/inc/misc ---- */
typedef XSPROTO(XSPROTO_test_t);
typedef XSPROTO_test_t *XSPROTO_test_t_ptr;

XS(XS_Devel__PPPort_dXSTARG);  /* prototype */
XS(XS_Devel__PPPort_dXSTARG)
{
  dXSARGS;
  dXSTARG;
  IV iv;

  PERL_UNUSED_VAR(cv);
  SP -= items;
  iv = SvIV(ST(0)) + 1;
  PUSHi(iv);
  XSRETURN(1);
}

XS(XS_Devel__PPPort_dAXMARK);  /* prototype */
XS(XS_Devel__PPPort_dAXMARK)
{
  dSP;
  dAXMARK;
  dITEMS;
  IV iv;

  PERL_UNUSED_VAR(cv);
  SP -= items;
  iv = SvIV(ST(0)) - 1;
  mPUSHi(iv);
  XSRETURN(1);
}

/* ---- code from parts/inc/newCONSTSUB ---- */
void call_newCONSTSUB_1(void)
{
#ifdef PERL_NO_GET_CONTEXT
        dTHX;
#endif
        newCONSTSUB(gv_stashpv("Devel::PPPort", FALSE), "test_value_1", newSViv(1));
}

extern void call_newCONSTSUB_2(void);
extern void call_newCONSTSUB_3(void);

/* ---- code from parts/inc/sv_xpvf ---- */
static SV * test_vnewSVpvf(pTHX_ const char *pat, ...)
{
  SV *sv;
  va_list args;
  va_start(args, pat);
#if (PERL_BCDVERSION >= 0x5004000)
  sv = vnewSVpvf(pat, &args);
#else
  sv = newSVpv((char *) pat, 0);
#endif
  va_end(args);
  return sv;
}

static void test_sv_vcatpvf(pTHX_ SV *sv, const char *pat, ...)
{
  va_list args;
  va_start(args, pat);
#if (PERL_BCDVERSION >= 0x5004000)
  sv_vcatpvf(sv, pat, &args);
#else
  sv_catpv(sv, (char *) pat);
#endif
  va_end(args);
}

static void test_sv_vsetpvf(pTHX_ SV *sv, const char *pat, ...)
{
  va_list args;
  va_start(args, pat);
#if (PERL_BCDVERSION >= 0x5004000)
  sv_vsetpvf(sv, pat, &args);
#else
  sv_setpv(sv, (char *) pat);
#endif
  va_end(args);
}

/* ---- code from parts/inc/variables ---- */
U32 get_PL_signals_1(void)
{
#ifdef PERL_NO_GET_CONTEXT
  dTHX;
#endif
  return PL_signals;
}

extern U32 get_PL_signals_2(void);
extern U32 get_PL_signals_3(void);
int no_dummy_parser_vars(int);
int dummy_parser_warning(void);

/* No PTRSIZE IN 5.004 and below, so PTR2IV would warn and possibly misbehave */
#if (PERL_BCDVERSION > 0x5004000)
  #define ppp_TESTVAR(var)          STMT_START { mXPUSHi(PTR2IV(&var)); count++; } STMT_END
#else
  #define ppp_TESTVAR(var)          STMT_START { mXPUSHi(&var); count++; } STMT_END
#endif

#define ppp_PARSERVAR(type, var)  STMT_START {                   \
                                    type volatile my_ ## var;    \
                                    type volatile *my_p_ ## var; \
                                    my_ ## var = var;            \
                                    my_p_ ## var = &var;         \
                                    var = my_ ## var;            \
                                    var = *my_p_ ## var;         \
                                    mXPUSHi(&var != NULL);       \
                                    count++;                     \
                                  } STMT_END

#define ppp_PARSERVAR_dummy       STMT_START {                   \
                                    mXPUSHi(1);                  \
                                    count++;                     \
                                  } STMT_END

#if (PERL_BCDVERSION < 0x5004000)
# define ppp_rsfp_t FILE *
#else
# define ppp_rsfp_t PerlIO *
#endif

#if (PERL_BCDVERSION < 0x5006000)
# define ppp_expect_t expectation
#elif (PERL_BCDVERSION < 0x5009005)
# define ppp_expect_t int
#else
# define ppp_expect_t U8
#endif

#if (PERL_BCDVERSION < 0x5009005)
# define ppp_lex_state_t U32
#else
# define ppp_lex_state_t U8
#endif

#if (PERL_BCDVERSION < 0x5006000)
# define ppp_in_my_t bool
#elif (PERL_BCDVERSION < 0x5009005)
# define ppp_in_my_t I32
#else
# define ppp_in_my_t U16
#endif

#if (PERL_BCDVERSION < 0x5009005)
# define ppp_error_count_t I32
#else
# define ppp_error_count_t U8
#endif

/* =========== END XSMISC =================================================== */

#line 344 "RealPPPort.c"
#ifndef PERL_UNUSED_VAR
#  define PERL_UNUSED_VAR(var) if (0) var = var
#endif

#ifndef dVAR
#  define dVAR		dNOOP
#endif


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

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


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

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


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

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

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

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

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

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

    PERL_ARGS_ASSERT_CROAK_XS_USAGE;

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

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

#define croak_xs_usage        S_croak_xs_usage

#endif

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

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

#line 488 "RealPPPort.c"

XS_EUPXS(XS_Devel__PPPort_HvNAME_get); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_HvNAME_get)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "hv");
    {
	HV *	hv;
	char *	RETVAL;
	dXSTARG;

        if (SvROK(ST(0)) && SvTYPE(SvRV(ST(0)))==SVt_PVHV)
            hv = (HV*)SvRV(ST(0));
        else
            Perl_croak(aTHX_ "hv is not a hash reference")
;

	RETVAL = HvNAME_get(hv);
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


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

        if (SvROK(ST(0)) && SvTYPE(SvRV(ST(0)))==SVt_PVHV)
            hv = (HV*)SvRV(ST(0));
        else
            Perl_croak(aTHX_ "hv is not a hash reference")
;

	RETVAL = HvNAMELEN_get(hv);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_MY_CXT_1); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_MY_CXT_1)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	int	RETVAL;
	dXSTARG;
#line 373 "RealPPPort.xs"
                dMY_CXT;
                RETVAL = MY_CXT.dummy == 42;
                ++MY_CXT.dummy;
#line 551 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_MY_CXT_2); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_MY_CXT_2)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	int	RETVAL;
	dXSTARG;
#line 382 "RealPPPort.xs"
                dMY_CXT;
                RETVAL = MY_CXT.dummy == 43;
#line 570 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_MY_CXT_CLONE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_MY_CXT_CLONE)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	int	RETVAL;
	dXSTARG;
#line 390 "RealPPPort.xs"
                MY_CXT_CLONE;
                RETVAL = 42;
#line 589 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPVbyte); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPVbyte)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 403 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 608 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 406 "RealPPPort.xs"
                str = SvPVbyte(sv, len);
                RETVAL = strEQ(str, "mhx") ? (IV) len : (IV) -1;
#line 614 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 415 "RealPPPort.xs"
                char *str;
#line 632 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 417 "RealPPPort.xs"
                str = SvPV_nolen(sv);
                RETVAL = strEQ(str, "mhx") ? 42 : 0;
#line 638 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_const); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_const)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 426 "RealPPPort.xs"
                const char *str;
                STRLEN len;
#line 657 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 429 "RealPPPort.xs"
                str = SvPV_const(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 40 : 0);
#line 663 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_mutable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_mutable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 438 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 682 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 441 "RealPPPort.xs"
                str = SvPV_mutable(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 41 : 0);
#line 688 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_flags)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 450 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 707 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 453 "RealPPPort.xs"
                str = SvPV_flags(sv, len, SV_GMAGIC);
                RETVAL = len + (strEQ(str, "mhx") ? 42 : 0);
#line 713 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_flags_const); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_flags_const)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 462 "RealPPPort.xs"
                const char *str;
                STRLEN len;
#line 732 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 465 "RealPPPort.xs"
                str = SvPV_flags_const(sv, len, SV_GMAGIC);
                RETVAL = len + (strEQ(str, "mhx") ? 43 : 0);
#line 738 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_flags_const_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_flags_const_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 474 "RealPPPort.xs"
                const char *str;
#line 756 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 476 "RealPPPort.xs"
                str = SvPV_flags_const_nolen(sv, SV_GMAGIC);
                RETVAL = strEQ(str, "mhx") ? 47 : 0;
#line 762 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_flags_mutable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_flags_mutable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 485 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 781 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 488 "RealPPPort.xs"
                str = SvPV_flags_mutable(sv, len, SV_GMAGIC);
                RETVAL = len + (strEQ(str, "mhx") ? 45 : 0);
#line 787 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 497 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 806 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 500 "RealPPPort.xs"
                str = SvPV_force(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 46 : 0);
#line 812 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 509 "RealPPPort.xs"
                char *str;
#line 830 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 511 "RealPPPort.xs"
                str = SvPV_force_nolen(sv);
                RETVAL = strEQ(str, "mhx") ? 50 : 0;
#line 836 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_mutable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_mutable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 520 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 855 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 523 "RealPPPort.xs"
                str = SvPV_force_mutable(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 48 : 0);
#line 861 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_nomg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_nomg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 532 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 880 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 535 "RealPPPort.xs"
                str = SvPV_force_nomg(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 49 : 0);
#line 886 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_nomg_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_nomg_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 544 "RealPPPort.xs"
                char *str;
#line 904 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 546 "RealPPPort.xs"
                str = SvPV_force_nomg_nolen(sv);
                RETVAL = strEQ(str, "mhx") ? 53 : 0;
#line 910 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 555 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 929 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 558 "RealPPPort.xs"
                str = SvPV_force_flags(sv, len, SV_GMAGIC);
                RETVAL = len + (strEQ(str, "mhx") ? 51 : 0);
#line 935 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 567 "RealPPPort.xs"
                char *str;
#line 953 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 569 "RealPPPort.xs"
                str = SvPV_force_flags_nolen(sv, SV_GMAGIC);
                RETVAL = strEQ(str, "mhx") ? 55 : 0;
#line 959 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags_mutable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_force_flags_mutable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 578 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 978 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 581 "RealPPPort.xs"
                str = SvPV_force_flags_mutable(sv, len, SV_GMAGIC);
                RETVAL = len + (strEQ(str, "mhx") ? 53 : 0);
#line 984 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nolen_const); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nolen_const)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 590 "RealPPPort.xs"
                const char *str;
#line 1002 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 592 "RealPPPort.xs"
                str = SvPV_nolen_const(sv);
                RETVAL = strEQ(str, "mhx") ? 57 : 0;
#line 1008 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nomg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nomg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 601 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 1027 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 604 "RealPPPort.xs"
                str = SvPV_nomg(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 55 : 0);
#line 1033 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_const); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_const)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 613 "RealPPPort.xs"
                const char *str;
                STRLEN len;
#line 1052 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 616 "RealPPPort.xs"
                str = SvPV_nomg_const(sv, len);
                RETVAL = len + (strEQ(str, "mhx") ? 56 : 0);
#line 1058 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_const_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_const_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 625 "RealPPPort.xs"
                const char *str;
#line 1076 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 627 "RealPPPort.xs"
                str = SvPV_nomg_const_nolen(sv);
                RETVAL = strEQ(str, "mhx") ? 60 : 0;
#line 1082 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_nolen); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_nomg_nolen)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 636 "RealPPPort.xs"
                char *str;
#line 1100 "RealPPPort.c"
	IV	RETVAL;
	dXSTARG;
#line 638 "RealPPPort.xs"
                str = SvPV_nomg_nolen(sv);
                RETVAL = strEQ(str, "mhx") ? 61 : 0;
#line 1106 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvPV_renew); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvPV_renew)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "sv, nlen, insv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	sv = ST(0)
;
	STRLEN        nlen = (STRLEN)SvUV(ST(1))
;
	SV *	insv = ST(2)
;
#line 649 "RealPPPort.xs"
                STRLEN slen;
                const char *str;
#line 1131 "RealPPPort.c"
#line 652 "RealPPPort.xs"
                str = SvPV_const(insv, slen);
                XPUSHs(sv);
                mXPUSHi(SvLEN(sv));
                SvPV_renew(sv, nlen);
                Copy(str, SvPVX(sv), slen + 1, char);
                SvCUR_set(sv, slen);
                mXPUSHi(SvLEN(sv));
#line 1140 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_SvREFCNT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvREFCNT)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 667 "RealPPPort.xs"
                SV *sv, *svr;
#line 1158 "RealPPPort.c"
#line 669 "RealPPPort.xs"
                sv = newSV(0);
                mXPUSHi(SvREFCNT(sv) == 1);
                svr = SvREFCNT_inc(sv);
                mXPUSHi(sv == svr);
                mXPUSHi(SvREFCNT(sv) == 2);
                svr = SvREFCNT_inc_simple(sv);
                mXPUSHi(sv == svr);
                mXPUSHi(SvREFCNT(sv) == 3);
                svr = SvREFCNT_inc_NN(sv);
                mXPUSHi(sv == svr);
                mXPUSHi(SvREFCNT(sv) == 4);
                svr = SvREFCNT_inc_simple_NN(sv);
                mXPUSHi(sv == svr);
                mXPUSHi(SvREFCNT(sv) == 5);
                SvREFCNT_inc_void(sv);
                mXPUSHi(SvREFCNT(sv) == 6);
                SvREFCNT_inc_simple_void(sv);
                mXPUSHi(SvREFCNT(sv) == 7);
                SvREFCNT_inc_void_NN(sv);
                mXPUSHi(SvREFCNT(sv) == 8);
                SvREFCNT_inc_simple_void_NN(sv);
                mXPUSHi(SvREFCNT(sv) == 9);
                while (SvREFCNT(sv) > 1)
                  SvREFCNT_dec(sv);
                mXPUSHi(SvREFCNT(sv) == 1);
                SvREFCNT_dec(sv);
                XSRETURN(14);
#line 1187 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_TestSvUV_set); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_TestSvUV_set)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, val");
    {
	SV *	sv = ST(0)
;
	UV        val = (UV)SvUV(ST(1))
;
	IV	RETVAL;
	dXSTARG;
#line 706 "RealPPPort.xs"
                SvUV_set(sv, val);
                RETVAL = SvUVX(sv) == val ? 42 : -1;
#line 1210 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_TestSvPVX_const); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_TestSvPVX_const)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	IV	RETVAL;
	dXSTARG;
#line 715 "RealPPPort.xs"
                RETVAL = strEQ(SvPVX_const(sv), "mhx") ? 43 : -1;
#line 1230 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_TestSvPVX_mutable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_TestSvPVX_mutable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	IV	RETVAL;
	dXSTARG;
#line 723 "RealPPPort.xs"
                RETVAL = strEQ(SvPVX_mutable(sv), "mhx") ? 44 : -1;
#line 1250 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_TestSvSTASH_set); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_TestSvSTASH_set)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, name");
    {
	SV *	sv = ST(0)
;
	char *	name = (char *)SvPV_nolen(ST(1))
;
#line 732 "RealPPPort.xs"
                sv = SvRV(sv);
                SvREFCNT_dec(SvSTASH(sv));
                SvSTASH_set(sv, (HV*) SvREFCNT_inc(gv_stashpv(name, 0)));
#line 1272 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_G_SCALAR); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_G_SCALAR)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	I32	RETVAL;
	dXSTARG;
#line 743 "RealPPPort.xs"
                RETVAL = G_SCALAR;
#line 1289 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_G_ARRAY); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_G_ARRAY)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	I32	RETVAL;
	dXSTARG;
#line 750 "RealPPPort.xs"
                RETVAL = G_ARRAY;
#line 1307 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_G_DISCARD); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_G_DISCARD)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	I32	RETVAL;
	dXSTARG;
#line 757 "RealPPPort.xs"
                RETVAL = G_DISCARD;
#line 1325 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_eval_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_eval_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, flags");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV*	sv = ST(0)
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 766 "RealPPPort.xs"
                I32 i;
#line 1347 "RealPPPort.c"
#line 768 "RealPPPort.xs"
                PUTBACK;
                i = eval_sv(sv, flags);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1354 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_eval_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_eval_pv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, croak_on_error");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char*	p = (char *)SvPV_nolen(ST(0))
;
	I32	croak_on_error = (I32)SvIV(ST(1))
;
#line 779 "RealPPPort.xs"
                PUTBACK;
                EXTEND(SP, 1);
                PUSHs(eval_pv(p, croak_on_error));
#line 1378 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_sv)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "sv, flags, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV*	sv = ST(0)
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 788 "RealPPPort.xs"
                I32 i;
#line 1400 "RealPPPort.c"
#line 790 "RealPPPort.xs"
                for (i=0; i<items-2; i++)
                  ST(i) = ST(i+2); /* pop first two args */
                PUSHMARK(SP);
                SP += items - 2;
                PUTBACK;
                i = call_sv(sv, flags);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1411 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_pv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_pv)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "subname, flags, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char*	subname = (char *)SvPV_nolen(ST(0))
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 805 "RealPPPort.xs"
                I32 i;
#line 1433 "RealPPPort.c"
#line 807 "RealPPPort.xs"
                for (i=0; i<items-2; i++)
                  ST(i) = ST(i+2); /* pop first two args */
                PUSHMARK(SP);
                SP += items - 2;
                PUTBACK;
                i = call_pv(subname, flags);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1444 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_argv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_argv)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "subname, flags, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char*	subname = (char *)SvPV_nolen(ST(0))
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 822 "RealPPPort.xs"
                I32 i;
                char *args[8];
#line 1467 "RealPPPort.c"
#line 825 "RealPPPort.xs"
                if (items > 8)  /* play safe */
                  XSRETURN_UNDEF;
                for (i=2; i<items; i++)
                  args[i-2] = SvPV_nolen(ST(i));
                args[items-2] = NULL;
                PUTBACK;
                i = call_argv(subname, flags, args);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1479 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_method); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_method)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "methname, flags, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char*	methname = (char *)SvPV_nolen(ST(0))
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 841 "RealPPPort.xs"
                I32 i;
#line 1501 "RealPPPort.c"
#line 843 "RealPPPort.xs"
                for (i=0; i<items-2; i++)
                  ST(i) = ST(i+2); /* pop first two args */
                PUSHMARK(SP);
                SP += items - 2;
                PUTBACK;
                i = call_method(methname, flags);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1512 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_sv_G_METHOD); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_sv_G_METHOD)
{
    dVAR; dXSARGS;
    if (items < 2)
       croak_xs_usage(cv,  "sv, flags, ...");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV*	sv = ST(0)
;
	I32	flags = (I32)SvIV(ST(1))
;
#line 858 "RealPPPort.xs"
                I32 i;
#line 1534 "RealPPPort.c"
#line 860 "RealPPPort.xs"
                for (i=0; i<items-2; i++)
                  ST(i) = ST(i+2); /* pop first two args */
                PUSHMARK(SP);
                SP += items - 2;
                PUTBACK;
                i = call_sv(sv, flags | G_METHOD);
                SPAGAIN;
                EXTEND(SP, 1);
                mPUSHi(i);
#line 1545 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_load_module); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_load_module)
{
    dVAR; dXSARGS;
    if (items < 3)
       croak_xs_usage(cv,  "flags, name, version, ...");
    {
	U32	flags = (unsigned long)SvUV(ST(0))
;
	SV *	name = ST(1)
;
	SV *	version = ST(2)
;
#line 876 "RealPPPort.xs"
                /* Both SV parameters are donated to the ops built inside
                   load_module, so we need to bump the refcounts.  */
                Perl_load_module(aTHX_ flags, SvREFCNT_inc_simple(name),
                                 SvREFCNT_inc_simple(version), NULL);
#line 1570 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_CopSTASHPV); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_CopSTASHPV)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	char *	RETVAL;
	dXSTARG;
#line 888 "RealPPPort.xs"
                RETVAL = CopSTASHPV(PL_curcop);
#line 1587 "RealPPPort.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_CopFILE); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_CopFILE)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	char *	RETVAL;
	dXSTARG;
#line 895 "RealPPPort.xs"
                RETVAL = CopFILE(PL_curcop);
#line 1605 "RealPPPort.c"
	sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG;
    }
    XSRETURN(1);
}

#if (PERL_BCDVERSION >= 0x5006000)
#define XSubPPtmpAAAA 1


XS_EUPXS(XS_Devel__PPPort_caller_cx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_caller_cx)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "level");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	I32	level = (I32)SvIV(ST(0))
;
#line 905 "RealPPPort.xs"
        const PERL_CONTEXT *cx, *dbcx;
        const char *pv;
        const GV *gv;
#line 1630 "RealPPPort.c"
#line 909 "RealPPPort.xs"
        cx = caller_cx(level, &dbcx);
        if (!cx) XSRETURN_EMPTY;

        EXTEND(SP, 4);

        pv = CopSTASHPV(cx->blk_oldcop);
        ST(0) = pv ? sv_2mortal(newSVpv(pv, 0)) : &PL_sv_undef;
        gv = CvGV(cx->blk_sub.cv);
        ST(1) = isGV(gv) ? sv_2mortal(newSVpv(GvNAME(gv), 0)) : &PL_sv_undef;

        pv = CopSTASHPV(dbcx->blk_oldcop);
        ST(2) = pv ? sv_2mortal(newSVpv(pv, 0)) : &PL_sv_undef;
        gv = CvGV(dbcx->blk_sub.cv);
        ST(3) = isGV(gv) ? sv_2mortal(newSVpv(GvNAME(gv), 0)) : &PL_sv_undef;

        XSRETURN(4);
#line 1648 "RealPPPort.c"
	PUTBACK;
	return;
    }
}

#endif /* 5.6.0 */

XS_EUPXS(XS_Devel__PPPort_exception); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_exception)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "throw_e");
    {
	int	throw_e = (int)SvIV(ST(0))
;
	int	RETVAL;
	dXSTARG;

	RETVAL = exception(throw_e);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_croak_NVgf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_croak_NVgf)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "num");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	NV        num = (NV)SvNV(ST(0))
;
#line 946 "RealPPPort.xs"
                Perl_croak(aTHX_ "%.20" NVgf "\n", num);
#line 1688 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_grok_number); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_grok_number)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 956 "RealPPPort.xs"
                const char *pv;
                STRLEN len;
#line 1707 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 959 "RealPPPort.xs"
                pv = SvPV(string, len);
                if (!grok_number(pv, len, &RETVAL))
                  XSRETURN_UNDEF;
#line 1714 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_grok_bin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_grok_bin)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 969 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1734 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 973 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = grok_bin(pv, &len, &flags, NULL);
#line 1740 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_grok_hex); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_grok_hex)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 982 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1760 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 986 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = grok_hex(pv, &len, &flags, NULL);
#line 1766 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_grok_oct); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_grok_oct)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 995 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1786 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 999 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = grok_oct(pv, &len, &flags, NULL);
#line 1792 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_Perl_grok_number); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_grok_number)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 1008 "RealPPPort.xs"
                const char *pv;
                STRLEN len;
#line 1811 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 1011 "RealPPPort.xs"
                pv = SvPV(string, len);
                if (!Perl_grok_number(aTHX_ pv, len, &RETVAL))
                  XSRETURN_UNDEF;
#line 1818 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_Perl_grok_bin); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_grok_bin)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 1021 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1838 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 1025 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = Perl_grok_bin(aTHX_ pv, &len, &flags, NULL);
#line 1844 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_Perl_grok_hex); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_grok_hex)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 1034 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1864 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 1038 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = Perl_grok_hex(aTHX_ pv, &len, &flags, NULL);
#line 1870 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_Perl_grok_oct); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_grok_oct)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	SV *	string = ST(0)
;
#line 1047 "RealPPPort.xs"
                char *pv;
                I32 flags = 0;
                STRLEN len;
#line 1890 "RealPPPort.c"
	UV	RETVAL;
	dXSTARG;
#line 1051 "RealPPPort.xs"
                pv = SvPV(string, len);
                RETVAL = Perl_grok_oct(aTHX_ pv, &len, &flags, NULL);
#line 1896 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_GvSVn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_GvSVn)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1063 "RealPPPort.xs"
                GV* gv;
#line 1912 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1065 "RealPPPort.xs"
                RETVAL = 0;
                gv = gv_fetchpvs("Devel::PPPort::GvTest", GV_ADDMULTI, SVt_PVGV);
                if (GvSVn(gv) != NULL)
                {
                  RETVAL++;
                }
#line 1922 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_isGV_with_GP); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_isGV_with_GP)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1077 "RealPPPort.xs"
                GV* gv;
#line 1938 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1079 "RealPPPort.xs"
                RETVAL = 0;
                gv = gv_fetchpvs("Devel::PPPort::GvTest", GV_ADDMULTI, SVt_PVGV);
                if (isGV_with_GP(gv))
                {
                  RETVAL++;
                }
                if (!isGV(&PL_sv_undef))
                {
                  RETVAL++;
                }
#line 1952 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_cvn_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_cvn_flags)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1095 "RealPPPort.xs"
                CV* xv;
#line 1968 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1097 "RealPPPort.xs"
                RETVAL = 0;
                xv = get_cvn_flags("Devel::PPPort::foobar", sizeof("Devel::PPPort::foobar")-1, 0);
                if(xv == NULL) RETVAL++;
                xv = get_cvn_flags("Devel::PPPort::foobar", sizeof("Devel::PPPort::foobar")-1, GV_ADDMULTI);
                if(xv && SvTYPE(xv) == SVt_PVCV) RETVAL++;
                xv = get_cvn_flags("Devel::PPPort::get_cvn_flags", sizeof("Devel::PPPort::get_cvn_flags")-1, 0);
                if(xv && SvTYPE(xv) == SVt_PVCV) RETVAL++;
#line 1979 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_gv_fetchpvn_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_fetchpvn_flags)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 1110 "RealPPPort.xs"
#if (PERL_BCDVERSION < 0x5009002) || (PERL_BCDVERSION > 0x5009003) /* 5.9.2 and 5.9.3 ignore the length param */
                RETVAL = newRV_inc((SV*)gv_fetchpvn_flags("Devel::PPPort::VERSIONFAKE", sizeof("Devel::PPPort::VERSIONFAKE")-5, 0, SVt_PV));
#else
                RETVAL = newRV_inc((SV*)gv_fetchpvn_flags("Devel::PPPort::VERSION", 0, 0, SVt_PV));
#endif
#line 2000 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_gv_fetchsv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_fetchsv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "name");
    {
	SV *	name = ST(0)
;
	SV *	RETVAL;
#line 1122 "RealPPPort.xs"
                RETVAL = newRV_inc((SV*)gv_fetchsv(name, 0, SVt_PV));
#line 2020 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_gv_init_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_init_type)
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "namesv, multi, flags");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV*	namesv = ST(0)
;
	int	multi = (int)SvIV(ST(1))
;
	I32	flags = (I32)SvIV(ST(2))
;
#line 1132 "RealPPPort.xs"
        HV *defstash = gv_stashpv("main", 0);
        STRLEN len;
        const char * const name = SvPV_const(namesv, len);
        GV *gv = *(GV**)hv_fetch(defstash, name, len, TRUE);
#line 2048 "RealPPPort.c"
#line 1137 "RealPPPort.xs"
        if (SvTYPE(gv) == SVt_PVGV)
            Perl_croak(aTHX_ "GV is already a PVGV");
        if (multi) flags |= GV_ADDMULTI;
        gv_init_pvn(gv, defstash, name, len, flags);
	XPUSHs( gv ? (SV*)gv : &PL_sv_undef);
#line 2055 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_iv_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_iv_size)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	IV	RETVAL;
	dXSTARG;
#line 1150 "RealPPPort.xs"
                RETVAL = IVSIZE == sizeof(IV);
#line 2073 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_uv_size); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_uv_size)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	IV	RETVAL;
	dXSTARG;
#line 1157 "RealPPPort.xs"
                RETVAL = UVSIZE == sizeof(UV);
#line 2091 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_iv_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_iv_type)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	IV	RETVAL;
	dXSTARG;
#line 1164 "RealPPPort.xs"
                RETVAL = sizeof(IVTYPE) == sizeof(IV);
#line 2109 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_uv_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_uv_type)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	IV	RETVAL;
	dXSTARG;
#line 1171 "RealPPPort.xs"
                RETVAL = sizeof(UVTYPE) == sizeof(UV);
#line 2127 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_mPUSHs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mPUSHs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1182 "RealPPPort.xs"
        EXTEND(SP, 3);
        mPUSHs(newSVpv("foo", 0));
        mPUSHs(newSVpv("bar13", 3));
        mPUSHs(newSViv(42));
        XSRETURN(3);
#line 2149 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mPUSHp); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mPUSHp)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1191 "RealPPPort.xs"
        EXTEND(SP, 3);
        mPUSHp("one", 3);
        mPUSHp("two", 3);
        mPUSHp("three", 5);
        XSRETURN(3);
#line 2171 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mPUSHn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mPUSHn)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1200 "RealPPPort.xs"
        EXTEND(SP, 3);
        mPUSHn(0.5);
        mPUSHn(-0.25);
        mPUSHn(0.125);
        XSRETURN(3);
#line 2193 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mPUSHi); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mPUSHi)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1209 "RealPPPort.xs"
        EXTEND(SP, 3);
        mPUSHi(-1);
        mPUSHi(2);
        mPUSHi(-3);
        XSRETURN(3);
#line 2215 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mPUSHu); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mPUSHu)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1218 "RealPPPort.xs"
        EXTEND(SP, 3);
        mPUSHu(1);
        mPUSHu(2);
        mPUSHu(3);
        XSRETURN(3);
#line 2237 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mXPUSHs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mXPUSHs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1227 "RealPPPort.xs"
        mXPUSHs(newSVpv("foo", 0));
        mXPUSHs(newSVpv("bar13", 3));
        mXPUSHs(newSViv(42));
        XSRETURN(3);
#line 2258 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mXPUSHp); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mXPUSHp)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1235 "RealPPPort.xs"
        mXPUSHp("one", 3);
        mXPUSHp("two", 3);
        mXPUSHp("three", 5);
        XSRETURN(3);
#line 2279 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mXPUSHn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mXPUSHn)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1243 "RealPPPort.xs"
        mXPUSHn(0.5);
        mXPUSHn(-0.25);
        mXPUSHn(0.125);
        XSRETURN(3);
#line 2300 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mXPUSHi); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mXPUSHi)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1251 "RealPPPort.xs"
        mXPUSHi(-1);
        mXPUSHi(2);
        mXPUSHi(-3);
        XSRETURN(3);
#line 2321 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_mXPUSHu); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mXPUSHu)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1259 "RealPPPort.xs"
        mXPUSHu(1);
        mXPUSHu(2);
        mXPUSHu(3);
        XSRETURN(3);
#line 2342 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_new_with_other_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_new_with_other_mg)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "package, ...");
    {
	SV *	package = ST(0)
;
#line 1272 "RealPPPort.xs"
    HV *self;
    HV *stash;
    SV *self_ref;
    const char *data = "hello\0";
    MAGIC *mg;
#line 2364 "RealPPPort.c"
	SV *	RETVAL;
#line 1278 "RealPPPort.xs"
    self = newHV();
    stash = gv_stashpv(SvPV_nolen(package), 0);

    self_ref = newRV_noinc((SV*)self);

    sv_magic((SV*)self, NULL, PERL_MAGIC_ext, data, strlen(data));
    mg = mg_find((SV*)self, PERL_MAGIC_ext);
    if (mg)
      mg->mg_virtual = &other_mg_vtbl;
    else
      croak("No mg!");

    RETVAL = sv_bless(self_ref, stash);
#line 2380 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_new_with_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_new_with_mg)
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "package, ...");
    {
	SV *	package = ST(0)
;
#line 1298 "RealPPPort.xs"
    HV *self;
    HV *stash;
    SV *self_ref;
    const char *data = "hello\0";
    MAGIC *mg;
#line 2403 "RealPPPort.c"
	SV *	RETVAL;
#line 1304 "RealPPPort.xs"
    self = newHV();
    stash = gv_stashpv(SvPV_nolen(package), 0);

    self_ref = newRV_noinc((SV*)self);

    sv_magic((SV*)self, NULL, PERL_MAGIC_ext, data, strlen(data));
    mg = mg_find((SV*)self, PERL_MAGIC_ext);
    if (mg)
      mg->mg_virtual = &null_mg_vtbl;
    else
      croak("No mg!");

    RETVAL = sv_bless(self_ref, stash);
#line 2419 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_remove_null_magic); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_remove_null_magic)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	self = ST(0)
;
#line 1324 "RealPPPort.xs"
    HV *obj;
#line 2440 "RealPPPort.c"
#line 1326 "RealPPPort.xs"
    obj = (HV*) SvRV(self);

    sv_unmagicext((SV*)obj, PERL_MAGIC_ext, &null_mg_vtbl);
#line 2445 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_remove_other_magic); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_remove_other_magic)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	self = ST(0)
;
#line 1334 "RealPPPort.xs"
    HV *obj;
#line 2465 "RealPPPort.c"
#line 1336 "RealPPPort.xs"
    obj = (HV*) SvRV(self);

    sv_unmagicext((SV*)obj, PERL_MAGIC_ext, &other_mg_vtbl);
#line 2470 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_as_string); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_as_string)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "self");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	self = ST(0)
;
#line 1344 "RealPPPort.xs"
    HV *obj;
    MAGIC *mg;
#line 2491 "RealPPPort.c"
#line 1347 "RealPPPort.xs"
    obj = (HV*) SvRV(self);

    if ((mg = mg_findext((SV*)obj, PERL_MAGIC_ext, &null_mg_vtbl))) {
        XPUSHs(sv_2mortal(newSVpv(mg->mg_ptr, strlen(mg->mg_ptr))));
    } else {
        XPUSHs(sv_2mortal(newSVpvs("Sorry, your princess is in another castle.")));
    }
#line 2500 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_sv_catpv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catpv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, string");
    {
	SV *	sv = ST(0)
;
	char *	string = (char *)SvPV_nolen(ST(1))
;
#line 1360 "RealPPPort.xs"
                sv_catpv_mg(sv, string);
#line 2520 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_catpvn_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catpvn_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, sv2");
    {
	SV *	sv = ST(0)
;
	SV *	sv2 = ST(1)
;
#line 1367 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 2540 "RealPPPort.c"
#line 1370 "RealPPPort.xs"
                str = SvPV(sv2, len);
                sv_catpvn_mg(sv, str, len);
#line 2544 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_catsv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catsv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, sv2");
    {
	SV *	sv = ST(0)
;
	SV *	sv2 = ST(1)
;
#line 1378 "RealPPPort.xs"
                sv_catsv_mg(sv, sv2);
#line 2563 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setiv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setiv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, iv");
    {
	SV *	sv = ST(0)
;
	IV	iv = (IV)SvIV(ST(1))
;
#line 1385 "RealPPPort.xs"
                sv_setiv_mg(sv, iv);
#line 2582 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setnv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setnv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, nv");
    {
	SV *	sv = ST(0)
;
	NV        nv = (NV)SvNV(ST(1))
;
#line 1392 "RealPPPort.xs"
                sv_setnv_mg(sv, nv);
#line 2601 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setpv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setpv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, pv");
    {
	SV *	sv = ST(0)
;
	char *	pv = (char *)SvPV_nolen(ST(1))
;
#line 1399 "RealPPPort.xs"
                sv_setpv_mg(sv, pv);
#line 2620 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setpvn_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setpvn_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, sv2");
    {
	SV *	sv = ST(0)
;
	SV *	sv2 = ST(1)
;
#line 1406 "RealPPPort.xs"
                char *str;
                STRLEN len;
#line 2640 "RealPPPort.c"
#line 1409 "RealPPPort.xs"
                str = SvPV(sv2, len);
                sv_setpvn_mg(sv, str, len);
#line 2644 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setsv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setsv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, sv2");
    {
	SV *	sv = ST(0)
;
	SV *	sv2 = ST(1)
;
#line 1417 "RealPPPort.xs"
                sv_setsv_mg(sv, sv2);
#line 2663 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setuv_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setuv_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, uv");
    {
	SV *	sv = ST(0)
;
	UV        uv = (UV)SvUV(ST(1))
;
#line 1424 "RealPPPort.xs"
                sv_setuv_mg(sv, uv);
#line 2682 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_usepvn_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_usepvn_mg)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, sv2");
    {
	SV *	sv = ST(0)
;
	SV *	sv2 = ST(1)
;
#line 1431 "RealPPPort.xs"
                char *str, *copy;
                STRLEN len;
#line 2702 "RealPPPort.c"
#line 1434 "RealPPPort.xs"
                str = SvPV(sv2, len);
                New(42, copy, len+1, char);
                Copy(str, copy, len+1, char);
                sv_usepvn_mg(sv, copy, len);
#line 2708 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_SvVSTRING_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvVSTRING_mg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 1443 "RealPPPort.xs"
                RETVAL = SvVSTRING_mg(sv) != NULL;
#line 2727 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_magic_portable); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_magic_portable)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 1451 "RealPPPort.xs"
                MAGIC *mg;
                const char *foo = "foo";
#line 2746 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1454 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                sv_magic_portable(sv, 0, '~', foo, 0);
                mg = mg_find(sv, '~');
                if (!mg)
                  croak("No mg!");

                RETVAL = mg->mg_ptr == foo;
#else
                sv_magic(sv, 0, '~', (char *) foo, strlen(foo));
                mg = mg_find(sv, '~');
                RETVAL = strEQ(mg->mg_ptr, foo);
#endif
                sv_unmagic(sv, '~');
#line 2763 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_checkmem); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_checkmem)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1477 "RealPPPort.xs"
    char *p;

#line 2780 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1480 "RealPPPort.xs"
    RETVAL = 0;
    Newx(p, 6, char);
    CopyD("Hello", p, 6, char);
    if (memEQ(p, "Hello", 6))
      RETVAL++;
    ZeroD(p, 6, char);
    if (memEQ(p, "\0\0\0\0\0\0", 6))
      RETVAL++;
    if (memEQs(p, 6, "\0\0\0\0\0\0"))
      RETVAL++;
    Poison(p, 6, char);
    if (memNE(p, "\0\0\0\0\0\0", 6))
      RETVAL++;
    if (memNEs(p, 6, "\0\0\0\0\0\0"))
      RETVAL++;
    Safefree(p);

    Newxz(p, 6, char);
    if (memEQ(p, "\0\0\0\0\0\0", 6))
      RETVAL++;
    Safefree(p);

    Newxc(p, 3, short, char);
    Safefree(p);

#line 2809 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_croak_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_croak_sv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 1516 "RealPPPort.xs"
    croak_sv(sv);
#line 2827 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_die_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_die_sv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 1522 "RealPPPort.xs"
    (void)die_sv(sv);
#line 2844 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_warn_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_warn_sv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 1528 "RealPPPort.xs"
    warn_sv(sv);
#line 2861 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_mess_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_mess_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "sv, consume");
    {
	SV *	sv = ST(0)
;
	bool	consume = (bool)SvTRUE(ST(1))
;
	SV *	RETVAL;
#line 1535 "RealPPPort.xs"
    RETVAL = newSVsv(mess_sv(sv, consume));
#line 2881 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_croak_no_modify); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_croak_no_modify)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1542 "RealPPPort.xs"
    croak_no_modify();
#line 2898 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_croak_memory_wrap); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_croak_memory_wrap)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1547 "RealPPPort.xs"
    croak_memory_wrap();
#line 2913 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_croak_xs_usage); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_croak_xs_usage)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "params");
    {
	char *	params = (char *)SvPV_nolen(ST(0))
;
#line 1553 "RealPPPort.xs"
    croak_xs_usage(cv, params);
#line 2930 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_OpSIBLING_tests); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_OpSIBLING_tests)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1562 "RealPPPort.xs"
		OP *x;
		OP *kid;
		OP *lastkid;
		int count = 0;
		int failures = 0;
		int i;
#line 2950 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1569 "RealPPPort.xs"
		x = newOP(OP_PUSHMARK, 0);

		/* No siblings yet! */
		if (OpHAS_SIBLING(x) || OpSIBLING(x)) {
			failures++; warn("Op should not have had a sib");
		}


		/* Add 2 siblings */
		kid = x;

		for (i = 0; i < 2; i++) {
			OP *newsib = newOP(OP_PUSHMARK, 0);
			OpMORESIB_set(kid, newsib);

			kid = OpSIBLING(kid);
			lastkid = kid;
		}

		/* Should now have a sibling */
		if (! OpHAS_SIBLING(x) || ! OpSIBLING(x) ) {
			failures++; warn("Op should have had a sib after moresib_set");
		}

		/* Count the siblings */
		for (kid = OpSIBLING(x); kid; kid = OpSIBLING(kid)) {
			count++;
		}

		if (count != 2) {
			failures++; warn("Kid had %d sibs, expected 2", count);
		}

		if (OpHAS_SIBLING(lastkid) || OpSIBLING(lastkid)) {
			failures++; warn("Last kid should not have a sib");
		}

		/* Really sets the parent, and says 'no more siblings' */
		OpLASTSIB_set(x, lastkid);

		if (OpHAS_SIBLING(x) || OpSIBLING(x)) {
			failures++; warn("OpLASTSIB_set failed?");
		}

		/* Restore the kid */
		OpMORESIB_set(x, lastkid);

		/* Try to remove it again */
		OpLASTSIB_set(x, NULL);

		if (OpHAS_SIBLING(x) || OpSIBLING(x)) {
			failures++; warn("OpLASTSIB_set with NULL failed?");
		}

		/* Try to restore with maybesib_set */
		OpMAYBESIB_set(x, lastkid, NULL);

		if (! OpHAS_SIBLING(x) || ! OpSIBLING(x) ) {
			failures++; warn("Op should have had a sib after maybesibset");
		}

		RETVAL = failures;
#line 3016 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvRXOK); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvRXOK)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	int	RETVAL;
	dXSTARG;
#line 1638 "RealPPPort.xs"
		RETVAL = SvRXOK(sv);
#line 3036 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_ptrtests); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_ptrtests)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1645 "RealPPPort.xs"
                int var, *p = &var;

#line 3053 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1648 "RealPPPort.xs"
                RETVAL = 0;
                RETVAL += PTR2nat(p) != 0       ?  1 : 0;
                RETVAL += PTR2ul(p) != 0UL      ?  2 : 0;
                RETVAL += PTR2UV(p) != (UV) 0   ?  4 : 0;
                RETVAL += PTR2IV(p) != (IV) 0   ?  8 : 0;
                RETVAL += PTR2NV(p) != (NV) 0   ? 16 : 0;
                RETVAL += p > NUM2PTR(int *, 0) ? 32 : 0;

#line 3065 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_gv_stashpvn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_stashpvn)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name, create");
    {
	char *	name = (char *)SvPV_nolen(ST(0))
;
	I32	create = (I32)SvIV(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1664 "RealPPPort.xs"
                RETVAL = gv_stashpvn(name, strlen(name), create) != NULL;
#line 3087 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_sv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name, create");
    {
	char *	name = (char *)SvPV_nolen(ST(0))
;
	I32	create = (I32)SvIV(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1673 "RealPPPort.xs"
                RETVAL = get_sv(name, create) != NULL;
#line 3109 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_av); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_av)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name, create");
    {
	char *	name = (char *)SvPV_nolen(ST(0))
;
	I32	create = (I32)SvIV(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1682 "RealPPPort.xs"
                RETVAL = get_av(name, create) != NULL;
#line 3131 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_hv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_hv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name, create");
    {
	char *	name = (char *)SvPV_nolen(ST(0))
;
	I32	create = (I32)SvIV(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1691 "RealPPPort.xs"
                RETVAL = get_hv(name, create) != NULL;
#line 3153 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_cv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_cv)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "name, create");
    {
	char *	name = (char *)SvPV_nolen(ST(0))
;
	I32	create = (I32)SvIV(ST(1))
;
	int	RETVAL;
	dXSTARG;
#line 1700 "RealPPPort.xs"
                RETVAL = get_cv(name, create) != NULL;
#line 3175 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_xsreturn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_xsreturn)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "two");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	int	two = (int)SvIV(ST(0))
;
#line 1708 "RealPPPort.xs"
                mXPUSHp("test1", 5);
                if (two)
                  mXPUSHp("test2", 5);
                if (two)
                  XSRETURN(2);
                else
                  XSRETURN(1);
#line 3201 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_boolSV); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_boolSV)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "value");
    {
	int	value = (int)SvIV(ST(0))
;
	SV *	RETVAL;
#line 1720 "RealPPPort.xs"
                RETVAL = newSVsv(boolSV(value));
#line 3220 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_DEFSV); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_DEFSV)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 1727 "RealPPPort.xs"
                RETVAL = newSVsv(DEFSV);
#line 3238 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_DEFSV_modify); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_DEFSV_modify)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1734 "RealPPPort.xs"
                XPUSHs(sv_mortalcopy(DEFSV));
                ENTER;
                SAVE_DEFSV;
                DEFSV_set(newSVpvs("DEFSV"));
                XPUSHs(sv_mortalcopy(DEFSV));
                /* Yes, this leaks the above scalar; 5.005 with threads for some reason */
                /* frees it upon LEAVE, thus mortalizing it causes "attempt to free..." */
                /* sv_2mortal(DEFSV); */
                LEAVE;
                XPUSHs(sv_mortalcopy(DEFSV));
                XSRETURN(3);
#line 3267 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_ERRSV); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_ERRSV)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	int	RETVAL;
	dXSTARG;
#line 1749 "RealPPPort.xs"
                RETVAL = SvTRUE(ERRSV);
#line 3285 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_UNDERBAR); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_UNDERBAR)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 1756 "RealPPPort.xs"
                {
                  dUNDERBAR;
                  RETVAL = newSVsv(UNDERBAR);
                }
#line 3305 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_prepush); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_prepush)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1766 "RealPPPort.xs"
                {
                  dXSTARG;
                  XSprePUSH;
                  PUSHi(42);
                  XSRETURN(1);
                }
#line 3327 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_PERL_ABS); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PERL_ABS)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "a");
    {
	int	a = (int)SvIV(ST(0))
;
	int	RETVAL;
	dXSTARG;

	RETVAL = PERL_ABS(a);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SVf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SVf)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "x");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	x = ST(0)
;
#line 1781 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                x = sv_2mortal(newSVpvf("[%" SVf "]", SVfARG(x)));
#endif
                XPUSHs(x);
                XSRETURN(1);
#line 3369 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_Perl_ppaddr_t); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_ppaddr_t)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char *	string = (char *)SvPV_nolen(ST(0))
;
#line 1791 "RealPPPort.xs"
                Perl_ppaddr_t lower;
#line 3389 "RealPPPort.c"
#line 1793 "RealPPPort.xs"
                lower = PL_ppaddr[OP_LC];
                mXPUSHs(newSVpv(string, 0));
                PUTBACK;
                ENTER;
                (void)*(lower)(aTHXR);
                SPAGAIN;
                LEAVE;
                XSRETURN(1);
#line 3399 "RealPPPort.c"
	PUTBACK;
	return;
    }
}

#if (PERL_BCDVERSION >= 0x5008000)
#define XSubPPtmpAAAB 1


XS_EUPXS(XS_Devel__PPPort_check_HeUTF8); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_check_HeUTF8)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "utf8_key");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	utf8_key = ST(0)
;
#line 1808 "RealPPPort.xs"
                HV *hash;
                HE *ent;
                STRLEN klen;
                char *key;
#line 3425 "RealPPPort.c"
#line 1813 "RealPPPort.xs"
                hash = newHV();

                key = SvPV(utf8_key, klen);
                if (SvUTF8(utf8_key)) klen *= -1;
                hv_store(hash, key, klen, newSVpvs("string"), 0);
                hv_iterinit(hash);
                ent = hv_iternext(hash);
                assert(ent);
                mXPUSHp((HeUTF8(ent) == 0 ? "norm" : "utf8"), 4);
                hv_undef(hash);
#line 3437 "RealPPPort.c"
	PUTBACK;
	return;
    }
}

#endif

XS_EUPXS(XS_Devel__PPPort_check_c_array); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_check_c_array)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1830 "RealPPPort.xs"
                int x[] = { 10, 11, 12, 13 };
#line 3456 "RealPPPort.c"
#line 1832 "RealPPPort.xs"
                mXPUSHi(C_ARRAY_LENGTH(x));  /* 4 */
                mXPUSHi(*(C_ARRAY_END(x)-1)); /* 13 */
#line 3460 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_1); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_1)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	call_newCONSTSUB_1();
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_2); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_2)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	call_newCONSTSUB_2();
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_3); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_call_newCONSTSUB_3)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {

	call_newCONSTSUB_3();
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_newRV_inc_REFCNT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newRV_inc_REFCNT)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1855 "RealPPPort.xs"
                SV *sv, *rv;
#line 3518 "RealPPPort.c"
	U32	RETVAL;
	dXSTARG;
#line 1857 "RealPPPort.xs"
                sv = newSViv(42);
                rv = newRV_inc(sv);
                SvREFCNT_dec(sv);
                RETVAL = SvREFCNT(sv);
                sv_2mortal(rv);
#line 3527 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_newRV_noinc_REFCNT); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newRV_noinc_REFCNT)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1868 "RealPPPort.xs"
                SV *sv, *rv;
#line 3543 "RealPPPort.c"
	U32	RETVAL;
	dXSTARG;
#line 1870 "RealPPPort.xs"
                sv = newSViv(42);
                rv = newRV_noinc(sv);
                RETVAL = SvREFCNT(sv);
                sv_2mortal(rv);
#line 3551 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_newSV_type); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSV_type)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 1884 "RealPPPort.xs"
                SV* sv;
#line 3567 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 1886 "RealPPPort.xs"
                RETVAL = 0;
                sv = newSV_type(SVt_NULL);
                if (SvTYPE(sv) == SVt_NULL)
                {
                  RETVAL++;
                }
                SvREFCNT_dec(sv);

                sv = newSV_type(SVt_PVIV);
                if (SvTYPE(sv) == SVt_PVIV)
                {
                  RETVAL++;
                }
                SvREFCNT_dec(sv);

                sv = newSV_type(SVt_PVHV);
                if (SvTYPE(sv) == SVt_PVHV)
                {
                  RETVAL++;
                }
                SvREFCNT_dec(sv);

                sv = newSV_type(SVt_PVAV);
                if (SvTYPE(sv) == SVt_PVAV)
                {
                  RETVAL++;
                }
                SvREFCNT_dec(sv);
#line 3599 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_newSVpvn); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvn)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1924 "RealPPPort.xs"
                mXPUSHs(newSVpvn("test", 4));
                mXPUSHs(newSVpvn("test", 2));
                mXPUSHs(newSVpvn("test", 0));
                mXPUSHs(newSVpvn(NULL, 2));
                mXPUSHs(newSVpvn(NULL, 0));
                XSRETURN(5);
#line 3622 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_newSVpvn_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvn_flags)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1934 "RealPPPort.xs"
                XPUSHs(newSVpvn_flags("test", 4, SVs_TEMP));
                XPUSHs(newSVpvn_flags("test", 2, SVs_TEMP));
                XPUSHs(newSVpvn_flags("test", 0, SVs_TEMP));
                XPUSHs(newSVpvn_flags(NULL, 2, SVs_TEMP));
                XPUSHs(newSVpvn_flags(NULL, 0, SVs_TEMP));
                XSRETURN(5);
#line 3645 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_newSVpvn_utf8); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvn_utf8)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1944 "RealPPPort.xs"
                XPUSHs(newSVpvn_flags("test", 4, SVs_TEMP|SVf_UTF8));
                XSRETURN(1);
#line 3664 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_pv_escape_can_unicode); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_pv_escape_can_unicode)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1954 "RealPPPort.xs"
#if defined(is_utf8_string) && defined(utf8_to_uvchr)
                XSRETURN_YES;
#else
                XSRETURN_NO;
#endif
#line 3686 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_pv_pretty); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_pv_pretty)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1963 "RealPPPort.xs"
                char *rv;
#line 3704 "RealPPPort.c"
#line 1965 "RealPPPort.xs"
                EXTEND(SP, 8);
                ST(0) = sv_newmortal();
                rv = pv_pretty(ST(0), "foobarbaz",
                                9, 40, NULL, NULL, 0);
                ST(1) = sv_2mortal(newSVpv(rv, 0));
                ST(2) = sv_newmortal();
                rv = pv_pretty(ST(2), "pv_p\retty\n",
                                10, 40, "left", "right", PERL_PV_PRETTY_LTGT);
                ST(3) = sv_2mortal(newSVpv(rv, 0));
                ST(4) = sv_newmortal();
                rv = pv_pretty(ST(4), "N\303\275 Batter\303\255",
                                12, 20, NULL, NULL, PERL_PV_ESCAPE_UNI_DETECT);
                ST(5) = sv_2mortal(newSVpv(rv, 0));
                ST(6) = sv_newmortal();
                rv = pv_pretty(ST(6), "\303\201g\303\246tis Byrjun",
                                15, 18, NULL, NULL, PERL_PV_ESCAPE_UNI_DETECT|PERL_PV_PRETTY_ELLIPSES);
                ST(7) = sv_2mortal(newSVpv(rv, 0));
                XSRETURN(8);
#line 3724 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_pv_display); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_pv_display)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 1987 "RealPPPort.xs"
                char *rv;
#line 3742 "RealPPPort.c"
#line 1989 "RealPPPort.xs"
                EXTEND(SP, 4);
                ST(0) = sv_newmortal();
                rv = pv_display(ST(0), "foob\0rbaz", 9, 10, 20);
                ST(1) = sv_2mortal(newSVpv(rv, 0));
                ST(2) = sv_newmortal();
                rv = pv_display(ST(2), "pv_display", 10, 11, 5);
                ST(3) = sv_2mortal(newSVpv(rv, 0));
                XSRETURN(4);
#line 3752 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_newSVpvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2005 "RealPPPort.xs"
                mXPUSHs(newSVpvs("newSVpvs"));
                XSRETURN(1);
#line 3771 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_newSVpvs_flags); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvs_flags)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2011 "RealPPPort.xs"
                XPUSHs(newSVpvs_flags("newSVpvs_flags", SVs_TEMP));
                XSRETURN(1);
#line 3790 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_newSVpvs_share); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvs_share)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2017 "RealPPPort.xs"
                SV *sv;
                U32 hash;
#line 3807 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 2020 "RealPPPort.xs"
                RETVAL = 0;
                PERL_HASH(hash, "pvs", 3);
                sv = newSVpvs_share("pvs");
                RETVAL += strEQ(SvPV_nolen_const(sv), "pvs");
                RETVAL += SvCUR(sv) == 3;
                RETVAL += SvSHARED_HASH(sv) == hash;
                SvREFCNT_dec(sv);
#line 3818 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_catpvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catpvs)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	sv = ST(0)
;
#line 2034 "RealPPPort.xs"
                sv_catpvs(sv, "sv_catpvs");
#line 3838 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_sv_setpvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setpvs)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	sv = ST(0)
;
#line 2040 "RealPPPort.xs"
                sv_setpvs(sv, "sv_setpvs");
#line 3858 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_hv_fetchs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_hv_fetchs)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "hv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	hv = ST(0)
;
#line 2046 "RealPPPort.xs"
                SV **s;
#line 3878 "RealPPPort.c"
#line 2048 "RealPPPort.xs"
                s = hv_fetchs((HV *) SvRV(hv), "hv_fetchs", 0);
                XPUSHs(sv_mortalcopy(*s));
                XSRETURN(1);
#line 3883 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_hv_stores); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_hv_stores)
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "hv, sv");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	hv = ST(0)
;
	SV *	sv = ST(1)
;
#line 2057 "RealPPPort.xs"
                (void) hv_stores((HV *) SvRV(hv), "hv_stores", SvREFCNT_inc_simple(sv));
#line 3905 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_gv_fetchpvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_fetchpvs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2062 "RealPPPort.xs"
                RETVAL = newRV_inc((SV*)gv_fetchpvs("Devel::PPPort::VERSION", 0, SVt_PV));
#line 3922 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_gv_stashpvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_gv_stashpvs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2069 "RealPPPort.xs"
                RETVAL = newRV_inc((SV*)gv_stashpvs("Devel::PPPort", 0));
#line 3940 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_get_cvs); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_get_cvs)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2076 "RealPPPort.xs"
                CV* xv;
#line 3957 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 2078 "RealPPPort.xs"
                RETVAL = 0;
                xv = get_cvs("Devel::PPPort::foobar", 0);
                if(xv == NULL) RETVAL++;
                xv = get_cvs("Devel::PPPort::foobar", GV_ADDMULTI);
                if(xv && SvTYPE(xv) == SVt_PVCV) RETVAL++;
                xv = get_cvs("Devel::PPPort::get_cvs", 0);
                if(xv && SvTYPE(xv) == SVt_PVCV) RETVAL++;
#line 3968 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_newSVpvn_share); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVpvn_share)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2095 "RealPPPort.xs"
                const char *s;
                SV *sv;
                STRLEN len;
                U32 hash;
#line 3987 "RealPPPort.c"
	int	RETVAL;
	dXSTARG;
#line 2100 "RealPPPort.xs"
                RETVAL = 0;
                s = "mhx";
                len = 3;
                PERL_HASH(hash, (char *) s, len);
                sv = newSVpvn_share(s, len, 0);
                s = 0;
                RETVAL += strEQ(SvPV_nolen_const(sv), "mhx");
                RETVAL += SvCUR(sv) == len;
                RETVAL += SvSHARED_HASH(sv) == hash;
                SvREFCNT_dec(sv);
                s = "foobar";
                len = 6;
                PERL_HASH(hash, (char *) s, len);
                sv = newSVpvn_share(s, -(I32) len, hash);
                s = 0;
                RETVAL += strEQ(SvPV_nolen_const(sv), "foobar");
                RETVAL += SvCUR(sv) == len;
                RETVAL += SvSHARED_HASH(sv) == hash;
                SvREFCNT_dec(sv);
#line 4010 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_my_snprintf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_my_snprintf)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2129 "RealPPPort.xs"
                char buf[128];
                int len;
#line 4029 "RealPPPort.c"
#line 2132 "RealPPPort.xs"
                len = my_snprintf(buf, sizeof buf, "foo%s%d", "bar", 42);
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                XSRETURN(2);
#line 4035 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_my_sprintf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_my_sprintf)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2144 "RealPPPort.xs"
                char buf[128];
                int len;
#line 4054 "RealPPPort.c"
#line 2147 "RealPPPort.xs"
                len = my_sprintf(buf, "foo%s%d", "bar", 42);
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                XSRETURN(2);
#line 4060 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_my_strlfunc); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_my_strlfunc)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2159 "RealPPPort.xs"
                char buf[8];
                int len;
#line 4079 "RealPPPort.c"
#line 2162 "RealPPPort.xs"
                len = my_strlcpy(buf, "foo", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                len = my_strlcat(buf, "bar", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                len = my_strlcat(buf, "baz", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                len = my_strlcpy(buf, "1234567890", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                len = my_strlcpy(buf, "1234", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                len = my_strlcat(buf, "567890123456", sizeof(buf));
                mXPUSHi(len);
                mXPUSHs(newSVpv(buf, 0));
                XSRETURN(12);
#line 4100 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_vnewSVpvf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_vnewSVpvf)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2189 "RealPPPort.xs"
                RETVAL = test_vnewSVpvf(aTHX_ "%s-%d", "Perl", 42);
#line 4117 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_vcatpvf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_vcatpvf)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	SV *	RETVAL;
#line 2197 "RealPPPort.xs"
                RETVAL = newSVsv(sv);
                test_sv_vcatpvf(aTHX_ RETVAL, "%s-%d", "Perl", 42);
#line 4138 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_vsetpvf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_vsetpvf)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	SV *	RETVAL;
#line 2206 "RealPPPort.xs"
                RETVAL = newSVsv(sv);
                test_sv_vsetpvf(aTHX_ RETVAL, "%s-%d", "Perl", 42);
#line 4159 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_catpvf_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catpvf_mg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2215 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                sv_catpvf_mg(sv, "%s-%d", "Perl", 42);
#endif
#line 4180 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_Perl_sv_catpvf_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_sv_catpvf_mg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2223 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                Perl_sv_catpvf_mg(aTHX_ sv, "%s-%d", "-Perl", 43);
#endif
#line 4199 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_catpvf_mg_nocontext); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_catpvf_mg_nocontext)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2231 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
#ifdef PERL_IMPLICIT_CONTEXT
                sv_catpvf_mg_nocontext(sv, "%s-%d", "-Perl", 44);
#else
                sv_catpvf_mg(sv, "%s-%d", "-Perl", 44);
#endif
#endif
#line 4222 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setpvf_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setpvf_mg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2243 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                sv_setpvf_mg(sv, "%s-%d", "mhx", 42);
#endif
#line 4241 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_Perl_sv_setpvf_mg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_sv_setpvf_mg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2251 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                Perl_sv_setpvf_mg(aTHX_ sv, "%s-%d", "foo", 43);
#endif
#line 4260 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_sv_setpvf_mg_nocontext); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setpvf_mg_nocontext)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
#line 2259 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
#ifdef PERL_IMPLICIT_CONTEXT
                sv_setpvf_mg_nocontext(sv, "%s-%d", "bar", 44);
#else
                sv_setpvf_mg(sv, "%s-%d", "bar", 44);
#endif
#endif
#line 4283 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_no_THX_arg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_no_THX_arg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	IV	RETVAL;
	dXSTARG;
#line 2275 "RealPPPort.xs"
                RETVAL = 1 + sv_2iv(sv);
#line 4302 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_with_THX_arg); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_with_THX_arg)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "error");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SV *	error = ST(0)
;
#line 2283 "RealPPPort.xs"
                croak_sv(error);
#line 4322 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_sv_setuv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_setuv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "uv");
    {
	UV        uv = (UV)SvUV(ST(0))
;
	SV *	RETVAL;
#line 2293 "RealPPPort.xs"
                RETVAL = newSViv(1);
                sv_setuv(RETVAL, uv);
#line 4342 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_newSVuv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_newSVuv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "uv");
    {
	UV        uv = (UV)SvUV(ST(0))
;
	SV *	RETVAL;
#line 2302 "RealPPPort.xs"
                RETVAL = newSVuv(uv);
#line 4362 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_sv_2uv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_sv_2uv)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	UV	RETVAL;
	dXSTARG;
#line 2310 "RealPPPort.xs"
                RETVAL = sv_2uv(sv);
#line 4383 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_SvUVx); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_SvUVx)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "sv");
    {
	SV *	sv = ST(0)
;
	UV	RETVAL;
	dXSTARG;
#line 2318 "RealPPPort.xs"
                sv--;
                RETVAL = SvUVx(++sv);
#line 4404 "RealPPPort.c"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_XSRETURN_UV); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_XSRETURN_UV)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2326 "RealPPPort.xs"
                XSRETURN_UV(42);
#line 4422 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_PUSHu); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PUSHu)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2331 "RealPPPort.xs"
                dTARG;
#line 4440 "RealPPPort.c"
#line 2333 "RealPPPort.xs"
                TARG = sv_newmortal();
                EXTEND(SP, 1);
                PUSHu(42);
                XSRETURN(1);
#line 4446 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_XPUSHu); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_XPUSHu)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2341 "RealPPPort.xs"
                dTARG;
#line 4464 "RealPPPort.c"
#line 2343 "RealPPPort.xs"
                TARG = sv_newmortal();
                XPUSHu(43);
                XSRETURN(1);
#line 4469 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_compare_PL_signals); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_compare_PL_signals)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	int	RETVAL;
	dXSTARG;
#line 2354 "RealPPPort.xs"
                {
                  U32 ref = get_PL_signals_1();
                  RETVAL = ref == get_PL_signals_2() && ref == get_PL_signals_3();
                }
#line 4490 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_sv_undef); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_sv_undef)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2364 "RealPPPort.xs"
                RETVAL = newSVsv(&PL_sv_undef);
#line 4507 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_sv_yes); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_sv_yes)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2371 "RealPPPort.xs"
                RETVAL = newSVsv(&PL_sv_yes);
#line 4525 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_sv_no); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_sv_no)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2378 "RealPPPort.xs"
                RETVAL = newSVsv(&PL_sv_no);
#line 4543 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_na); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_na)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    {
	char *	string = (char *)SvPV_nolen(ST(0))
;
	int	RETVAL;
	dXSTARG;
#line 2386 "RealPPPort.xs"
                PL_na = strlen(string);
                RETVAL = PL_na;
#line 4565 "RealPPPort.c"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_Sv); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_Sv)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2394 "RealPPPort.xs"
                PL_Sv = newSVpv("mhx", 0);
                RETVAL = PL_Sv;
#line 4583 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_tokenbuf); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_tokenbuf)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2402 "RealPPPort.xs"
                RETVAL = newSViv(PL_tokenbuf[0]);
#line 4601 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_parser); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_parser)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2409 "RealPPPort.xs"
                RETVAL = newSViv(PL_parser != NULL);
#line 4619 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_hexdigit); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_hexdigit)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2416 "RealPPPort.xs"
                RETVAL = newSVpv((char *) PL_hexdigit, 0);
#line 4637 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_hints); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_hints)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	SV *	RETVAL;
#line 2423 "RealPPPort.xs"
                RETVAL = newSViv((IV) PL_hints);
#line 4655 "RealPPPort.c"
	RETVAL = sv_2mortal(RETVAL);
	ST(0) = RETVAL;
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_PL_ppaddr); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_PL_ppaddr)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "string");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	char *	string = (char *)SvPV_nolen(ST(0))
;
#line 2431 "RealPPPort.xs"
                PUSHMARK(SP);
                mXPUSHs(newSVpv(string, 0));
                PUTBACK;
                ENTER;
                (void)*(PL_ppaddr[OP_UC])(aTHXR);
                SPAGAIN;
                LEAVE;
                XSRETURN(1);
#line 4683 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_other_variables); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_other_variables)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
#line 2443 "RealPPPort.xs"
                int count = 0;
#line 4701 "RealPPPort.c"
#line 2445 "RealPPPort.xs"
                ppp_TESTVAR(PL_DBsignal);
                ppp_TESTVAR(PL_DBsingle);
                ppp_TESTVAR(PL_DBsub);
                ppp_TESTVAR(PL_DBtrace);
                ppp_TESTVAR(PL_compiling);
                ppp_TESTVAR(PL_curcop);
                ppp_TESTVAR(PL_curstash);
                ppp_TESTVAR(PL_debstash);
                ppp_TESTVAR(PL_defgv);
                ppp_TESTVAR(PL_diehook);
#if (PERL_BCDVERSION >= 0x5013007)
                /* can't get a pointer any longer */
                mXPUSHi(PL_dirty ? 1 : 1);
                count++;
#else
                ppp_TESTVAR(PL_dirty);
#endif
                ppp_TESTVAR(PL_dowarn);
                ppp_TESTVAR(PL_errgv);
                ppp_TESTVAR(PL_laststatval);
                ppp_TESTVAR(PL_no_modify);
                ppp_TESTVAR(PL_perl_destruct_level);
                ppp_TESTVAR(PL_perldb);
                ppp_TESTVAR(PL_stack_base);
                ppp_TESTVAR(PL_stack_sp);
                ppp_TESTVAR(PL_statcache);
                ppp_TESTVAR(PL_stdingv);
                ppp_TESTVAR(PL_sv_arenaroot);
                ppp_TESTVAR(PL_tainted);
                ppp_TESTVAR(PL_tainting);

                ppp_PARSERVAR(ppp_expect_t, PL_expect);
                ppp_PARSERVAR(line_t, PL_copline);
                ppp_PARSERVAR(ppp_rsfp_t, PL_rsfp);
                ppp_PARSERVAR(AV *, PL_rsfp_filters);
                ppp_PARSERVAR(SV *, PL_linestr);
                ppp_PARSERVAR(char *, PL_bufptr);
                ppp_PARSERVAR(char *, PL_bufend);
                ppp_PARSERVAR(ppp_lex_state_t, PL_lex_state);
                ppp_PARSERVAR(SV *, PL_lex_stuff);
                ppp_PARSERVAR(ppp_error_count_t, PL_error_count);
                ppp_PARSERVAR(ppp_in_my_t, PL_in_my);
#if (PERL_BCDVERSION >= 0x5005000)
                ppp_PARSERVAR(HV*, PL_in_my_stash);
#else
                ppp_PARSERVAR_dummy;
#endif
                XSRETURN(count);
#line 4751 "RealPPPort.c"
	PUTBACK;
	return;
    }
}


XS_EUPXS(XS_Devel__PPPort_no_dummy_parser_vars); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_no_dummy_parser_vars)
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "check");
    {
	int	check = (int)SvIV(ST(0))
;
	int	RETVAL;
	dXSTARG;

	RETVAL = no_dummy_parser_vars(check);
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


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

	RETVAL = dummy_parser_warning();
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}


XS_EUPXS(XS_Devel__PPPort_warner); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_warner)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2508 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                warner(packWARN(WARN_MISC), "warner %s:%d", "bar", 42);
#endif
#line 4805 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_Perl_warner); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_warner)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2515 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                Perl_warner(aTHX_ packWARN(WARN_MISC), "Perl_warner %s:%d", "bar", 42);
#endif
#line 4822 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_Perl_warner_nocontext); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_Perl_warner_nocontext)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2522 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                Perl_warner_nocontext(packWARN(WARN_MISC), "Perl_warner_nocontext %s:%d", "bar", 42);
#endif
#line 4839 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}


XS_EUPXS(XS_Devel__PPPort_ckWARN); /* prototype to pass -Wmissing-prototypes */
XS_EUPXS(XS_Devel__PPPort_ckWARN)
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
#line 2529 "RealPPPort.xs"
#if (PERL_BCDVERSION >= 0x5004000)
                if (ckWARN(WARN_MISC))
                  Perl_warner_nocontext(packWARN(WARN_MISC), "ckWARN %s:%d", "bar", 42);
#endif
#line 4857 "RealPPPort.c"
    }
    XSRETURN_EMPTY;
}

#ifdef __cplusplus
extern "C"
#endif
XS_EXTERNAL(boot_Devel__PPPort); /* prototype to pass -Wmissing-prototypes */
XS_EXTERNAL(boot_Devel__PPPort)
{
#if PERL_VERSION_LE(5, 21, 5)
    dVAR; dXSARGS;
#else
    dVAR; dXSBOOTARGSXSAPIVERCHK;
#endif
#if (PERL_REVISION == 5 && PERL_VERSION < 9)
    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("Devel::PPPort::HvNAME_get", XS_Devel__PPPort_HvNAME_get);
        newXS_deffile("Devel::PPPort::HvNAMELEN_get", XS_Devel__PPPort_HvNAMELEN_get);
        newXS_deffile("Devel::PPPort::MY_CXT_1", XS_Devel__PPPort_MY_CXT_1);
        newXS_deffile("Devel::PPPort::MY_CXT_2", XS_Devel__PPPort_MY_CXT_2);
        newXS_deffile("Devel::PPPort::MY_CXT_CLONE", XS_Devel__PPPort_MY_CXT_CLONE);
        newXS_deffile("Devel::PPPort::SvPVbyte", XS_Devel__PPPort_SvPVbyte);
        newXS_deffile("Devel::PPPort::SvPV_nolen", XS_Devel__PPPort_SvPV_nolen);
        newXS_deffile("Devel::PPPort::SvPV_const", XS_Devel__PPPort_SvPV_const);
        newXS_deffile("Devel::PPPort::SvPV_mutable", XS_Devel__PPPort_SvPV_mutable);
        newXS_deffile("Devel::PPPort::SvPV_flags", XS_Devel__PPPort_SvPV_flags);
        newXS_deffile("Devel::PPPort::SvPV_flags_const", XS_Devel__PPPort_SvPV_flags_const);
        newXS_deffile("Devel::PPPort::SvPV_flags_const_nolen", XS_Devel__PPPort_SvPV_flags_const_nolen);
        newXS_deffile("Devel::PPPort::SvPV_flags_mutable", XS_Devel__PPPort_SvPV_flags_mutable);
        newXS_deffile("Devel::PPPort::SvPV_force", XS_Devel__PPPort_SvPV_force);
        newXS_deffile("Devel::PPPort::SvPV_force_nolen", XS_Devel__PPPort_SvPV_force_nolen);
        newXS_deffile("Devel::PPPort::SvPV_force_mutable", XS_Devel__PPPort_SvPV_force_mutable);
        newXS_deffile("Devel::PPPort::SvPV_force_nomg", XS_Devel__PPPort_SvPV_force_nomg);
        newXS_deffile("Devel::PPPort::SvPV_force_nomg_nolen", XS_Devel__PPPort_SvPV_force_nomg_nolen);
        newXS_deffile("Devel::PPPort::SvPV_force_flags", XS_Devel__PPPort_SvPV_force_flags);
        newXS_deffile("Devel::PPPort::SvPV_force_flags_nolen", XS_Devel__PPPort_SvPV_force_flags_nolen);
        newXS_deffile("Devel::PPPort::SvPV_force_flags_mutable", XS_Devel__PPPort_SvPV_force_flags_mutable);
        newXS_deffile("Devel::PPPort::SvPV_nolen_const", XS_Devel__PPPort_SvPV_nolen_const);
        newXS_deffile("Devel::PPPort::SvPV_nomg", XS_Devel__PPPort_SvPV_nomg);
        newXS_deffile("Devel::PPPort::SvPV_nomg_const", XS_Devel__PPPort_SvPV_nomg_const);
        newXS_deffile("Devel::PPPort::SvPV_nomg_const_nolen", XS_Devel__PPPort_SvPV_nomg_const_nolen);
        newXS_deffile("Devel::PPPort::SvPV_nomg_nolen", XS_Devel__PPPort_SvPV_nomg_nolen);
        newXS_deffile("Devel::PPPort::SvPV_renew", XS_Devel__PPPort_SvPV_renew);
        newXS_deffile("Devel::PPPort::SvREFCNT", XS_Devel__PPPort_SvREFCNT);
        newXS_deffile("Devel::PPPort::TestSvUV_set", XS_Devel__PPPort_TestSvUV_set);
        newXS_deffile("Devel::PPPort::TestSvPVX_const", XS_Devel__PPPort_TestSvPVX_const);
        newXS_deffile("Devel::PPPort::TestSvPVX_mutable", XS_Devel__PPPort_TestSvPVX_mutable);
        newXS_deffile("Devel::PPPort::TestSvSTASH_set", XS_Devel__PPPort_TestSvSTASH_set);
        newXS_deffile("Devel::PPPort::G_SCALAR", XS_Devel__PPPort_G_SCALAR);
        newXS_deffile("Devel::PPPort::G_ARRAY", XS_Devel__PPPort_G_ARRAY);
        newXS_deffile("Devel::PPPort::G_DISCARD", XS_Devel__PPPort_G_DISCARD);
        newXS_deffile("Devel::PPPort::eval_sv", XS_Devel__PPPort_eval_sv);
        newXS_deffile("Devel::PPPort::eval_pv", XS_Devel__PPPort_eval_pv);
        newXS_deffile("Devel::PPPort::call_sv", XS_Devel__PPPort_call_sv);
        newXS_deffile("Devel::PPPort::call_pv", XS_Devel__PPPort_call_pv);
        newXS_deffile("Devel::PPPort::call_argv", XS_Devel__PPPort_call_argv);
        newXS_deffile("Devel::PPPort::call_method", XS_Devel__PPPort_call_method);
        newXS_deffile("Devel::PPPort::call_sv_G_METHOD", XS_Devel__PPPort_call_sv_G_METHOD);
        newXS_deffile("Devel::PPPort::load_module", XS_Devel__PPPort_load_module);
        newXS_deffile("Devel::PPPort::CopSTASHPV", XS_Devel__PPPort_CopSTASHPV);
        newXS_deffile("Devel::PPPort::CopFILE", XS_Devel__PPPort_CopFILE);
#if XSubPPtmpAAAA
        newXS_deffile("Devel::PPPort::caller_cx", XS_Devel__PPPort_caller_cx);
#endif
        newXS_deffile("Devel::PPPort::exception", XS_Devel__PPPort_exception);
        newXS_deffile("Devel::PPPort::croak_NVgf", XS_Devel__PPPort_croak_NVgf);
        newXS_deffile("Devel::PPPort::grok_number", XS_Devel__PPPort_grok_number);
        newXS_deffile("Devel::PPPort::grok_bin", XS_Devel__PPPort_grok_bin);
        newXS_deffile("Devel::PPPort::grok_hex", XS_Devel__PPPort_grok_hex);
        newXS_deffile("Devel::PPPort::grok_oct", XS_Devel__PPPort_grok_oct);
        newXS_deffile("Devel::PPPort::Perl_grok_number", XS_Devel__PPPort_Perl_grok_number);
        newXS_deffile("Devel::PPPort::Perl_grok_bin", XS_Devel__PPPort_Perl_grok_bin);
        newXS_deffile("Devel::PPPort::Perl_grok_hex", XS_Devel__PPPort_Perl_grok_hex);
        newXS_deffile("Devel::PPPort::Perl_grok_oct", XS_Devel__PPPort_Perl_grok_oct);
        newXS_deffile("Devel::PPPort::GvSVn", XS_Devel__PPPort_GvSVn);
        newXS_deffile("Devel::PPPort::isGV_with_GP", XS_Devel__PPPort_isGV_with_GP);
        newXS_deffile("Devel::PPPort::get_cvn_flags", XS_Devel__PPPort_get_cvn_flags);
        newXS_deffile("Devel::PPPort::gv_fetchpvn_flags", XS_Devel__PPPort_gv_fetchpvn_flags);
        newXS_deffile("Devel::PPPort::gv_fetchsv", XS_Devel__PPPort_gv_fetchsv);
        newXS_deffile("Devel::PPPort::gv_init_type", XS_Devel__PPPort_gv_init_type);
        newXS_deffile("Devel::PPPort::iv_size", XS_Devel__PPPort_iv_size);
        newXS_deffile("Devel::PPPort::uv_size", XS_Devel__PPPort_uv_size);
        newXS_deffile("Devel::PPPort::iv_type", XS_Devel__PPPort_iv_type);
        newXS_deffile("Devel::PPPort::uv_type", XS_Devel__PPPort_uv_type);
        newXS_deffile("Devel::PPPort::mPUSHs", XS_Devel__PPPort_mPUSHs);
        newXS_deffile("Devel::PPPort::mPUSHp", XS_Devel__PPPort_mPUSHp);
        newXS_deffile("Devel::PPPort::mPUSHn", XS_Devel__PPPort_mPUSHn);
        newXS_deffile("Devel::PPPort::mPUSHi", XS_Devel__PPPort_mPUSHi);
        newXS_deffile("Devel::PPPort::mPUSHu", XS_Devel__PPPort_mPUSHu);
        newXS_deffile("Devel::PPPort::mXPUSHs", XS_Devel__PPPort_mXPUSHs);
        newXS_deffile("Devel::PPPort::mXPUSHp", XS_Devel__PPPort_mXPUSHp);
        newXS_deffile("Devel::PPPort::mXPUSHn", XS_Devel__PPPort_mXPUSHn);
        newXS_deffile("Devel::PPPort::mXPUSHi", XS_Devel__PPPort_mXPUSHi);
        newXS_deffile("Devel::PPPort::mXPUSHu", XS_Devel__PPPort_mXPUSHu);
        newXS_deffile("Devel::PPPort::new_with_other_mg", XS_Devel__PPPort_new_with_other_mg);
        newXS_deffile("Devel::PPPort::new_with_mg", XS_Devel__PPPort_new_with_mg);
        newXS_deffile("Devel::PPPort::remove_null_magic", XS_Devel__PPPort_remove_null_magic);
        newXS_deffile("Devel::PPPort::remove_other_magic", XS_Devel__PPPort_remove_other_magic);
        newXS_deffile("Devel::PPPort::as_string", XS_Devel__PPPort_as_string);
        newXS_deffile("Devel::PPPort::sv_catpv_mg", XS_Devel__PPPort_sv_catpv_mg);
        newXS_deffile("Devel::PPPort::sv_catpvn_mg", XS_Devel__PPPort_sv_catpvn_mg);
        newXS_deffile("Devel::PPPort::sv_catsv_mg", XS_Devel__PPPort_sv_catsv_mg);
        newXS_deffile("Devel::PPPort::sv_setiv_mg", XS_Devel__PPPort_sv_setiv_mg);
        newXS_deffile("Devel::PPPort::sv_setnv_mg", XS_Devel__PPPort_sv_setnv_mg);
        newXS_deffile("Devel::PPPort::sv_setpv_mg", XS_Devel__PPPort_sv_setpv_mg);
        newXS_deffile("Devel::PPPort::sv_setpvn_mg", XS_Devel__PPPort_sv_setpvn_mg);
        newXS_deffile("Devel::PPPort::sv_setsv_mg", XS_Devel__PPPort_sv_setsv_mg);
        newXS_deffile("Devel::PPPort::sv_setuv_mg", XS_Devel__PPPort_sv_setuv_mg);
        newXS_deffile("Devel::PPPort::sv_usepvn_mg", XS_Devel__PPPort_sv_usepvn_mg);
        newXS_deffile("Devel::PPPort::SvVSTRING_mg", XS_Devel__PPPort_SvVSTRING_mg);
        newXS_deffile("Devel::PPPort::sv_magic_portable", XS_Devel__PPPort_sv_magic_portable);
        newXS_deffile("Devel::PPPort::checkmem", XS_Devel__PPPort_checkmem);
        newXS_deffile("Devel::PPPort::croak_sv", XS_Devel__PPPort_croak_sv);
        newXS_deffile("Devel::PPPort::die_sv", XS_Devel__PPPort_die_sv);
        newXS_deffile("Devel::PPPort::warn_sv", XS_Devel__PPPort_warn_sv);
        newXS_deffile("Devel::PPPort::mess_sv", XS_Devel__PPPort_mess_sv);
        newXS_deffile("Devel::PPPort::croak_no_modify", XS_Devel__PPPort_croak_no_modify);
        newXS_deffile("Devel::PPPort::croak_memory_wrap", XS_Devel__PPPort_croak_memory_wrap);
        newXS_deffile("Devel::PPPort::croak_xs_usage", XS_Devel__PPPort_croak_xs_usage);
        newXS_deffile("Devel::PPPort::OpSIBLING_tests", XS_Devel__PPPort_OpSIBLING_tests);
        newXS_deffile("Devel::PPPort::SvRXOK", XS_Devel__PPPort_SvRXOK);
        newXS_deffile("Devel::PPPort::ptrtests", XS_Devel__PPPort_ptrtests);
        newXS_deffile("Devel::PPPort::gv_stashpvn", XS_Devel__PPPort_gv_stashpvn);
        newXS_deffile("Devel::PPPort::get_sv", XS_Devel__PPPort_get_sv);
        newXS_deffile("Devel::PPPort::get_av", XS_Devel__PPPort_get_av);
        newXS_deffile("Devel::PPPort::get_hv", XS_Devel__PPPort_get_hv);
        newXS_deffile("Devel::PPPort::get_cv", XS_Devel__PPPort_get_cv);
        newXS_deffile("Devel::PPPort::xsreturn", XS_Devel__PPPort_xsreturn);
        newXS_deffile("Devel::PPPort::boolSV", XS_Devel__PPPort_boolSV);
        newXS_deffile("Devel::PPPort::DEFSV", XS_Devel__PPPort_DEFSV);
        newXS_deffile("Devel::PPPort::DEFSV_modify", XS_Devel__PPPort_DEFSV_modify);
        newXS_deffile("Devel::PPPort::ERRSV", XS_Devel__PPPort_ERRSV);
        newXS_deffile("Devel::PPPort::UNDERBAR", XS_Devel__PPPort_UNDERBAR);
        newXS_deffile("Devel::PPPort::prepush", XS_Devel__PPPort_prepush);
        newXS_deffile("Devel::PPPort::PERL_ABS", XS_Devel__PPPort_PERL_ABS);
        newXS_deffile("Devel::PPPort::SVf", XS_Devel__PPPort_SVf);
        newXS_deffile("Devel::PPPort::Perl_ppaddr_t", XS_Devel__PPPort_Perl_ppaddr_t);
#if XSubPPtmpAAAB
        newXS_deffile("Devel::PPPort::check_HeUTF8", XS_Devel__PPPort_check_HeUTF8);
#endif
        newXS_deffile("Devel::PPPort::check_c_array", XS_Devel__PPPort_check_c_array);
        newXS_deffile("Devel::PPPort::call_newCONSTSUB_1", XS_Devel__PPPort_call_newCONSTSUB_1);
        newXS_deffile("Devel::PPPort::call_newCONSTSUB_2", XS_Devel__PPPort_call_newCONSTSUB_2);
        newXS_deffile("Devel::PPPort::call_newCONSTSUB_3", XS_Devel__PPPort_call_newCONSTSUB_3);
        newXS_deffile("Devel::PPPort::newRV_inc_REFCNT", XS_Devel__PPPort_newRV_inc_REFCNT);
        newXS_deffile("Devel::PPPort::newRV_noinc_REFCNT", XS_Devel__PPPort_newRV_noinc_REFCNT);
        newXS_deffile("Devel::PPPort::newSV_type", XS_Devel__PPPort_newSV_type);
        newXS_deffile("Devel::PPPort::newSVpvn", XS_Devel__PPPort_newSVpvn);
        newXS_deffile("Devel::PPPort::newSVpvn_flags", XS_Devel__PPPort_newSVpvn_flags);
        newXS_deffile("Devel::PPPort::newSVpvn_utf8", XS_Devel__PPPort_newSVpvn_utf8);
        newXS_deffile("Devel::PPPort::pv_escape_can_unicode", XS_Devel__PPPort_pv_escape_can_unicode);
        newXS_deffile("Devel::PPPort::pv_pretty", XS_Devel__PPPort_pv_pretty);
        newXS_deffile("Devel::PPPort::pv_display", XS_Devel__PPPort_pv_display);
        newXS_deffile("Devel::PPPort::newSVpvs", XS_Devel__PPPort_newSVpvs);
        newXS_deffile("Devel::PPPort::newSVpvs_flags", XS_Devel__PPPort_newSVpvs_flags);
        newXS_deffile("Devel::PPPort::newSVpvs_share", XS_Devel__PPPort_newSVpvs_share);
        newXS_deffile("Devel::PPPort::sv_catpvs", XS_Devel__PPPort_sv_catpvs);
        newXS_deffile("Devel::PPPort::sv_setpvs", XS_Devel__PPPort_sv_setpvs);
        newXS_deffile("Devel::PPPort::hv_fetchs", XS_Devel__PPPort_hv_fetchs);
        newXS_deffile("Devel::PPPort::hv_stores", XS_Devel__PPPort_hv_stores);
        newXS_deffile("Devel::PPPort::gv_fetchpvs", XS_Devel__PPPort_gv_fetchpvs);
        newXS_deffile("Devel::PPPort::gv_stashpvs", XS_Devel__PPPort_gv_stashpvs);
        newXS_deffile("Devel::PPPort::get_cvs", XS_Devel__PPPort_get_cvs);
        newXS_deffile("Devel::PPPort::newSVpvn_share", XS_Devel__PPPort_newSVpvn_share);
        newXS_deffile("Devel::PPPort::my_snprintf", XS_Devel__PPPort_my_snprintf);
        newXS_deffile("Devel::PPPort::my_sprintf", XS_Devel__PPPort_my_sprintf);
        newXS_deffile("Devel::PPPort::my_strlfunc", XS_Devel__PPPort_my_strlfunc);
        newXS_deffile("Devel::PPPort::vnewSVpvf", XS_Devel__PPPort_vnewSVpvf);
        newXS_deffile("Devel::PPPort::sv_vcatpvf", XS_Devel__PPPort_sv_vcatpvf);
        newXS_deffile("Devel::PPPort::sv_vsetpvf", XS_Devel__PPPort_sv_vsetpvf);
        newXS_deffile("Devel::PPPort::sv_catpvf_mg", XS_Devel__PPPort_sv_catpvf_mg);
        newXS_deffile("Devel::PPPort::Perl_sv_catpvf_mg", XS_Devel__PPPort_Perl_sv_catpvf_mg);
        newXS_deffile("Devel::PPPort::sv_catpvf_mg_nocontext", XS_Devel__PPPort_sv_catpvf_mg_nocontext);
        newXS_deffile("Devel::PPPort::sv_setpvf_mg", XS_Devel__PPPort_sv_setpvf_mg);
        newXS_deffile("Devel::PPPort::Perl_sv_setpvf_mg", XS_Devel__PPPort_Perl_sv_setpvf_mg);
        newXS_deffile("Devel::PPPort::sv_setpvf_mg_nocontext", XS_Devel__PPPort_sv_setpvf_mg_nocontext);
        newXS_deffile("Devel::PPPort::no_THX_arg", XS_Devel__PPPort_no_THX_arg);
        newXS_deffile("Devel::PPPort::with_THX_arg", XS_Devel__PPPort_with_THX_arg);
        newXS_deffile("Devel::PPPort::sv_setuv", XS_Devel__PPPort_sv_setuv);
        newXS_deffile("Devel::PPPort::newSVuv", XS_Devel__PPPort_newSVuv);
        newXS_deffile("Devel::PPPort::sv_2uv", XS_Devel__PPPort_sv_2uv);
        newXS_deffile("Devel::PPPort::SvUVx", XS_Devel__PPPort_SvUVx);
        newXS_deffile("Devel::PPPort::XSRETURN_UV", XS_Devel__PPPort_XSRETURN_UV);
        newXS_deffile("Devel::PPPort::PUSHu", XS_Devel__PPPort_PUSHu);
        newXS_deffile("Devel::PPPort::XPUSHu", XS_Devel__PPPort_XPUSHu);
        newXS_deffile("Devel::PPPort::compare_PL_signals", XS_Devel__PPPort_compare_PL_signals);
        newXS_deffile("Devel::PPPort::PL_sv_undef", XS_Devel__PPPort_PL_sv_undef);
        newXS_deffile("Devel::PPPort::PL_sv_yes", XS_Devel__PPPort_PL_sv_yes);
        newXS_deffile("Devel::PPPort::PL_sv_no", XS_Devel__PPPort_PL_sv_no);
        newXS_deffile("Devel::PPPort::PL_na", XS_Devel__PPPort_PL_na);
        newXS_deffile("Devel::PPPort::PL_Sv", XS_Devel__PPPort_PL_Sv);
        newXS_deffile("Devel::PPPort::PL_tokenbuf", XS_Devel__PPPort_PL_tokenbuf);
        newXS_deffile("Devel::PPPort::PL_parser", XS_Devel__PPPort_PL_parser);
        newXS_deffile("Devel::PPPort::PL_hexdigit", XS_Devel__PPPort_PL_hexdigit);
        newXS_deffile("Devel::PPPort::PL_hints", XS_Devel__PPPort_PL_hints);
        newXS_deffile("Devel::PPPort::PL_ppaddr", XS_Devel__PPPort_PL_ppaddr);
        newXS_deffile("Devel::PPPort::other_variables", XS_Devel__PPPort_other_variables);
        newXS_deffile("Devel::PPPort::no_dummy_parser_vars", XS_Devel__PPPort_no_dummy_parser_vars);
        newXS_deffile("Devel::PPPort::dummy_parser_warning", XS_Devel__PPPort_dummy_parser_warning);
        newXS_deffile("Devel::PPPort::warner", XS_Devel__PPPort_warner);
        newXS_deffile("Devel::PPPort::Perl_warner", XS_Devel__PPPort_Perl_warner);
        newXS_deffile("Devel::PPPort::Perl_warner_nocontext", XS_Devel__PPPort_Perl_warner_nocontext);
        newXS_deffile("Devel::PPPort::ckWARN", XS_Devel__PPPort_ckWARN);

    /* Initialisation Section */

#line 337 "RealPPPort.xs"
	/* ---- code from parts/inc/MY_CXT ---- */
	{
	  MY_CXT_INIT;
	  /* If any of the fields in the my_cxt_t struct need
	   * to be initialised, do it here.
	   */
	  MY_CXT.dummy = 42;
	}

	/* ---- code from parts/inc/misc ---- */
	{
	  XSPROTO_test_t_ptr p = &XS_Devel__PPPort_dXSTARG;
	  newXS("Devel::PPPort::dXSTARG", *p, file);
	}
	newXS("Devel::PPPort::dAXMARK", XS_Devel__PPPort_dAXMARK, file);

#if XSubPPtmpAAAA
#endif
#if XSubPPtmpAAAB
#endif
#line 5101 "RealPPPort.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
}

