File Coverage

Geos_xsgen.cc

Criterion	Covered	Total	%
statement	4274	5482	77.9
branch	2867	8586	33.3
condition			n/a
subroutine			n/a
pod			n/a
total	7141	14068	50.7

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

#line 1 "Geos.xs"
#include "xs/geos/geos.h"
#include "panda/Geos/Helper.h"
#include "panda/Geos/tesselate.h"
#include "xsi/private_typemaps.h"

using xs::my_perl;
using xs::Sv;
using namespace geos::geom;
using namespace geos::geom::prep;
using namespace geos::algorithm;
using namespace geos::noding;
using namespace geos::noding::snapround;
using namespace geos::io;
using namespace geos::index::chain;
using namespace geos::index;
using namespace geos::precision;
using namespace geos::operation::buffer;
using namespace geos::operation::distance;
using namespace geos::operation::overlay;
using namespace geos::operation::valid;
using namespace geos::operation::relate;
using namespace geos::operation::linemerge;
using namespace geos::triangulate;
using namespace xs;
using namespace Geo::Geos;
using namespace panda;

struct IntersectionFinderAdder_payload {
    using vector_t = std::vector<::geos::geom::Coordinate>;

    xs::Object lineIntersector;
    vector_t coords;
};

struct Noder_payload {
    using vector_t = std::vector<::geos::noding::SegmentString*>;

    xs::Ref array_ref;
    vector_t segments;
};


struct MonotoneChain_payload {
    std::unique_ptr seq;
};

struct SubItemVisitor: public geos::index::ItemVisitor {
    xs::Sub sub;
    Helper::lookup_map_t& lookup_map;

    SubItemVisitor(Sub sub_, Helper::lookup_map_t& lookup_map_):sub{sub_}, lookup_map{lookup_map_} {};
    void visitItem (void *data) {
        SV* key = static_cast(data);
        HE* he = hv_fetch_ent(lookup_map, key, 0, 0);
        if (!he) throw ("Cannot lookup key in map");
        Scalar arg {HeVAL(he)};
        sub(arg);
    }
};

struct SVs_map_payload {
    Helper::lookup_map_t map;
    SVs_map_payload(): map{Hash::create()} {}
};

static xs::Sv::payload_marker_t payload_marker{};
static xs::Sv::payload_marker_t payload_marker_IntersectionFinderAdder{};
static xs::Sv::payload_marker_t payload_marker_Noder{};
static xs::Sv::payload_marker_t payload_marker_MonotoneChain{};
static xs::Sv::payload_marker_t payload_marker_SVs_map{};

static int payload_marker_IntersectionFinderAdder_free(pTHX_ SV*, MAGIC* mg) {
    if (mg->mg_virtual == &payload_marker_IntersectionFinderAdder) {
        auto* payload = static_cast((void*)mg->mg_ptr);
        delete payload;
    }
    return 0;
}

static int payload_marker_Noder_free(pTHX_ SV*, MAGIC* mg) {
    if (mg->mg_virtual == &payload_marker_Noder) {
        auto* payload = static_cast((void*)mg->mg_ptr);
        delete payload;
    }
    return 0;
}

static int payload_marker_MonotoneChain_free(pTHX_ SV*, MAGIC* mg) {
    if (mg->mg_virtual == &payload_marker_MonotoneChain) {
        auto* payload = static_cast((void*)mg->mg_ptr);
        delete payload;
    }
    return 0;
}

static int payload_marker_SVs_map_free(pTHX_ SV*, MAGIC* mg) {
    if (mg->mg_virtual == &payload_marker_SVs_map) {
        auto* payload = static_cast((void*)mg->mg_ptr);
        delete payload;
    }
    return 0;
}


static Sv coordinate_create_null () {
    Sv ret = xs::out(new Coordinate());
    return ret;
}

static Sv coordinate_get_null () {
    static thread_local Sv obj = coordinate_create_null();
    return obj;
}

//static Sv::payload_marker_t payload_marker;

#line 127 "Geos_xsgen.cc"
#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 271 "Geos_xsgen.cc"

/* INCLUDE:  Including 'xsi/Coordinate.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Coordinate_getNull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 0)
       croak_xs_usage(cv,  "");
    {
	Sv	RETVAL;
#line 4 "./xsi/Coordinate.xsi"
 RETVAL = coordinate_get_null();
#line 286 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 4)
       croak_xs_usage(cv,  "SV*, x= 0, y= 0, z= NULL");
    {
	Coordinate *	RETVAL;
	double	x;
	double	y;
	SV*	z;

	if (items < 2)
	    x = 0;
	else {
	    x = (double)SvNV(ST(1))
;
	}

	if (items < 3)
	    y = 0;
	else {
	    y = (double)SvNV(ST(2))
;
	}

	if (items < 4)
	    z = NULL;
	else {
	    z = ST(3)
;
	}
#line 7 "./xsi/Coordinate.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(x, y, z ? SvNV(z) : DoubleNotANumber);
#line 344 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_x) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 11 "./xsi/Coordinate.xsi"
    double* val;
    switch (ix) {
        case 0:  val = &THIS->x; break;
        case 1:  val = &THIS->y; break;
        default: val = &THIS->z; break;
    }
    if (newval) {
        if (SvREADONLY(ST(0))) throw "cannot modify readonly object";
        *val = SvNV(newval);
    }
    RETVAL = *val;
#line 388 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_setNull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "./xsi/Coordinate.xsi"
    if (SvREADONLY(ST(0))) throw "cannot modify readonly object";
    THIS->setNull();
#line 409 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_isNull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 29 "./xsi/Coordinate.xsi"
        RETVAL = THIS->isNull();
#line 428 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_equals) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	other = xs::in(ST(1));
;
#line 31 "./xsi/Coordinate.xsi"
        RETVAL = THIS->equals(other);
#line 449 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_equals2D) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	other = xs::in(ST(1));
;
#line 33 "./xsi/Coordinate.xsi"
        RETVAL = THIS->equals2D(other);
#line 470 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_equals3D) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	other = xs::in(ST(1));
;
#line 35 "./xsi/Coordinate.xsi"
        RETVAL = THIS->equals3D(other);
#line 491 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_compareTo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	other = xs::in(ST(1));
;
#line 37 "./xsi/Coordinate.xsi"
        RETVAL = THIS->compareTo(other);
#line 513 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_eq) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, other_arg, SV*");
    {
	bool	RETVAL;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    other_arg = ST(1)
;
#line 40 "./xsi/Coordinate.xsi"
    auto* other = xs::in(other_arg);
    RETVAL = other ? THIS->equals(*other) : false;
#line 535 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 45 "./xsi/Coordinate.xsi"
        RETVAL = THIS->toString();
#line 555 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_distance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	other = xs::in(ST(1));
;
#line 47 "./xsi/Coordinate.xsi"
        RETVAL = THIS->distance(other);
#line 577 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_hashCode) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 49 "./xsi/Coordinate.xsi"
        RETVAL = THIS->hashCode();
#line 597 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Coordinate_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 51 "./xsi/Coordinate.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 614 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Coordinate.xsi' */


/* INCLUDE:  Including 'xsi/Dimension.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Dimension_toDimensionSymbol) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "value");
    {
	string	RETVAL;
	dXSTARG;
	int	value = (int)SvIV(ST(0))
;
#line 5 "./xsi/Dimension.xsi"
    char c = Dimension::toDimensionSymbol(value);
    RETVAL = c;
#line 641 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Dimension_toDimensionValue) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "value");
    {
	int	RETVAL;
	dXSTARG;
	string	value;

  { STRLEN __value_len;
    const char* __value_buf = SvPV(ST(0), __value_len);
    value.assign(__value_buf, __value_len); }
;
#line 10 "./xsi/Dimension.xsi"
    if (value.size() != 1) throw "string of one char is expected";
    RETVAL =  Dimension::toDimensionValue(value[0]);
#line 666 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Dimension.xsi' */


/* INCLUDE:  Including 'xsi/Envelope.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Envelope_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 5)
       croak_xs_usage(cv,  "SV*, arg1= Sv(), arg2= NULL, arg3= NULL, arg4= NULL");
    {
	Envelope *	RETVAL;
	Sv	arg1;
	SV*	arg2;
	SV*	arg3;
	SV*	arg4;

	if (items < 2)
	    arg1 = Sv();
	else {
    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 5 "./xsi/Envelope.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (items == 1) RETVAL = new Envelope();
    else if (items == 2) {
        if (!arg1.is_simple()) {
            auto& c = xs::in(arg1);
            RETVAL = new Envelope(c);
        }
        else {
            if(!arg1) throw("undef not allowed");
            panda::string_view sw = Simple(arg1);
            std::string str { sw.begin(), sw.end() };
            RETVAL = new Envelope(str);
        }
    }
    else if (items == 3) {
        auto& c1 = xs::in(arg1);
        auto& c2 = xs::in(arg2);
        RETVAL = new Envelope(c1, c2);
    }
    else if (items == 5)  RETVAL = new Envelope(Simple(arg1), Simple(arg2), Simple(arg3), Simple(arg4));
    else throw ("unsupported constructor");
#line 741 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_init) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 5)
       croak_xs_usage(cv,  "THIS, arg1= NULL, arg2= NULL, arg3= NULL, arg4= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;
	SV*	arg2;
	SV*	arg3;
	SV*	arg4;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 28 "./xsi/Envelope.xsi"
    if (items == 1) THIS->init();
    else if (items == 2) {
        auto& c = xs::in(arg1);
        THIS->init(c);
    }
    else if (items == 3) {
        auto c1 = xs::in(arg1);
        auto c2 = xs::in(arg2);
        THIS->init(c1, c2);
    }
    else if (items == 5)  THIS->init(Simple(arg1), Simple(arg2), Simple(arg3), Simple(arg4));
    else throw ("unsupported arguments");
#line 809 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_setToNull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 42 "./xsi/Envelope.xsi"
        THIS->setToNull();
#line 829 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 44 "./xsi/Envelope.xsi"
        RETVAL = THIS->getArea();
#line 849 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getMaxY) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 46 "./xsi/Envelope.xsi"
        RETVAL = THIS->getMaxY();
#line 869 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getMaxX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 48 "./xsi/Envelope.xsi"
        RETVAL = THIS->getMaxX();
#line 889 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getMinY) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 50 "./xsi/Envelope.xsi"
        RETVAL = THIS->getMinY();
#line 909 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getMinX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 52 "./xsi/Envelope.xsi"
        RETVAL = THIS->getMinX();
#line 929 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getWidth) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 54 "./xsi/Envelope.xsi"
        RETVAL = THIS->getWidth();
#line 949 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_getHeight) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 56 "./xsi/Envelope.xsi"
        RETVAL = THIS->getHeight();
#line 969 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_isNull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 58 "./xsi/Envelope.xsi"
        RETVAL = THIS->isNull();
#line 988 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_hashCode) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 60 "./xsi/Envelope.xsi"
        RETVAL = THIS->hashCode();
#line 1008 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 62 "./xsi/Envelope.xsi"
        RETVAL = THIS->toString();
#line 1028 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_eq) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, other_arg, SV*");
    {
	bool	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv    other_arg = ST(1)
;
#line 65 "./xsi/Envelope.xsi"
    auto other = xs::in(other_arg);
    RETVAL = other ? THIS->equals(other) : false;
#line 1050 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_centre) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 70 "./xsi/Envelope.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    if (!THIS->centre(c)) XSRETURN_UNDEF;
    RETVAL = new Coordinate(c);
#line 1072 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_contains) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL");
    {
	bool	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 76 "./xsi/Envelope.xsi"
    if (!arg2) {
        Object obj {arg1};
        if(!obj) throw("wrong argument");
        if (obj.stash().name() == "Geo::Geos::Envelope") {
            auto e = xs::in(obj);
            RETVAL = THIS->contains(e);
        }
        else {
            auto& c = xs::in(obj);
            RETVAL = THIS->contains(c);
        }
    }
    else RETVAL = THIS->contains(Simple(arg1), Simple(arg2));
#line 1118 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_covers) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL");
    {
	bool	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 92 "./xsi/Envelope.xsi"
    if (!arg2) {
        Object obj {arg1};
        if(!obj) throw("wrong argument");
        if (obj.stash().name() == "Geo::Geos::Envelope") {
            auto e = xs::in(obj);
            RETVAL = THIS->covers(e);
        }
        else {
            auto& c = xs::in(obj);
            RETVAL = THIS->covers(c);
        }
    }
    else RETVAL = THIS->covers(Simple(arg1), Simple(arg2));
#line 1159 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_intersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "maybe_self, arg1, arg2= NULL, arg3= NULL");
    {
	bool	RETVAL;
	Object    maybe_self = ST(0);
    if (!maybe_self && SvOK(ST(0))) throw "arg is not a blessed reference"
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;
	SV*	arg3;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}
#line 108 "./xsi/Envelope.xsi"
    if (!maybe_self) throw("wrong argument");
    auto arg0_stash = maybe_self.stash().name();
    if (arg0_stash != "Geo::Geos::Envelope") {
        // static method
        auto& p1 = xs::in(maybe_self);
        auto& p2 = xs::in(arg1);
        if (!arg3) {
            auto& q = xs::in(arg2);
            RETVAL = Envelope::intersects(p1, p2, q);
        }
        else {
            auto& q1 = xs::in(arg2);
            auto& q2 = xs::in(arg3);
            RETVAL = Envelope::intersects(p1, p2, q1, q2);
        }
    } else  {
        // object method
        Envelope& self = xs::in(maybe_self);
        if (!arg2) {
            Object obj {arg1};
            if(!obj) throw("wrong argument");
            if (obj.stash().name() == "Geo::Geos::Envelope") {
                auto& e = xs::in(obj);
                RETVAL = self.intersects(&e);
            }
            else {
                auto& c = xs::in(obj);
                RETVAL = self.intersects(c);
            }
        }
        else RETVAL = self.intersects(Simple(arg1), Simple(arg2));
    }
#line 1228 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_expandToInclude) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 143 "./xsi/Envelope.xsi"
    if (!arg2) {
        Object obj {arg1};
        if(!obj) throw("wrong argument");
        if (obj.stash().name() == "Geo::Geos::Envelope") {
            auto& e = xs::in(obj);
            THIS->expandToInclude(&e);
        }
        else {
            auto& c = xs::in(obj);
            THIS->expandToInclude(c);
        }
    }
    else THIS->expandToInclude(Simple(arg1), Simple(arg2));
#line 1270 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_distance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	double	RETVAL;
	dXSTARG;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope&	other = xs::in(ST(1));
;
#line 158 "./xsi/Envelope.xsi"
 RETVAL = THIS->distance(&other);
#line 1292 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_translate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, tX, tY");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	tX = (double)SvNV(ST(1))
;
	double	tY = (double)SvNV(ST(2))
;
#line 160 "./xsi/Envelope.xsi"
        THIS->translate(tX, tY);
#line 1316 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_expandBy) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dX, dY");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	dX = (double)SvNV(ST(1))
;
	double	dY = (double)SvNV(ST(2))
;
#line 162 "./xsi/Envelope.xsi"
        THIS->expandBy(dX, dY);
#line 1340 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_intersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	Envelope *	RETVAL;
	Envelope*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope&	other = xs::in(ST(1));
;
#line 165 "./xsi/Envelope.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Envelope e;
    if (!THIS->intersection(other, e)) XSRETURN_UNDEF;
    RETVAL = new Envelope(e);
#line 1364 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Envelope_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 170 "./xsi/Envelope.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 1386 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Envelope.xsi' */


/* INCLUDE:  Including 'xsi/PrecisionModel.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__PrecisionModel_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 4)
       croak_xs_usage(cv,  "SV*, arg1= NULL, arg2= NULL, arg3= NULL");
    {
	PrecisionModel *	RETVAL;
	SV*	arg1;
	SV*	arg2;
	SV*	arg3;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}
#line 5 "./xsi/PrecisionModel.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = new PrecisionModel();
    else {
        if(SvIOK(arg1)) {
            PrecisionModel::Type model = static_cast(SvIV(arg1));
            RETVAL = new PrecisionModel(model);
        }
        else {
            double scale = SvNV(arg1);
            if (arg2) {
                if(!arg3) throw("undef not allowed");
                double offsetX = SvNV(arg2);
                double offsetY = SvNV(arg3);
                RETVAL = new PrecisionModel(scale, offsetX, offsetY);
            }
            else RETVAL = new PrecisionModel(scale);
        }
    }
#line 1450 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_getScale) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 24 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->getScale();
#line 1475 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_getOffsetX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 26 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->getOffsetX();
#line 1495 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_getOffsetY) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 28 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->getOffsetY();
#line 1515 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_isFloating) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 30 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->isFloating();
#line 1534 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_getMaximumSignificantDigits) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 32 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->getMaximumSignificantDigits();
#line 1554 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_getType) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 34 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->getType();
#line 1574 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_makePrecise) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, val");
    {
	double	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	val = (double)SvNV(ST(1))
;
#line 36 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->makePrecise(val);
#line 1596 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 38 "./xsi/PrecisionModel.xsi"
        RETVAL = THIS->toString();
#line 1616 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__PrecisionModel_compareTo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	int	RETVAL;
	dXSTARG;
	PrecisionModel*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	PrecisionModel&	other = xs::in(ST(1));
;
#line 40 "./xsi/PrecisionModel.xsi"
 RETVAL = THIS->compareTo(&other);
#line 1638 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/PrecisionModel.xsi' */


/* INCLUDE:  Including 'xsi/IntersectionMatrix.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "SV*, arg1= NULL");
    {
	IntersectionMatrix *	RETVAL;
	SV*	arg1;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}
#line 5 "./xsi/IntersectionMatrix.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = new IntersectionMatrix();
    else {
        std::string elements { SvPV_nolen(arg1) };
        RETVAL = new IntersectionMatrix(elements);
    }
#line 1674 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_matches) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, requiredDimensionSymbols");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	std::string	requiredDimensionSymbols;

  { STRLEN __requiredDimensionSymbols_len;
    const char* __requiredDimensionSymbols_buf = SvPV(ST(1), __requiredDimensionSymbols_len);
    requiredDimensionSymbols.assign(__requiredDimensionSymbols_buf, __requiredDimensionSymbols_len); }
;
#line 12 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->matches(requiredDimensionSymbols);
#line 1704 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_add) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	IntersectionMatrix&	other = xs::in(ST(1));
;
#line 14 "./xsi/IntersectionMatrix.xsi"
 THIS->add(&other);
#line 1726 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_set) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL, arg3= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;
	SV*	arg3;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}
#line 17 "./xsi/IntersectionMatrix.xsi"
    if(!arg1) throw("undef not allowed");
    if (!arg2) {
        std::string dimensionSymbols { SvPV_nolen(arg1) };
        THIS->set(dimensionSymbols);
    } else {
        if(!arg3) throw("undef not allowed");
        int row = SvIV(arg1);
        int col = SvIV(arg2);
        int val = SvIV(arg3);
        THIS->set(row, col, val);
    }
#line 1774 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_setAtLeast) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL, arg3= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;
	SV*	arg3;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}
#line 31 "./xsi/IntersectionMatrix.xsi"
    if(!arg1) throw("undef not allowed");
    if (!arg2) {
        std::string dimensionSymbols { SvPV_nolen(arg1) };
        THIS->setAtLeast(dimensionSymbols);
    } else {
        if(!arg3) throw("undef not allowed");
        int row = SvIV(arg1);
        int col = SvIV(arg2);
        int val = SvIV(arg3);
        THIS->setAtLeast(row, col, val);
    }
#line 1822 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_setAll) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, dimensionValue");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	dimensionValue = (int)SvIV(ST(1))
;
#line 44 "./xsi/IntersectionMatrix.xsi"
        THIS->setAll(dimensionValue);
#line 1844 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_setAtLeastIfValid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "THIS, row, column, minimumDimensionValue");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	row = (int)SvIV(ST(1))
;
	int	column = (int)SvIV(ST(2))
;
	int	minimumDimensionValue = (int)SvIV(ST(3))
;
#line 46 "./xsi/IntersectionMatrix.xsi"
        THIS->setAtLeastIfValid(row, column, minimumDimensionValue);
#line 1870 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_get) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, row, col");
    {
	int	RETVAL;
	dXSTARG;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	row = (int)SvIV(ST(1))
;
	int	col = (int)SvIV(ST(2))
;
#line 48 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->get(row, col);
#line 1894 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isDisjoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 50 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isDisjoint();
#line 1913 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isIntersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 52 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isIntersects();
#line 1932 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isWithin) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 54 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isWithin();
#line 1951 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isContains) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 56 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isContains();
#line 1970 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isCovers) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 58 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isCovers();
#line 1989 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isCoveredBy) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 60 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isCoveredBy();
#line 2008 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isTouches) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dimensionOfGeometryA, dimensionOfGeometryB");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	dimensionOfGeometryA = (int)SvIV(ST(1))
;
	int	dimensionOfGeometryB = (int)SvIV(ST(2))
;
#line 62 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isTouches(dimensionOfGeometryA, dimensionOfGeometryB);
#line 2031 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isCrosses) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dimensionOfGeometryA, dimensionOfGeometryB");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	dimensionOfGeometryA = (int)SvIV(ST(1))
;
	int	dimensionOfGeometryB = (int)SvIV(ST(2))
;
#line 64 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isCrosses(dimensionOfGeometryA, dimensionOfGeometryB);
#line 2054 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isEquals) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dimensionOfGeometryA, dimensionOfGeometryB");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	dimensionOfGeometryA = (int)SvIV(ST(1))
;
	int	dimensionOfGeometryB = (int)SvIV(ST(2))
;
#line 66 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isEquals(dimensionOfGeometryA, dimensionOfGeometryB);
#line 2077 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_isOverlaps) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, dimensionOfGeometryA, dimensionOfGeometryB");
    {
	bool	RETVAL;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	dimensionOfGeometryA = (int)SvIV(ST(1))
;
	int	dimensionOfGeometryB = (int)SvIV(ST(2))
;
#line 68 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->isOverlaps(dimensionOfGeometryA, dimensionOfGeometryB);
#line 2100 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_transpose) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 71 "./xsi/IntersectionMatrix.xsi"
 THIS->transpose(); XSRETURN(1);
#line 2120 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	IntersectionMatrix*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 73 "./xsi/IntersectionMatrix.xsi"
        RETVAL = THIS->toString();
#line 2140 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__IntersectionMatrix_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 75 "./xsi/IntersectionMatrix.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 2157 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/IntersectionMatrix.xsi' */


/* INCLUDE:  Including 'xsi/Triangle.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Triangle_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "SV*, p0, p1, p2");
    {
	Triangle *	RETVAL;
	Coordinate&	p0 = xs::in(ST(1));
;
	Coordinate&	p1 = xs::in(ST(2));
;
	Coordinate&	p2 = xs::in(ST(3));
;
#line 4 "./xsi/Triangle.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Triangle(p0, p1, p2);
#line 2187 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangle_p0) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	Coordinate *	RETVAL;
	Triangle*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = xs::in(ST(1));
;
	}
#line 7 "./xsi/Triangle.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate* val;
    switch (ix) {
        case 0:  val = &THIS->p0; break;
        case 1:  val = &THIS->p1; break;
        default: val = &THIS->p2; break;
    }
    if (newval) {
        *val = *newval;
    }
    RETVAL = new Coordinate(*val);
#line 2230 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangle_inCentre) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	Triangle*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 20 "./xsi/Triangle.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->inCentre(c);
    RETVAL = new Coordinate(c);
#line 2257 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangle_circumcentre) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	Triangle*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 26 "./xsi/Triangle.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->circumcentre(c);
    RETVAL = new Coordinate(c);
#line 2284 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangle_isInCircleNonRobust) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 4)
       croak_xs_usage(cv,  "a, b, c, p");
    {
	bool	RETVAL;
	Coordinate&	a = xs::in(ST(0));
;
	Coordinate&	b = xs::in(ST(1));
;
	Coordinate&	c = xs::in(ST(2));
;
	Coordinate&	p = xs::in(ST(3));
;
#line 32 "./xsi/Triangle.xsi"
    switch(ix) {
        case 0: RETVAL = TrianglePredicate::isInCircleNonRobust(a, b, c, p); break;
        case 1: RETVAL = TrianglePredicate::isInCircleNormalized(a, b, c, p); break;
        default: RETVAL = TrianglePredicate::isInCircleRobust(a, b, c, p); break;
    }
#line 2319 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangle_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 40 "./xsi/Triangle.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 2336 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Triangle.xsi' */


/* INCLUDE:  Including 'xsi/LineSegment.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__LineSegment_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 5)
       croak_xs_usage(cv,  "SV*, arg1= NULL, arg2= NULL, arg3= NULL, arg4= NULL");
    {
	LineSegment *	RETVAL;
	SV*	arg1;
	SV*	arg2;
	SV*	arg3;
	SV*	arg4;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 5 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = new LineSegment();
    else if (!arg3) {
        auto& c1 = xs::in(arg1);
        auto& c2 = xs::in(arg2);
        RETVAL = new LineSegment(c1, c2);
    }
    else {
        if(!arg2) throw("undef not allowed");
        if(!arg3) throw("undef not allowed");
        if(!arg4) throw("undef not allowed");
        double x0 = SvNV(arg1);
        double y0 = SvNV(arg2);
        double x1 = SvNV(arg3);
        double y1 = SvNV(arg4);
        RETVAL = new LineSegment(x0, y0, x1, y1);
    }
#line 2407 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_getLength) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 23 "./xsi/LineSegment.xsi"
        RETVAL = THIS->getLength();
#line 2432 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_isHorizontal) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "./xsi/LineSegment.xsi"
        RETVAL = THIS->isHorizontal();
#line 2451 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_isVertical) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 27 "./xsi/LineSegment.xsi"
        RETVAL = THIS->isVertical();
#line 2470 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_setCoordinates) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1, arg2= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1 = ST(1)
;
	SV*	arg2;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 30 "./xsi/LineSegment.xsi"
    if (!arg2) {
        auto& ls = xs::in(arg1);
        THIS->setCoordinates(ls);
    }
    else {
        auto& c1 = xs::in(arg1);
        auto& c2 = xs::in(arg2);
        THIS->setCoordinates(c1, c2);
    }
#line 2508 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_orientationIndex) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, arg");
    {
	int	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Object    arg = ST(1);
    if (!arg && SvOK(ST(1))) throw "arg is not a blessed reference"
;
#line 42 "./xsi/LineSegment.xsi"
    if (arg.stash().name() == "Geo::Geos::Coordinate") {
        auto c = xs::in(arg);
        RETVAL = THIS->orientationIndex(*c);
    }
    else {
        auto& ls = xs::in(arg);
        RETVAL = THIS->orientationIndex(ls);
    }
#line 2538 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_reverse) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 52 "./xsi/LineSegment.xsi"
        THIS->reverse();
#line 2558 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_normalize) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 54 "./xsi/LineSegment.xsi"
        THIS->normalize();
#line 2578 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_angle) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 56 "./xsi/LineSegment.xsi"
        RETVAL = THIS->angle();
#line 2598 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_midPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 59 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->midPoint(c);
    RETVAL = new Coordinate(c);
#line 2620 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_distance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, arg");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Object    arg = ST(1);
    if (!arg && SvOK(ST(1))) throw "arg is not a blessed reference"
;
#line 65 "./xsi/LineSegment.xsi"
    if (arg.stash().name() == "Geo::Geos::Coordinate") {
        auto c = xs::in(arg);
        RETVAL = THIS->distance(*c);
    }
    else {
        auto& ls = xs::in(arg);
        RETVAL = THIS->distance(ls);
    }
#line 2655 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_distancePerpendicular) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, p");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	p = xs::in(ST(1));
;
#line 75 "./xsi/LineSegment.xsi"
        RETVAL = THIS->distancePerpendicular(p);
#line 2677 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_pointAlong) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, segmentLengthFraction");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	segmentLengthFraction = (double)SvNV(ST(1))
;
#line 78 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->pointAlong(segmentLengthFraction, c);
    RETVAL = new Coordinate(c);
#line 2701 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_pointAlongOffset) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, segmentLengthFraction, offsetDistance");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	segmentLengthFraction = (double)SvNV(ST(1))
;
	double	offsetDistance = (double)SvNV(ST(2))
;
#line 84 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->pointAlongOffset(segmentLengthFraction, offsetDistance, c);
    RETVAL = new Coordinate(c);
#line 2732 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_projectionFactor) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, p");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	p = xs::in(ST(1));
;
#line 89 "./xsi/LineSegment.xsi"
        RETVAL = THIS->projectionFactor(p);
#line 2759 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_segmentFraction) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, p");
    {
	double	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	p = xs::in(ST(1));
;
#line 91 "./xsi/LineSegment.xsi"
        RETVAL = THIS->segmentFraction(p);
#line 2781 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_project) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, arg");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Object    arg = ST(1);
    if (!arg && SvOK(ST(1))) throw "arg is not a blessed reference"
;
#line 94 "./xsi/LineSegment.xsi"
    if (arg.stash().name() == "Geo::Geos::Coordinate") {
        auto& c = xs::in(arg);
        Coordinate c_out;
        THIS->project(c, c_out);
        auto wrapped = xs::out<>(new Coordinate(c_out));
        mXPUSHs(wrapped.detach());
    }
    else {
        auto& ls = xs::in(arg);
        LineSegment ls_out;
        bool overlap = THIS->project(ls, ls_out);
        auto wrapped = xs::out<>(new LineSegment(ls_out));
        mXPUSHs(wrapped.detach());
        if (GIMME_V == G_ARRAY) mXPUSHi(overlap);
    }
#line 2818 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_closestPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, p");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	p = xs::in(ST(1));
;
#line 112 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->closestPoint(p, c);
    RETVAL = new Coordinate(c);
#line 2842 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_compareTo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	int	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineSegment&	other = xs::in(ST(1));
;
#line 117 "./xsi/LineSegment.xsi"
        RETVAL = THIS->compareTo(other);
#line 2869 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_equalsTopo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineSegment&	other = xs::in(ST(1));
;
#line 119 "./xsi/LineSegment.xsi"
        RETVAL = THIS->equalsTopo(other);
#line 2890 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_closestPoints) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, line");
    {
	Array	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineSegment&	line = xs::in(ST(1));
;
#line 122 "./xsi/LineSegment.xsi"
    auto seq = std::unique_ptr(THIS->closestPoints(line));
    RETVAL = Helper::convert_copy(seq.get());
#line 2912 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_intersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, line");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineSegment&	line = xs::in(ST(1));
;
#line 127 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    if(THIS->intersection(line, c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 2943 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_lineIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, line");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineSegment&	line = xs::in(ST(1));
;
#line 133 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    if(THIS->lineIntersection(line, c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 2972 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_toGeometry) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, gf");
    {
	LineString *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	GeometryFactory&	gf = xs::in(ST(1));
;
#line 139 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto ptr = THIS->toGeometry(gf);
    RETVAL = ptr.release();
#line 3000 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 144 "./xsi/LineSegment.xsi"
    std::ostringstream out;
    out << *THIS;
    RETVAL = out.str();
#line 3027 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_p0) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	Coordinate *	RETVAL;
	LineSegment*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 150 "./xsi/LineSegment.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate* val;
    switch (ix) {
        case 0:  val = &THIS->p0; break;
        default: val = &THIS->p1; break;
    }
    if (newval) {
        auto& c = xs::in(newval);
        *val = c;
    }
    RETVAL = new Coordinate(*val);
#line 3065 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineSegment_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 162 "./xsi/LineSegment.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 3087 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/LineSegment.xsi' */


/* INCLUDE:  Including 'xsi/GeometryFactory.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__GeometryFactory_create) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 0 || items > 2)
       croak_xs_usage(cv,  "arg1= NULL, arg2= NULL");
    {
	GeometryFactory *	RETVAL;
	SV*	arg1;
	SV*	arg2;

	if (items < 1)
	    arg1 = NULL;
	else {
	    arg1 = ST(0)
;
	}

	if (items < 2)
	    arg2 = NULL;
	else {
	    arg2 = ST(1)
;
	}
#line 5 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    GeometryFactory::Ptr ptr;
    if (!arg1) {
        ptr = GeometryFactory::create();
    }
    else {
        auto& pm = xs::in(arg1);
        if (arg2) {
            int srid = SvIV(arg2);
            ptr = GeometryFactory::create(&pm, srid);
        }
        else ptr = GeometryFactory::create(&pm);
    }

    if (ptr.get()) {
        /* steal pointer without destroying the factory */
        RETVAL = ptr.release();
    }
    else throw ("unsupported arguments");
#line 3144 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_getPrecisionModel) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	PrecisionModel *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 26 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto pm = THIS->getPrecisionModel();
    RETVAL = new PrecisionModel(*pm);
#line 3170 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_getSRID) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 30 "./xsi/GeometryFactory.xsi"
        RETVAL = THIS->getSRID();
#line 3195 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createGeometryCollection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	GeometryCollection *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 33 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = THIS->createGeometryCollection();
#line 3215 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1= Sv{}, arg2= NULL");
    {
	Point *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Sv	arg1;
	SV*	arg2;

	if (items < 2)
	    arg1 = Sv{};
	else {
    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 37 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createPoint();
    else {
        if (!arg1.is_array_ref()) {
            Object obj {arg1};
            if (obj && obj.stash().name() == "Geo::Geos::Coordinate") {
                auto coord = xs::in(obj);
                RETVAL = THIS->createPoint(*coord);
            }
            else throw ("Object must be blessed into Geo::Geos::Coordinate");
        }
        else {
            if (!arg2) throw ("missing mandatory argument");
            size_t dims = SvIV(arg2);
            auto seq = Helper::convert_copy(*THIS, Array(arg1), dims);
            RETVAL = THIS->createPoint(seq);
        }
    }
#line 3272 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createMultiPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1= NULL, arg2= NULL");
    {
	MultiPoint *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;
	SV*	arg2;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 57 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createMultiPoint();
    else {
        if (!arg2) throw ("missing mandatory argument");
        size_t dims = SvIV(arg2);
        auto seq = std::unique_ptr(Helper::convert_copy(*THIS, Array(arg1), dims));
        RETVAL = THIS->createMultiPoint(*seq);
    }
#line 3319 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createLineString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1= NULL, arg2= NULL");
    {
	LineString *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;
	SV*	arg2;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 67 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createLineString();
    else {
        if (!arg2) throw ("missing argument");
        size_t dims = SvIV(arg2);
        auto seq = std::unique_ptr(Helper::convert_copy(*THIS, Array(arg1), dims));
        RETVAL = THIS->createLineString(*seq);
    }
#line 3366 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createMultiLineString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, arg1= NULL");
    {
	MultiLineString *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}
#line 77 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createMultiLineString();
    else {
        Array geometries(arg1);
        if (!geometries) throw ("unsupported argument");
        auto lines = Helper::convert_geometries(geometries);
        RETVAL = THIS->createMultiLineString(lines);
    }
#line 3405 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createLinearRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1= NULL, arg2= NULL");
    {
	LinearRing *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;
	SV*	arg2;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 87 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createLinearRing();
    else {
        if (!arg2) throw ("missing argument");
        size_t dims = SvIV(arg2);
        auto seq = std::unique_ptr(Helper::convert_copy(*THIS, Array(arg1), dims));
        RETVAL = THIS->createLinearRing(*seq);
    }
#line 3452 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createPolygon) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "THIS, arg1= NULL, arg2= NULL");
    {
	geos::geom::Polygon *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;
	SV*	arg2;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}
#line 97 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createPolygon();
    else {
        auto ring = xs::in(arg1);
        auto holes = Helper::convert_geometries(Array(arg2));
        RETVAL = THIS->createPolygon(*ring, holes);
    }
#line 3498 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createMultiPolygon) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, arg1= NULL");
    {
	MultiPolygon *	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg1;

	if (items < 2)
	    arg1 = NULL;
	else {
	    arg1 = ST(1)
;
	}
#line 106 "./xsi/GeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg1) RETVAL = THIS->createMultiPolygon();
    else {
        auto polygons = Helper::convert_geometries(Array(arg1));
        RETVAL = THIS->createMultiPolygon(polygons);
    }
#line 3535 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_toGeometry) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, env");
    {
	Sv	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope*	env = xs::in(ST(1));
;
#line 114 "./xsi/GeometryFactory.xsi"
    RETVAL = Helper::uplift(THIS->toGeometry(env));
#line 3561 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_createEmptyGeometry) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	GeometryFactory*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 118 "./xsi/GeometryFactory.xsi"
    RETVAL = Helper::uplift(THIS->createEmptyGeometry());
#line 3596 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__GeometryFactory_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 121 "./xsi/GeometryFactory.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 3629 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/GeometryFactory.xsi' */


/* INCLUDE:  Including 'xsi/Geometry.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Geometry_getSRID) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/Geometry.xsi"
        RETVAL = THIS->getSRID();
#line 3655 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_setSRID) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, newSRID");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	newSRID = (int)SvIV(ST(1))
;
#line 6 "./xsi/Geometry.xsi"
        THIS->setSRID(newSRID);
#line 3677 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_isEmpty) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 8 "./xsi/Geometry.xsi"
        RETVAL = THIS->isEmpty();
#line 3696 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_isSimple) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 10 "./xsi/Geometry.xsi"
        RETVAL = THIS->isSimple();
#line 3715 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_isRectangle) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/Geometry.xsi"
        RETVAL = THIS->isRectangle();
#line 3734 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_isValid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 14 "./xsi/Geometry.xsi"
        RETVAL = THIS->isValid();
#line 3753 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getNumPoints) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	size_t	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 16 "./xsi/Geometry.xsi"
        RETVAL = THIS->getNumPoints();
#line 3773 "Geos_xsgen.cc"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getDimension) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 18 "./xsi/Geometry.xsi"
        RETVAL = THIS->getDimension();
#line 3793 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getCoordinateDimension) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 20 "./xsi/Geometry.xsi"
        RETVAL = THIS->getCoordinateDimension();
#line 3813 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getBoundaryDimension) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 22 "./xsi/Geometry.xsi"
        RETVAL = THIS->getBoundaryDimension();
#line 3833 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getNumGeometries) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 24 "./xsi/Geometry.xsi"
        RETVAL = THIS->getNumGeometries();
#line 3853 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_reverse) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 26 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->reverse());
#line 3872 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getGeometryN) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	size_t	n = (size_t)SvUV(ST(1))
;
#line 29 "./xsi/Geometry.xsi"
    auto g = THIS->getGeometryN(n);
    if (g) RETVAL = Helper::uplift(g->clone());
    else XSRETURN_UNDEF;
#line 3911 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getCoordinate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 35 "./xsi/Geometry.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    // avoid mem-leak due to https://trac.osgeo.org/geos/ticket/918
    if (THIS->isEmpty()) XSRETURN_UNDEF;

    auto c = THIS->getCoordinate();
    if (c) RETVAL = new Coordinate(*c);
    else XSRETURN_UNDEF;
#line 3952 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getGeometryType) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	std::string	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 43 "./xsi/Geometry.xsi"
        RETVAL = THIS->getGeometryType();
#line 3977 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getGeometryTypeId) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 45 "./xsi/Geometry.xsi"
        RETVAL = THIS->getGeometryTypeId();
#line 3997 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 47 "./xsi/Geometry.xsi"
        RETVAL = THIS->toString();
#line 4017 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_toText) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	std::string	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 49 "./xsi/Geometry.xsi"
        RETVAL = THIS->toText();
#line 4037 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_equalsExact) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, other, tolerance= 0");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
	double	tolerance;

	if (items < 3)
	    tolerance = 0;
	else {
	    tolerance = (double)SvNV(ST(2))
;
	}
#line 51 "./xsi/Geometry.xsi"
 RETVAL = THIS->equalsExact(&other, tolerance);
#line 4066 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_equals) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 53 "./xsi/Geometry.xsi"
 RETVAL = THIS->equals(&other);
#line 4087 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_compareTo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	int	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 55 "./xsi/Geometry.xsi"
 RETVAL = THIS->compareTo(&other);
#line 4109 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getBoundary) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 57 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->getBoundary());
#line 4128 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 59 "./xsi/Geometry.xsi"
        RETVAL = THIS->getArea();
#line 4164 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getLength) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 61 "./xsi/Geometry.xsi"
        RETVAL = THIS->getLength();
#line 4184 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_distance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	double	RETVAL;
	dXSTARG;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 63 "./xsi/Geometry.xsi"
 RETVAL = THIS->distance(&g);
#line 4206 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_isWithinDistance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, g, distance");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
	double	distance = (double)SvNV(ST(2))
;
#line 65 "./xsi/Geometry.xsi"
 RETVAL = THIS->isWithinDistance(&g, distance);
#line 4229 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getCentroid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Point *	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 67 "./xsi/Geometry.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getCentroid();
#line 4249 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getInteriorPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Point *	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 69 "./xsi/Geometry.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getInteriorPoint();
#line 4274 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_symDifference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 71 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->symDifference(&other));
#line 4300 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_difference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 73 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->difference(&other));
#line 4337 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_Union) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 75 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->Union(&other));
#line 4374 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_intersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 77 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->intersection(&other));
#line 4411 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_convexHull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 79 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->convexHull());
#line 4446 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_buffer) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "THIS, distance, arg2= NULL, arg3= NULL");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	double	distance = (double)SvNV(ST(1))
;
	SV*	arg2;
	SV*	arg3;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}
#line 82 "./xsi/Geometry.xsi"
    Geometry* r;
    if (!arg2) r = THIS->buffer(distance);
    else {
        int quadrantSegments = SvIV(arg2);
        if (arg3) {
            int endCapStyle = SvIV(arg3);
            r = THIS->buffer(distance, quadrantSegments, endCapStyle);
        } else {
            r = THIS->buffer(distance, quadrantSegments);
        }
    }
    RETVAL = Helper::uplift(r);
#line 4510 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_coveredBy) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 96 "./xsi/Geometry.xsi"
 RETVAL = THIS->coveredBy(&other);
#line 4547 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_covers) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 98 "./xsi/Geometry.xsi"
 RETVAL = THIS->covers(&other);
#line 4568 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_overlaps) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 100 "./xsi/Geometry.xsi"
 RETVAL = THIS->overlaps(&other);
#line 4589 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_contains) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 102 "./xsi/Geometry.xsi"
 RETVAL = THIS->contains(&other);
#line 4610 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_within) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 104 "./xsi/Geometry.xsi"
 RETVAL = THIS->within(&other);
#line 4631 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_crosses) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 106 "./xsi/Geometry.xsi"
 RETVAL = THIS->crosses(&other);
#line 4652 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_intersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 108 "./xsi/Geometry.xsi"
 RETVAL = THIS->intersects(&other);
#line 4673 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_touches) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 110 "./xsi/Geometry.xsi"
 RETVAL = THIS->touches(&other);
#line 4694 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_disjoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	bool	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
#line 112 "./xsi/Geometry.xsi"
 RETVAL = THIS->disjoint(&other);
#line 4715 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getEnvelope) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 114 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->getEnvelope());
#line 4734 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_clone) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 116 "./xsi/Geometry.xsi"
 RETVAL = Helper::uplift(THIS->clone());
#line 4769 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getPrecisionModel) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	PrecisionModel *	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 119 "./xsi/Geometry.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto pm = THIS->getPrecisionModel();
    RETVAL = new PrecisionModel(*pm);
#line 4806 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_getCoordinates) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Array	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 124 "./xsi/Geometry.xsi"
    auto seq = std::unique_ptr(THIS->getCoordinates());
    RETVAL = Helper::convert_copy(seq.get());
#line 4831 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_relate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, other, arg= NULL");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	other = xs::in(ST(1));
;
	SV*	arg;

	if (items < 3)
	    arg = NULL;
	else {
	    arg = ST(2)
;
	}
#line 129 "./xsi/Geometry.xsi"
    if (!arg) RETVAL = xs::out(THIS->relate(&other));
    else {
        std::string intersectionPattern {  SvPV_nolen(arg) };
        RETVAL = Simple(THIS->relate(&other, intersectionPattern));
    }
#line 4871 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_normalize) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 137 "./xsi/Geometry.xsi"
        THIS->normalize();
#line 4907 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 169 "./xsi/Geometry.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 4924 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Geometry_HOOK_CLONE) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Geometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 172 "./xsi/Geometry.xsi"
    RETVAL = Helper::uplift(THIS->clone());
#line 4943 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Geometry.xsi' */


/* INCLUDE:  Including 'xsi/GeometryCollection.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__GeometryCollection_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 4 "./xsi/GeometryCollection.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 4982 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/GeometryCollection.xsi' */


/* INCLUDE:  Including 'xsi/Point.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Point_getX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Point*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/Point.xsi"
        RETVAL = THIS->getX();
#line 5008 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Point_getY) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	Point*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 6 "./xsi/Point.xsi"
        RETVAL = THIS->getY();
#line 5028 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Point_reverse) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Point*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 8 "./xsi/Point.xsi"
 RETVAL = Helper::uplift(THIS->reverse());
#line 5047 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Point.xsi' */


/* INCLUDE:  Including 'xsi/MultiPoint.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__MultiPoint_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 4 "./xsi/MultiPoint.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5086 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/MultiPoint.xsi' */


/* INCLUDE:  Including 'xsi/LineString.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__LineString_getPointN) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    {
	Point *	RETVAL;
	LineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	std::size_t	n = xs::in(ST(1));
;
#line 4 "./xsi/LineString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getPointN(n);
#line 5114 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineString_getStartPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Point *	RETVAL;
	LineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 6 "./xsi/LineString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getStartPoint();
#line 5139 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineString_getEndPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Point *	RETVAL;
	LineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 8 "./xsi/LineString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getEndPoint();
#line 5164 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineString_isClosed) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	LineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 10 "./xsi/LineString.xsi"
        RETVAL = THIS->isClosed();
#line 5188 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__LineString_isRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	LineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/LineString.xsi"
        RETVAL = THIS->isRing();
#line 5207 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/LineString.xsi' */


/* INCLUDE:  Including 'xsi/MultiLineString.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__MultiLineString_isClosed) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	MultiLineString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/MultiLineString.xsi"
        RETVAL = THIS->isClosed();
#line 5232 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/MultiLineString.xsi' */


/* INCLUDE:  Including 'xsi/LinearRing.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__LinearRing_reverse) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	LinearRing*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/LinearRing.xsi"
 RETVAL = Helper::uplift(THIS->reverse());
#line 5257 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/LinearRing.xsi' */


/* INCLUDE:  Including 'xsi/Polygon.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Polygon_getExteriorRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	LinearRing *	RETVAL;
	geos::geom::Polygon*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 6 "./xsi/Polygon.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = dyn_cast(THIS->getExteriorRing()->clone());
#line 5299 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Polygon_getInteriorRingN) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, index");
    {
	LinearRing *	RETVAL;
	geos::geom::Polygon*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	std::size_t	index = xs::in(ST(1));
;
#line 10 "./xsi/Polygon.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto r = THIS->getInteriorRingN(index);
    if (r) RETVAL = dyn_cast(r->clone());
    else XSRETURN_UNDEF;
#line 5328 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Polygon_getNumInteriorRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	std::size_t	RETVAL;
	geos::geom::Polygon*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 15 "./xsi/Polygon.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getNumInteriorRing();
#line 5353 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Polygon_tesselate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	GeometryCollection *	RETVAL;
	geos::geom::Polygon*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 18 "./xsi/Polygon.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = panda::Geos::tesselate(*THIS);
#line 5378 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Polygon_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 21 "./xsi/Polygon.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5400 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/Polygon.xsi' */


/* INCLUDE:  Including 'xsi/MultiPolygon.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__MultiPolygon_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 4 "./xsi/MultiPolygon.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5423 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/MultiPolygon.xsi' */


/* INCLUDE:  Including 'xsi/WKBConstants.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__WKBConstants_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 4 "./xsi/WKBConstants.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5446 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/WKBConstants.xsi' */


/* INCLUDE:  Including 'xsi/WKBWriter.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__WKBWriter_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 4)
       croak_xs_usage(cv,  "SV*, dims= 2, bo= getMachineByteOrder(), includeSRID= false");
    {
	WKBWriter *	RETVAL;
	int	dims;
	int	bo;
	bool	includeSRID;

	if (items < 2)
	    dims = 2;
	else {
	    dims = (int)SvIV(ST(1))
;
	}

	if (items < 3)
	    bo = getMachineByteOrder();
	else {
	    bo = (int)SvIV(ST(2))
;
	}

	if (items < 4)
	    includeSRID = false;
	else {
	    includeSRID = (bool)SvTRUE(ST(3))
;
	}
#line 5 "./xsi/WKBWriter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new WKBWriter(dims, bo, includeSRID);
#line 5494 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_getOutputDimension) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 8 "./xsi/WKBWriter.xsi"
        RETVAL = THIS->getOutputDimension();
#line 5519 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_setOutputDimension) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, newOutputDimension");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	newOutputDimension = (int)SvIV(ST(1))
;
#line 10 "./xsi/WKBWriter.xsi"
        THIS->setOutputDimension(newOutputDimension);
#line 5541 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_getByteOrder) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/WKBWriter.xsi"
        RETVAL = THIS->getByteOrder();
#line 5561 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_setByteOrder) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, newByteOrder");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	newByteOrder = (int)SvIV(ST(1))
;
#line 14 "./xsi/WKBWriter.xsi"
        THIS->setByteOrder(newByteOrder);
#line 5583 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_getIncludeSRID) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 16 "./xsi/WKBWriter.xsi"
        RETVAL = THIS->getIncludeSRID();
#line 5603 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_setIncludeSRID) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, newIncludeSRID");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	newIncludeSRID = (int)SvIV(ST(1))
;
#line 18 "./xsi/WKBWriter.xsi"
        THIS->setIncludeSRID(newIncludeSRID);
#line 5625 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_write) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	std::string	RETVAL;
	dXSTARG;
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 21 "./xsi/WKBWriter.xsi"
    std::ostringstream out;
    THIS->write(g, out);
    RETVAL = out.str();
#line 5649 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_writeHEX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	std::string	RETVAL;
	dXSTARG;
	WKBWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 27 "./xsi/WKBWriter.xsi"
    std::ostringstream out;
    THIS->writeHEX(g, out);
    RETVAL = out.str();
#line 5673 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBWriter_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 32 "./xsi/WKBWriter.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5690 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/WKBWriter.xsi' */


/* INCLUDE:  Including 'xsi/WKBReader.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__WKBReader_read) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "in, geometry_factory= NULL");
    {
	Sv	RETVAL;
	std::string	in;
	SV*	geometry_factory;

  { STRLEN __in_len;
    const char* __in_buf = SvPV(ST(0), __in_len);
    in.assign(__in_buf, __in_len); }
;

	if (items < 2)
	    geometry_factory = NULL;
	else {
	    geometry_factory = ST(1)
;
	}
#line 5 "./xsi/WKBReader.xsi"
    std::istringstream in_stream(in);
    Geometry* g;
    if (geometry_factory) {
        WKBReader r(xs::in(geometry_factory));
        g = r.read(in_stream);
    }
    else {
        WKBReader r;
        g = r.read(in_stream);
    }
    RETVAL = Helper::uplift(g);
#line 5737 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKBReader_readHEX) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "in, geometry_factory= NULL");
    {
	Sv	RETVAL;
	std::string	in;
	SV*	geometry_factory;

  { STRLEN __in_len;
    const char* __in_buf = SvPV(ST(0), __in_len);
    in.assign(__in_buf, __in_len); }
;

	if (items < 2)
	    geometry_factory = NULL;
	else {
	    geometry_factory = ST(1)
;
	}
#line 19 "./xsi/WKBReader.xsi"
    std::istringstream in_stream(in);
    Geometry* g;
    if (geometry_factory) {
        WKBReader r(xs::in(geometry_factory));
        g = r.readHEX(in_stream);
    }
    else {
        WKBReader r;
        g = r.readHEX(in_stream);
    }
    RETVAL = Helper::uplift(g);
#line 5794 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/WKBReader.xsi' */


/* INCLUDE:  Including 'xsi/WKTWriter.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__WKTWriter_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "SV*, roundingPrecision= NULL, trim= NULL");
    {
	WKTWriter *	RETVAL;
	SV*	roundingPrecision;
	SV*	trim;

	if (items < 2)
	    roundingPrecision = NULL;
	else {
	    roundingPrecision = ST(1)
;
	}

	if (items < 3)
	    trim = NULL;
	else {
	    trim = ST(2)
;
	}
#line 5 "./xsi/WKTWriter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new WKTWriter();
    if (roundingPrecision) RETVAL->setRoundingPrecision(SvIV(roundingPrecision));
    if (trim) RETVAL->setTrim(SvTRUE(trim));
#line 5852 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKTWriter_setTrim) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, value");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	WKTWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	value = (bool)SvTRUE(ST(1))
;
#line 10 "./xsi/WKTWriter.xsi"
        THIS->setTrim(value);
#line 5879 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__WKTWriter_setRoundingPrecision) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, value");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	WKTWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	value = (int)SvIV(ST(1))
;
#line 12 "./xsi/WKTWriter.xsi"
        THIS->setRoundingPrecision(value);
#line 5901 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__WKTWriter_write) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	std::string	RETVAL;
	dXSTARG;
	WKTWriter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 14 "./xsi/WKTWriter.xsi"
 RETVAL = THIS->write(&g);
#line 5923 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__WKTWriter_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 16 "./xsi/WKTWriter.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 5940 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/WKTWriter.xsi' */


/* INCLUDE:  Including 'xsi/WKTReader.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__WKTReader_read) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "in, geometry_factory= NULL");
    {
	Sv	RETVAL;
	std::string	in;
	SV*	geometry_factory;

  { STRLEN __in_len;
    const char* __in_buf = SvPV(ST(0), __in_len);
    in.assign(__in_buf, __in_len); }
;

	if (items < 2)
	    geometry_factory = NULL;
	else {
	    geometry_factory = ST(1)
;
	}
#line 5 "./xsi/WKTReader.xsi"
    Geometry* g;
    if (geometry_factory) {
        WKTReader r(xs::in(geometry_factory));
        g = r.read(in);
    }
    else {
        WKTReader r;
        g = r.read(in);
    }
    RETVAL = Helper::uplift(g);
#line 5986 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/WKTReader.xsi' */


/* INCLUDE:  Including 'xsi/PrepGeometry.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_getGeometry) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Geometry *	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/PrepGeometry.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
 RETVAL = THIS->getGeometry().clone();
#line 6028 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_contains) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 6 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->contains(&geom);
#line 6054 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_containsProperly) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 8 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->containsProperly(&geom);
#line 6075 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_coveredBy) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 10 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->coveredBy(&geom);
#line 6096 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_covers) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 12 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->covers(&geom);
#line 6117 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_crosses) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 14 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->crosses(&geom);
#line 6138 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_disjoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 16 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->disjoint(&geom);
#line 6159 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_intersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 18 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->intersects(&geom);
#line 6180 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_overlaps) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 20 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->overlaps(&geom);
#line 6201 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_touches) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 22 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->touches(&geom);
#line 6222 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_within) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, geom");
    {
	bool	RETVAL;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	geom = xs::in(ST(1));
;
#line 24 "./xsi/PrepGeometry.xsi"
 RETVAL = THIS->within(&geom);
#line 6243 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	BasicPreparedGeometry*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 26 "./xsi/PrepGeometry.xsi"
        RETVAL = THIS->toString();
#line 6263 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Prep__Geometry_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 28 "./xsi/PrepGeometry.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 6280 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/PrepGeometry.xsi' */


/* INCLUDE:  Including 'xsi/PrepGeometryFactory.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Prep__GeometryFactory_prepare) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	BasicPreparedGeometry *	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 5 "./xsi/PrepGeometryFactory.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto pg = const_cast(PreparedGeometryFactory::prepare(&g));
    RETVAL = static_cast(pg);
#line 6307 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/PrepGeometryFactory.xsi' */


/* INCLUDE:  Including 'xsi/algorithm.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Algorithm_toDegrees) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "radians");
    {
	double	RETVAL;
	dXSTARG;
	double	radians = (double)SvNV(ST(0))
;
#line 4 "./xsi/algorithm.xsi"
 RETVAL = Angle::toDegrees(radians);
#line 6338 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_toRadians) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "angleDegrees");
    {
	double	RETVAL;
	dXSTARG;
	double	angleDegrees = (double)SvNV(ST(0))
;
#line 6 "./xsi/algorithm.xsi"
 RETVAL = Angle::toRadians(angleDegrees);
#line 6358 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_angle) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "p0");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	p0 = xs::in(ST(0));
;
#line 8 "./xsi/algorithm.xsi"
 RETVAL = Angle::angle(p0);
#line 6378 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_isAcute) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p0, p1, p2");
    {
	bool	RETVAL;
	Coordinate*	p0 = xs::in(ST(0));
;
	Coordinate*	p1 = xs::in(ST(1));
;
	Coordinate *	p2 = xs::in(ST(2));
;
#line 11 "./xsi/algorithm.xsi"
    RETVAL = Angle::isAcute(*p0, *p1, *p2);
#line 6401 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_isObtuse) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p0, p1, p2");
    {
	bool	RETVAL;
	Coordinate&	p0 = xs::in(ST(0));
;
	Coordinate&	p1 = xs::in(ST(1));
;
	Coordinate&	p2 = xs::in(ST(2));
;
#line 15 "./xsi/algorithm.xsi"
    RETVAL = Angle::isObtuse(p0, p1, p2);
#line 6424 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_angleBetween) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "tip1, tail, tip2");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	tip1 = xs::in(ST(0));
;
	Coordinate&	tail = xs::in(ST(1));
;
	Coordinate&	tip2 = xs::in(ST(2));
;
#line 19 "./xsi/algorithm.xsi"
    RETVAL = Angle::angleBetween(tip1, tail, tip2);
#line 6448 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_angleBetweenOriented) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "tip1, tail, tip2");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	tip1 = xs::in(ST(0));
;
	Coordinate&	tail = xs::in(ST(1));
;
	Coordinate&	tip2 = xs::in(ST(2));
;
#line 23 "./xsi/algorithm.xsi"
    RETVAL = Angle::angleBetweenOriented (tip1, tail, tip2);
#line 6472 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_interiorAngle) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p0, p1, p2");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	p0 = xs::in(ST(0));
;
	Coordinate&	p1 = xs::in(ST(1));
;
	Coordinate&	p2 = xs::in(ST(2));
;
#line 27 "./xsi/algorithm.xsi"
    RETVAL = Angle::interiorAngle(p0, p1, p2);
#line 6496 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_getTurn) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "ang1, ang2");
    {
	int	RETVAL;
	dXSTARG;
	double	ang1 = (double)SvNV(ST(0))
;
	double	ang2 = (double)SvNV(ST(1))
;
#line 30 "./xsi/algorithm.xsi"
 RETVAL = Angle::getTurn(ang1, ang2);
#line 6518 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_normalize) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "angle");
    {
	double	RETVAL;
	dXSTARG;
	double	angle = (double)SvNV(ST(0))
;
#line 32 "./xsi/algorithm.xsi"
 RETVAL = Angle::normalize(angle);
#line 6538 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_normalizePositive) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "angle");
    {
	double	RETVAL;
	dXSTARG;
	double	angle = (double)SvNV(ST(0))
;
#line 34 "./xsi/algorithm.xsi"
 RETVAL = Angle::normalizePositive(angle);
#line 6558 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_diff) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "ang1, ang2");
    {
	double	RETVAL;
	dXSTARG;
	double	ang1 = (double)SvNV(ST(0))
;
	double	ang2 = (double)SvNV(ST(1))
;
#line 36 "./xsi/algorithm.xsi"
 RETVAL = Angle::diff(ang1, ang2);
#line 6580 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_centroid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Coordinate *	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 39 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    if (Centroid::getCentroid(g, c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 6602 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_centroidArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "geoms");
    {
	Coordinate *	RETVAL;
	Array    geoms = ST(0);
    if (!geoms && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 45 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate result;
    CentroidArea acc;
    for(size_t i = 0; i < geoms.size(); ++i) {
        auto item = geoms.at(i);
        if (item.is_array_ref()) {
            auto seq = Helper::convert_coords(Array(item));
            acc.add(&seq);
        }
        else {
            acc.add(&xs::in(item));
        }
    }
    if (acc.getCentroid(result)) RETVAL = new Coordinate(result);
    else XSRETURN_UNDEF;
#line 6641 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_centroidLine) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "geoms");
    {
	Coordinate *	RETVAL;
	Array    geoms = ST(0);
    if (!geoms && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 63 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate result;
    CentroidLine acc;
    for(size_t i = 0; i < geoms.size(); ++i) {
        auto item = geoms.at(i);
        if (item.is_array_ref()) {
            auto seq = Helper::convert_coords(Array(item));
            acc.add(&seq);
        }
        else {
            acc.add(&xs::in(item));
        }
    }
    if (acc.getCentroid(result)) RETVAL = new Coordinate(result);
    else XSRETURN_UNDEF;
#line 6680 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_centroidPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "geoms");
    {
	Coordinate *	RETVAL;
	Array    geoms = ST(0);
    if (!geoms && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 80 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate result;
    CentroidPoint acc;
    for(size_t i = 0; i < geoms.size(); ++i) {
        Object item = Object(geoms.at(i));
        if (!item) throw ("invalid argument");
        if (item.stash().name() == "Geo::Geos::Coordinate") {
            acc.add(&xs::in(item));
        }
        else acc.add(&xs::in(item));
    }
    if (acc.getCentroid(result)) RETVAL = new Coordinate(result);
    else XSRETURN_UNDEF;
#line 6717 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_isPointInRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, ring");
    {
	bool	RETVAL;
	Coordinate&	p = xs::in(ST(0));
;
	Array    ring = ST(1);
    if (!ring && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 95 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(ring);
    RETVAL = CGAlgorithms::isPointInRing(p, &seq);
#line 6745 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_locatePointInRing) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, ring");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Array    ring = ST(1);
    if (!ring && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 100 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(ring);
    RETVAL = CGAlgorithms::locatePointInRing(p, seq);
#line 6769 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_isOnLine) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, line");
    {
	bool	RETVAL;
	Coordinate&	p = xs::in(ST(0));
;
	Array    line = ST(1);
    if (!line && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 105 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(line);
    RETVAL = CGAlgorithms::isPointInRing(p, &seq);
#line 6792 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_isCCW) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "ring");
    {
	bool	RETVAL;
	Array    ring = ST(0);
    if (!ring && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 110 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(ring);
    RETVAL = CGAlgorithms::isCCW(&seq);
#line 6813 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_computeOrientation) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p1, p2, q");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p1 = xs::in(ST(0));
;
	Coordinate&	p2 = xs::in(ST(1));
;
	Coordinate&	q = xs::in(ST(2));
;
#line 115 "./xsi/algorithm.xsi"
    RETVAL = CGAlgorithms::computeOrientation(p1, p2, q);
#line 6837 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_distancePointLine) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, A, B");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Coordinate&	A = xs::in(ST(1));
;
	Coordinate&	B = xs::in(ST(2));
;
#line 119 "./xsi/algorithm.xsi"
    RETVAL = CGAlgorithms::distancePointLine(p, A, B);
#line 6861 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_distancePointLinePerpendicular) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, A, B");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Coordinate&	A = xs::in(ST(1));
;
	Coordinate&	B = xs::in(ST(2));
;
#line 123 "./xsi/algorithm.xsi"
    RETVAL = CGAlgorithms::distancePointLinePerpendicular(p, A, B);
#line 6885 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_distanceLineLine) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "A, B, C, D");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate&	A = xs::in(ST(0));
;
	Coordinate&	B = xs::in(ST(1));
;
	Coordinate&	C = xs::in(ST(2));
;
	Coordinate&	D = xs::in(ST(3));
;
#line 127 "./xsi/algorithm.xsi"
    RETVAL = CGAlgorithms::distanceLineLine(A, B, C, D);
#line 6911 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_signedArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "ring");
    {
	double	RETVAL;
	dXSTARG;
	Array    ring = ST(0);
    if (!ring && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 131 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(ring);
    RETVAL = CGAlgorithms::signedArea(&seq);
#line 6933 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_length) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "pts");
    {
	double	RETVAL;
	dXSTARG;
	Array    pts = ST(0);
    if (!pts && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 136 "./xsi/algorithm.xsi"
    auto seq = Helper::convert_coords(pts);
    RETVAL = CGAlgorithms::signedArea(&seq);
#line 6955 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_orientationIndex) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p1, p2, q");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p1 = xs::in(ST(0));
;
	Coordinate&	p2 = xs::in(ST(1));
;
	Coordinate&	q = xs::in(ST(2));
;
#line 141 "./xsi/algorithm.xsi"
    RETVAL = CGAlgorithms::computeOrientation(p1, p2, q);
#line 6979 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_getIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p00, p01, p10, p11");
    {
	Coordinate *	RETVAL;
	Coordinate&	p00 = xs::in(ST(0));
;
	Coordinate&	p01 = xs::in(ST(1));
;
	Coordinate&	p10 = xs::in(ST(2));
;
	Coordinate&	p11 = xs::in(ST(3));
;
#line 145 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    //auto& c = CentralEndpointIntersector::getIntersection(p00, p01, p10, p11);
    // ^ buggy implementation in 3.6.3, as it returns dangling reference;
    CentralEndpointIntersector intor(p00, p01, p10, p11);
    auto& c = intor.getIntersection();
    RETVAL = new Coordinate(c);
#line 7009 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_convexHull) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "newGeometry");
    {
	Sv	RETVAL;
	Geometry&	newGeometry = xs::in(ST(0));
;
#line 153 "./xsi/algorithm.xsi"
    auto ch = ConvexHull(&newGeometry);
    RETVAL = Helper::uplift(ch.getConvexHull());
#line 7034 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_interiorPointArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Coordinate *	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 158 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    InteriorPointArea ip(&g);
    Coordinate c;
    if (ip.getInteriorPoint(c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 7073 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_interiorPointLine) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Coordinate *	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 165 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    InteriorPointLine ip(&g);
    Coordinate c;
    if (ip.getInteriorPoint(c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 7101 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_interiorPointPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Coordinate *	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 172 "./xsi/algorithm.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    InteriorPointPoint ip(&g);
    Coordinate c;
    if (ip.getInteriorPoint(c)) RETVAL = new Coordinate(c);
    else XSRETURN_UNDEF;
#line 7129 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_locate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, geom");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Geometry&	geom = xs::in(ST(1));
;
#line 179 "./xsi/algorithm.xsi"
    PointLocator pl;
    RETVAL = pl.locate(p, &geom);
#line 7157 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_intersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, geom");
    {
	bool	RETVAL;
	Coordinate&	p = xs::in(ST(0));
;
	Geometry&	geom = xs::in(ST(1));
;
#line 184 "./xsi/algorithm.xsi"
    PointLocator pl;
    RETVAL = pl.intersects(p, &geom);
#line 7179 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_signOfDet2x2) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "x1, y1, x2, y2");
    {
	int	RETVAL;
	dXSTARG;
	double	x1 = (double)SvNV(ST(0))
;
	double	y1 = (double)SvNV(ST(1))
;
	double	x2 = (double)SvNV(ST(2))
;
	double	y2 = (double)SvNV(ST(3))
;
#line 189 "./xsi/algorithm.xsi"
    RETVAL = RobustDeterminant::signOfDet2x2(x1, y1, x2, y2);
#line 7205 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_locateIndexedPointInArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, geom");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Geometry&	geom = xs::in(ST(1));
;
#line 193 "./xsi/algorithm.xsi"
    locate::IndexedPointInAreaLocator locator(geom);
    RETVAL = locator.locate(&p);
#line 7228 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm_locateSimplePointInArea) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "p, geom");
    {
	int	RETVAL;
	dXSTARG;
	Coordinate&	p = xs::in(ST(0));
;
	Geometry&	geom = xs::in(ST(1));
;
#line 198 "./xsi/algorithm.xsi"
    locate::SimplePointInAreaLocator locator(&geom);
    RETVAL = locator.locate(&p);
#line 7251 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/algorithm.xsi' */


/* INCLUDE:  Including 'xsi/algorithm/HCoordinate.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 5)
       croak_xs_usage(cv,  "SV*, arg1, arg2= NULL, arg3= NULL, arg4= NULL");
    {
	HCoordinate *	RETVAL;
	SV*	arg1 = ST(1)
;
	SV*	arg2;
	SV*	arg3;
	SV*	arg4;

	if (items < 3)
	    arg2 = NULL;
	else {
	    arg2 = ST(2)
;
	}

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 5 "./xsi/algorithm/HCoordinate.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!arg2) {
        auto c = xs::in(arg1);
        RETVAL = new HCoordinate(*c);
    }
    else if(!arg3) {
        Object obj1 {arg1}, obj2{arg2};
        if(!obj1) throw("wrong argument");
        if(!obj2) throw("wrong argument");
        if (obj1.stash().name() == "Geo::Geos::Algorithm::HCoordinate") {
            auto& c1 = xs::in(obj1);
            auto& c2 = xs::in(obj1);
            RETVAL = new HCoordinate(c1, c2);
        }
        else {
            auto& c1 = xs::in(obj1);
            auto& c2 = xs::in(obj1);
            RETVAL = new HCoordinate(c1, c2);
        }
    }
    else if(!arg4) {
        if(!arg1) throw("undef not allowed");
        if(!arg2) throw("undef not allowed");
        if(!arg3) throw("undef not allowed");
        RETVAL = new HCoordinate(Simple(arg1), Simple(arg2), Simple(arg3));
    }
    else {
        auto& c1 = xs::in(arg1);
        auto& c2 = xs::in(arg2);
        auto& c3 = xs::in(arg3);
        auto& c4 = xs::in(arg4);
        RETVAL = new HCoordinate(c1, c2, c3, c4);
    }
#line 7332 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_x) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	double	RETVAL;
	dXSTARG;
	HCoordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 40 "./xsi/algorithm/HCoordinate.xsi"
    double* val;
    switch (ix) {
        case 0:  val = &THIS->x; break;
        case 1:  val = &THIS->y; break;
        default: val = &THIS->w; break;
    }
    if (newval) {
        *val = SvNV(newval);
    }
    RETVAL = *val;
#line 7375 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_getCoordinate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	HCoordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 53 "./xsi/algorithm/HCoordinate.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    THIS->getCoordinate(c);
    RETVAL = new Coordinate(c);
#line 7397 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_intersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "p1, p2, q1, q2");
    {
	Coordinate *	RETVAL;
	Coordinate&	p1 = xs::in(ST(0));
;
	Coordinate&	p2 = xs::in(ST(1));
;
	Coordinate&	q1 = xs::in(ST(2));
;
	Coordinate&	q2 = xs::in(ST(3));
;
#line 60 "./xsi/algorithm/HCoordinate.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Coordinate c;
    HCoordinate::intersection(p1, p2, q1, q2, c);
    RETVAL = new Coordinate(c);
#line 7430 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	HCoordinate*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 66 "./xsi/algorithm/HCoordinate.xsi"
    std::ostringstream out;
    out << *THIS;
    RETVAL = out.str();
#line 7457 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__HCoordinate_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 71 "./xsi/algorithm/HCoordinate.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 7474 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/algorithm/HCoordinate.xsi' */


/* INCLUDE:  Including 'xsi/algorithm/MinimumDiameter.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "SV*, g, hint= NULL");
    {
	MinimumDiameter *	RETVAL;
	Geometry&	g = xs::in(ST(1));
;
	SV*	hint;

	if (items < 3)
	    hint = NULL;
	else {
	    hint = ST(2)
;
	}
#line 5 "./xsi/algorithm/MinimumDiameter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!hint) {
        bool convex = SvTRUE(hint);
        RETVAL = new MinimumDiameter(&g, convex);
    }
    else RETVAL = new MinimumDiameter(&g);
#line 7512 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getMinimumRectangle) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "obj");
    {
	Sv	RETVAL;
	Object    obj = ST(0);
    if (!obj && SvOK(ST(0))) throw "arg is not a blessed reference"
;
#line 13 "./xsi/algorithm/MinimumDiameter.xsi"
    Geometry* r;
    if (obj.stash().name() == "Geo::Geos::Algorithm::MinimumDiameter") {
        auto& self = xs::in(obj);
        r = self.getMinimumRectangle();
    }
    else {
        auto& g = xs::in(obj);
        r = MinimumDiameter::getMinimumRectangle(&g);
    }
    RETVAL = Helper::uplift(r);
#line 7546 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getMinimumDiameter) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Sv	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 26 "./xsi/algorithm/MinimumDiameter.xsi"
    RETVAL = Helper::uplift(MinimumDiameter::getMinimumDiameter(&g));
#line 7581 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getLength) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	double	RETVAL;
	dXSTARG;
	MinimumDiameter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 29 "./xsi/algorithm/MinimumDiameter.xsi"
        RETVAL = THIS->getLength();
#line 7617 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getWidthCoordinate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	MinimumDiameter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 32 "./xsi/algorithm/MinimumDiameter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(* (THIS->getWidthCoordinate()));
#line 7637 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getSupportingSegment) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	LineString *	RETVAL;
	MinimumDiameter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 36 "./xsi/algorithm/MinimumDiameter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = dyn_cast(THIS->getSupportingSegment());
#line 7662 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_getDiameter) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	LineString *	RETVAL;
	MinimumDiameter*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 40 "./xsi/algorithm/MinimumDiameter.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = dyn_cast(THIS->getDiameter());
#line 7687 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__MinimumDiameter_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 44 "./xsi/algorithm/MinimumDiameter.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 7709 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/algorithm/MinimumDiameter.xsi' */


/* INCLUDE:  Including 'xsi/algorithm/LineIntersector.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "SV*, precisionModel= NULL");
    {
	Sv	RETVAL;
	SV*	precisionModel;

	if (items < 2)
	    precisionModel = NULL;
	else {
	    precisionModel = ST(1)
;
	}
#line 5 "./xsi/algorithm/LineIntersector.xsi"
    PrecisionModel* pm = precisionModel ? xs::in(precisionModel) : NULL;
    Object wrapped = xs::out(new LineIntersector(pm));
    if (pm) wrapped.payload_attach(precisionModel, &payload_marker);
    RETVAL = wrapped.ref();
#line 7743 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_interpolateZ) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, p0, p1");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate *	p = xs::in(ST(0));
;
	Coordinate *	p0 = xs::in(ST(1));
;
	Coordinate *	p1 = xs::in(ST(2));
;
#line 11 "./xsi/algorithm/LineIntersector.xsi"
 RETVAL = LineIntersector::interpolateZ(*p, *p0, *p1);
#line 7783 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_computeEdgeDistance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "p, p0, p1");
    {
	double	RETVAL;
	dXSTARG;
	Coordinate *	p = xs::in(ST(0));
;
	Coordinate *	p0 = xs::in(ST(1));
;
	Coordinate *	p1 = xs::in(ST(2));
;
#line 13 "./xsi/algorithm/LineIntersector.xsi"
 RETVAL = LineIntersector::computeEdgeDistance(*p, *p0, *p1);
#line 7807 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_isSameSignAndNonZero) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "a, b");
    {
	bool	RETVAL;
	double	a = (double)SvNV(ST(0))
;
	double	b = (double)SvNV(ST(1))
;
#line 15 "./xsi/algorithm/LineIntersector.xsi"
 RETVAL = LineIntersector::isSameSignAndNonZero(a, b);
#line 7828 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_hasIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 3)
       croak_xs_usage(cv,  "arg0, p1= NULL, p2= NULL");
    {
	bool	RETVAL;
	Object    arg0 = ST(0);
    if (!arg0 && SvOK(ST(0))) throw "arg is not a blessed reference"
;
	Coordinate *	p1;
	Coordinate *	p2;

	if (items < 2)
	    p1 = NULL;
	else {
	    p1 = xs::in(ST(1));
;
	}

	if (items < 3)
	    p2 = NULL;
	else {
	    p2 = xs::in(ST(2));
;
	}
#line 18 "./xsi/algorithm/LineIntersector.xsi"
    if (p1 == NULL) RETVAL = xs::in(arg0).hasIntersection();
    else {
        auto& p0 = xs::in(arg0);
        if(!p1) throw("undef not allowed");
        if(!p2) throw("undef not allowed");
        RETVAL = LineIntersector::hasIntersection(p0, *p1, *p2);
    }
#line 7870 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_isInteriorIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, arg= NULL");
    {
	bool	RETVAL;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	arg;

	if (items < 2)
	    arg = NULL;
	else {
	    arg = ST(1)
;
	}
#line 29 "./xsi/algorithm/LineIntersector.xsi"
    if(!arg) RETVAL = THIS->isInteriorIntersection();
    else {
        int inputLineIndex = SvIV(arg);
        RETVAL = THIS->isInteriorIntersection(inputLineIndex);
    }
#line 7901 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_setPrecisionModel) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, pm");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	pm = ST(1)
;
#line 37 "./xsi/algorithm/LineIntersector.xsi"
    PrecisionModel& newPM = xs::in(pm);
    THIS->setPrecisionModel(&newPM);
    Object me {ST(0)};
    if (me.payload_exists(&payload_marker)) {
        me.payload_detach(&payload_marker);
    }
    me.payload_attach(SvRV(pm), &payload_marker);
#line 7929 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_computeIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 4 || items > 5)
       croak_xs_usage(cv,  "THIS, p1, p2, p3, p4arg= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	p1 = xs::in(ST(1));
;
	Coordinate&	p2 = xs::in(ST(2));
;
	Coordinate&	p3 = xs::in(ST(3));
;
	SV*	p4arg;

	if (items < 5)
	    p4arg = NULL;
	else {
	    p4arg = ST(4)
;
	}
#line 47 "./xsi/algorithm/LineIntersector.xsi"
    if (!p4arg) THIS->computeIntersection(p1, p2, p3);
    else {
        auto& p4 = xs::in(p4arg);
        THIS->computeIntersection(p1, p2, p3, p4);
    }
#line 7967 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 54 "./xsi/algorithm/LineIntersector.xsi"
        RETVAL = THIS->toString();
#line 7987 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_getIntersectionNum) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 56 "./xsi/algorithm/LineIntersector.xsi"
        RETVAL = THIS->getIntersectionNum();
#line 8007 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_isProper) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 58 "./xsi/algorithm/LineIntersector.xsi"
        RETVAL = THIS->isProper();
#line 8026 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_getIndexAlongSegment) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, segmentIndex, intIndex");
    {
	int	RETVAL;
	dXSTARG;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	segmentIndex = (int)SvIV(ST(1))
;
	int	intIndex = (int)SvIV(ST(2))
;
#line 60 "./xsi/algorithm/LineIntersector.xsi"
        RETVAL = THIS->getIndexAlongSegment(segmentIndex, intIndex);
#line 8050 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_getEdgeDistance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, geomIndex, intIndex");
    {
	double	RETVAL;
	dXSTARG;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	geomIndex = (int)SvIV(ST(1))
;
	int	intIndex = (int)SvIV(ST(2))
;
#line 62 "./xsi/algorithm/LineIntersector.xsi"
        RETVAL = THIS->getEdgeDistance(geomIndex, intIndex);
#line 8074 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_getIntersectionAlongSegment) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, segmentIndex, intIndex");
    {
	Coordinate *	RETVAL;
	LineIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	segmentIndex = (int)SvIV(ST(1))
;
	int	intIndex = (int)SvIV(ST(2))
;
#line 65 "./xsi/algorithm/LineIntersector.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(THIS->getIntersectionAlongSegment(segmentIndex, intIndex));
#line 8098 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Algorithm__LineIntersector_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 68 "./xsi/algorithm/LineIntersector.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 8120 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/algorithm/LineIntersector.xsi' */


/* INCLUDE:  Including 'xsi/noding.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding_compareOrientedCoordinateArray) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "pts1, pts2");
    {
	int	RETVAL;
	dXSTARG;
	Array    pts1 = ST(0);
    if (!pts1 && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
	Array    pts2 = ST(1);
    if (!pts2 && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 5 "./xsi/noding.xsi"
    auto seq1 = Helper::convert_coords(pts1);
    auto seq2 = Helper::convert_coords(pts2);
    geos::noding::OrientedCoordinateArray oca{seq1};
    RETVAL = oca.compareTo(seq2);
#line 8153 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding_octant) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "arg1, arg2");
    {
	int	RETVAL;
	dXSTARG;
	Sv    arg1 = ST(0)
;
	SV*	arg2 = ST(1)
;
#line 12 "./xsi/noding.xsi"
    if (arg1.is_object_ref() && Object(arg1).stash().name() == "Geo::Geos::Coordinate") {
        auto& c1 = xs::in(arg1);
        auto& c2 = xs::in(arg2);
        RETVAL = Octant::octant(&c1, &c2);
    } else {
        if(!arg1) throw("undef not allowed");
        if(!arg2) throw("undef not allowed");
        double dx = SvNV(arg1);
        double dy = SvNV(arg2);
        RETVAL = Octant::octant(dx, dy);
    }
#line 8185 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding_checkNodingValid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "segmentStrigns");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Array    segmentStrigns = ST(0);
    if (!segmentStrigns && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 26 "./xsi/noding.xsi"
    std::vector v;
    v.reserve(segmentStrigns.size());

    for (auto it: segmentStrigns) {
        SegmentString& ss = xs::in(it);
        v.push_back(&ss);
    }
    NodingValidator nv(v);
    nv.checkValid();
#line 8214 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding_fastCheckNodingValid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "segmentStrigns");
    {
	std::string	RETVAL;
	dXSTARG;
	Array    segmentStrigns = ST(0);
    if (!segmentStrigns && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 38 "./xsi/noding.xsi"
    std::vector v;
    v.reserve(segmentStrigns.size());

    for (auto it: segmentStrigns) {
        SegmentString& ss = xs::in(it);
        v.push_back(&ss);
    }
    FastNodingValidator fnv{v};

    if (GIMME_V == G_VOID) {
        fnv.checkValid();
        XSRETURN_UNDEF;
    }
    else {
        if (fnv.isValid()) XSRETURN_UNDEF;
        else RETVAL = fnv.getErrorMessage();
    }
#line 8251 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding_compareSegmentPoints) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "octant, p1, p2");
    {
	int	RETVAL;
	dXSTARG;
	int	octant = (int)SvIV(ST(0))
;
	Coordinate&	p1 = xs::in(ST(1));
;
	Coordinate&	p2 = xs::in(ST(2));
;
#line 58 "./xsi/noding.xsi"
    RETVAL = SegmentPointComparator::compare(octant, p1, p2);
#line 8275 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding_extractSegmentStrings) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Array	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 62 "./xsi/noding.xsi"
    SegmentString::ConstVect v;
    geos::noding::SegmentStringUtil::extractSegmentStrings(&g, v);

    Array result = xs::Array::create(v.size());
    for(auto ss: v) {
        auto it = xs::out(const_cast(ss));
        result.push(it);
    };
    RETVAL = result;
#line 8302 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding_intersects) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "baseSegmentStrings, segmentStrings, intDetector= NULL");
    {
	bool	RETVAL;
	Array    baseSegmentStrings = ST(0);
    if (!baseSegmentStrings && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
	Array    segmentStrings = ST(1);
    if (!segmentStrings && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
	SV*	intDetector;

	if (items < 3)
	    intDetector = NULL;
	else {
	    intDetector = ST(2)
;
	}
#line 74 "./xsi/noding.xsi"
    SegmentString::ConstVect vb;
    for(auto it: baseSegmentStrings) vb.push_back(&xs::in(it));

    SegmentString::ConstVect v;
    for(auto it: segmentStrings) v.push_back(&xs::in(it));

    FastSegmentSetIntersectionFinder finder{&vb};
    if (!intDetector) RETVAL = finder.intersects(&v);
    else {
        auto& id = xs::in(intDetector);
        RETVAL = finder.intersects(&v, &id);
    }
#line 8351 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding.xsi' */


/* INCLUDE:  Including 'xsi/noding/SegmentString.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SegmentString_size) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	unsigned int	RETVAL;
	dXSTARG;
	SegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/noding/SegmentString.xsi"
        RETVAL = THIS->size();
#line 8377 "Geos_xsgen.cc"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentString_getCoordinate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, i");
    {
	Coordinate *	RETVAL;
	SegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	unsigned int	i = (unsigned int)SvUV(ST(1))
;
#line 7 "./xsi/noding/SegmentString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(THIS->getCoordinate(i));
#line 8399 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentString_getCoordinates) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Array	RETVAL;
	SegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 11 "./xsi/noding/SegmentString.xsi"
    auto seq = THIS->getCoordinates();
    RETVAL = Helper::convert_copy(seq);
#line 8424 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentString_isClosed) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 15 "./xsi/noding/SegmentString.xsi"
        RETVAL = THIS->isClosed();
#line 8450 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentString_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	SegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 18 "./xsi/noding/SegmentString.xsi"
    std::ostringstream out;
    out << *THIS;
    RETVAL = out.str();
#line 8472 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SegmentString.xsi' */


/* INCLUDE:  Including 'xsi/noding/SegmentNode.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_isInterior) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 4 "./xsi/noding/SegmentNode.xsi"
        RETVAL = THIS->isInterior();
#line 8497 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_isEndPoint) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, maxSegmentIndex");
    {
	bool	RETVAL;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	unsigned int	maxSegmentIndex = (unsigned int)SvUV(ST(1))
;
#line 6 "./xsi/noding/SegmentNode.xsi"
        RETVAL = THIS->isEndPoint(maxSegmentIndex);
#line 8518 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_compareTo) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, other");
    {
	int	RETVAL;
	dXSTARG;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SegmentNode&	other = xs::in(ST(1));
;
#line 8 "./xsi/noding/SegmentNode.xsi"
        RETVAL = THIS->compareTo(other);
#line 8540 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 11 "./xsi/noding/SegmentNode.xsi"
    std::ostringstream out;
    out << *THIS;
    RETVAL = out.str();
#line 8562 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_coord) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 17 "./xsi/noding/SegmentNode.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(THIS->coord);
#line 8582 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentNode_segmentIndex) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	unsigned int	RETVAL;
	dXSTARG;
	SegmentNode*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 20 "./xsi/noding/SegmentNode.xsi"
 RETVAL = THIS->segmentIndex;
#line 8607 "Geos_xsgen.cc"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SegmentNode.xsi' */


/* INCLUDE:  Including 'xsi/noding/NodedSegmentString.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, coords");
    {
	NodedSegmentString *	RETVAL;
	Array    coords = ST(1);
    if (!coords && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 5 "./xsi/noding/NodedSegmentString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto seq = Helper::convert_coords(coords);
    auto v = new NodedSegmentString(seq.clone(), NULL);
    RETVAL = v;
#line 8636 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_addIntersectionNode) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, c, segmentIndex");
    {
	Sv	RETVAL;
	NodedSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Coordinate&	c = xs::in(ST(1));
;
	std::size_t	segmentIndex = xs::in(ST(2));
;
#line 11 "./xsi/noding/NodedSegmentString.xsi"
    auto* node = THIS->addIntersectionNode(&c, segmentIndex);
    Sv wrapped = xs::out(node);
    Object obj{ST(0)};
    wrapped.payload_attach(obj.detach(), &payload_marker);
    RETVAL = wrapped;
#line 8668 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_getSegmentOctant) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, index");
    {
	int	RETVAL;
	dXSTARG;
	NodedSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	unsigned int	index = (unsigned int)SvUV(ST(1))
;
#line 18 "./xsi/noding/NodedSegmentString.xsi"
        RETVAL = THIS->getSegmentOctant(index);
#line 8706 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_addIntersections) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "THIS, li, segmentIndex, geomIndex");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	NodedSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	LineIntersector&	li = xs::in(ST(1));
;
	unsigned int	segmentIndex = (unsigned int)SvUV(ST(2))
;
	int	geomIndex = (int)SvIV(ST(3))
;
#line 21 "./xsi/noding/NodedSegmentString.xsi"
    THIS->addIntersections(&li, segmentIndex, geomIndex);
#line 8732 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_addIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 3 || items > 5)
       croak_xs_usage(cv,  "THIS, arg1, segmentIndex, arg3= NULL, arg4= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	NodedSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Object    arg1 = ST(1);
    if (!arg1 && SvOK(ST(1))) throw "arg is not a blessed reference"
;
	unsigned int	segmentIndex = (unsigned int)SvUV(ST(2))
;
	SV*	arg3;
	SV*	arg4;

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 25 "./xsi/noding/NodedSegmentString.xsi"
    if (!arg3) {
        auto& c = xs::in(arg1);
        THIS->addIntersection(c, segmentIndex);
    }
    else {
        auto& li = xs::in(arg1);
        if (!arg3) throw("missing mandatory argument");
        if (!arg4) throw("missing mandatory argument");
        THIS->addIntersection(&li, segmentIndex, SvIV(arg3), SvIV(arg4));
    }
#line 8782 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__NodedSegmentString_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 37 "./xsi/noding/NodedSegmentString.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 8799 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/NodedSegmentString.xsi' */


/* INCLUDE:  Including 'xsi/noding/BasicSegmentString.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__BasicSegmentString_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, coords");
    {
	BasicSegmentString *	RETVAL;
	Array    coords = ST(1);
    if (!coords && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 6 "./xsi/noding/BasicSegmentString.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto seq = Helper::convert_coords(coords);
    auto deep_clone = seq.clone();
    RETVAL = new BasicSegmentString(deep_clone, NULL);
#line 8828 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__BasicSegmentString_DESTROY) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	BasicSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/noding/BasicSegmentString.xsi"
    delete THIS->getCoordinates();
        xs::Typemap().destroy(THIS, SvRV(ST(0)));
#line 8854 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__BasicSegmentString_getSegmentOctant) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, index");
    {
	int	RETVAL;
	dXSTARG;
	BasicSegmentString*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	unsigned int	index = (unsigned int)SvUV(ST(1))
;
#line 15 "./xsi/noding/BasicSegmentString.xsi"
        RETVAL = THIS->getSegmentOctant(index);
#line 8876 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__BasicSegmentString_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 17 "./xsi/noding/BasicSegmentString.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 8893 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/BasicSegmentString.xsi' */


/* INCLUDE:  Including 'xsi/noding/SegmentIntersector.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersector_processIntersections) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 5)
       croak_xs_usage(cv,  "THIS, e0, segIndex0, e1, segIndex1");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SegmentIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SegmentString&	e0 = xs::in(ST(1));
;
	int	segIndex0 = (int)SvIV(ST(2))
;
	SegmentString&	e1 = xs::in(ST(3));
;
	int	segIndex1 = (int)SvIV(ST(4))
;
#line 6 "./xsi/noding/SegmentIntersector.xsi"
    THIS->processIntersections(&e0, segIndex0, &e1, segIndex1);
#line 8927 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersector_isDone) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentIntersector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 9 "./xsi/noding/SegmentIntersector.xsi"
        RETVAL = THIS->isDone();
#line 8946 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SegmentIntersector.xsi' */


/* INCLUDE:  Including 'xsi/noding/SegmentIntersectionDetector.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, liObj");
    {
	Sv	RETVAL;
	SV*	liObj = ST(1)
;
#line 5 "./xsi/noding/SegmentIntersectionDetector.xsi"
    LineIntersector& li = xs::in(liObj);
    Sv wrapped = xs::out<>(new SegmentIntersectionDetector(&li));
    wrapped.payload_attach(SvRV(liObj), &payload_marker);
    RETVAL = wrapped;
#line 8974 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/noding/SegmentIntersectionDetector.xsi"
        RETVAL = THIS->hasIntersection();
#line 9009 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasProperIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 14 "./xsi/noding/SegmentIntersectionDetector.xsi"
        RETVAL = THIS->hasProperIntersection();
#line 9028 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasNonProperIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 16 "./xsi/noding/SegmentIntersectionDetector.xsi"
        RETVAL = THIS->hasNonProperIntersection();
#line 9047 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_setFindProper) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, findProper");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	findProper = (bool)SvTRUE(ST(1))
;
#line 18 "./xsi/noding/SegmentIntersectionDetector.xsi"
        THIS->setFindProper(findProper);
#line 9069 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_setFindAllIntersectionTypes) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, findAllTypes");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	findAllTypes = (bool)SvTRUE(ST(1))
;
#line 20 "./xsi/noding/SegmentIntersectionDetector.xsi"
        THIS->setFindAllIntersectionTypes(findAllTypes);
#line 9091 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_getIntersectionSegments) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	xs::Array	RETVAL;
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 23 "./xsi/noding/SegmentIntersectionDetector.xsi"
    RETVAL = Helper::convert_copy(THIS->getIntersectionSegments());
#line 9110 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_getIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	SegmentIntersectionDetector*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 27 "./xsi/noding/SegmentIntersectionDetector.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    auto c = THIS->getIntersection();
    if (c) RETVAL = new Coordinate(*c);
    else XSRETURN_UNDEF;
#line 9139 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SegmentIntersectionDetector_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 33 "./xsi/noding/SegmentIntersectionDetector.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9161 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SegmentIntersectionDetector.xsi' */


/* INCLUDE:  Including 'xsi/noding/SingleInteriorIntersectionFinder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, liObj");
    {
	Sv	RETVAL;
	SV*	liObj = ST(1)
;
#line 5 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
    auto& li = xs::in(liObj);
    Sv wrapped = xs::out<>(new SingleInteriorIntersectionFinder(li));
    wrapped.payload_attach(SvRV(liObj), &payload_marker);
    RETVAL = wrapped;
#line 9189 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_hasIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SingleInteriorIntersectionFinder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
        RETVAL = THIS->hasIntersection();
#line 9224 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_getInteriorIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Coordinate *	RETVAL;
	SingleInteriorIntersectionFinder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 15 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Coordinate(THIS->getInteriorIntersection());
#line 9244 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_getIntersectionSegments) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	xs::Array	RETVAL;
	SingleInteriorIntersectionFinder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 19 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
    auto& vector = THIS->getIntersectionSegments();
    auto r = xs::Array::create(vector.size());
    for(auto& c: vector) {
        auto copy = xs::out(new Coordinate(c));
        r.push(copy);
    }
    RETVAL = r;
#line 9274 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 29 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9298 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SingleInteriorIntersectionFinder.xsi' */


/* INCLUDE:  Including 'xsi/noding/IntersectionAdder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, liObj");
    {
	Sv	RETVAL;
	SV*	liObj = ST(1)
;
#line 5 "./xsi/noding/IntersectionAdder.xsi"
    LineIntersector& li = xs::in(liObj);
    Object wrapped = xs::out<>(new IntersectionAdder(li));
    wrapped.payload_attach(SvRV(liObj), &payload_marker);
    RETVAL = wrapped.ref();
#line 9326 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_getLineIntersector) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	IntersectionAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/noding/IntersectionAdder.xsi"
    (void)THIS;
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    Object li{payload.obj};
    RETVAL = li.ref();
#line 9365 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_hasIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 19 "./xsi/noding/IntersectionAdder.xsi"
        RETVAL = THIS->hasIntersection();
#line 9400 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_hasProperIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 21 "./xsi/noding/IntersectionAdder.xsi"
        RETVAL = THIS->hasProperIntersection();
#line 9419 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_hasProperInteriorIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 23 "./xsi/noding/IntersectionAdder.xsi"
        RETVAL = THIS->hasProperInteriorIntersection();
#line 9438 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_hasInteriorIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	IntersectionAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "./xsi/noding/IntersectionAdder.xsi"
        RETVAL = THIS->hasInteriorIntersection();
#line 9457 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionAdder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 27 "./xsi/noding/IntersectionAdder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9474 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/IntersectionAdder.xsi' */


/* INCLUDE:  Including 'xsi/noding/IntersectionFinderAdder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionFinderAdder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "SV*, liObj, coords");
    {
	Sv	RETVAL;
	SV*	liObj = ST(1)
;
	Array    coords = ST(2);
    if (!coords && SvOK(ST(2))) throw "arg is not a 'Array' reference"
;
#line 5 "./xsi/noding/IntersectionFinderAdder.xsi"
    LineIntersector& li = xs::in(liObj);
    auto* payload = new IntersectionFinderAdder_payload{SvRV(liObj), {}};

    auto* v = &payload->coords;
    v->reserve(coords.size());
    for(auto it: coords) {
        Coordinate& c = xs::in(it);
        v->emplace_back(c);
    }

    Object wrapped = xs::out<>(new IntersectionFinderAdder(li, *v));
    wrapped.payload_attach(payload, &payload_marker_IntersectionFinderAdder);

    RETVAL = wrapped.ref();
#line 9515 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionFinderAdder_getInteriorIntersections) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	xs::Array	RETVAL;
	IntersectionFinderAdder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 22 "./xsi/noding/IntersectionFinderAdder.xsi"
    (void)THIS;
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker_IntersectionFinderAdder);
    auto* real_payload = static_cast(payload.ptr);
    auto* v = &real_payload->coords;

    auto result = xs::Array::create(v->size());
    for(auto& c: *v) {
        result.push(xs::out(new Coordinate(c)));
    }
    RETVAL = result;
#line 9560 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IntersectionFinderAdder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 35 "./xsi/noding/IntersectionFinderAdder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9584 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/IntersectionFinderAdder.xsi' */


/* INCLUDE:  Including 'xsi/noding/Noder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__Noder_computeNodes) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, segStrings");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	Noder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Array    segStrings = ST(1);
    if (!segStrings && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 5 "./xsi/noding/Noder.xsi"
    auto segments = Noder_payload::vector_t();
    segments.reserve(segStrings.size());

    for(auto it: segStrings) {
        SegmentString& ss = xs::in(it);
        segments.push_back(&ss);
    }

    auto payload = new Noder_payload();
    payload->array_ref = xs::Ref::create(segStrings);
    payload->segments = std::move(segments);


    Object self{ST(0)};
    self.payload_attach(payload, &payload_marker_Noder);

    THIS->computeNodes(&payload->segments);
#line 9629 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__Noder_getNodedSubstrings) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	Noder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "./xsi/noding/Noder.xsi"
    auto items = THIS->getNodedSubstrings();
    if (!items) XSRETURN_UNDEF;
    else {
        xs::Array result = xs::Array::create(items->size());
        for(auto it: *items) {
            result.push(xs::out(it));
        }
        delete items;
        RETVAL = xs::Ref::create(result);
    }
#line 9657 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/Noder.xsi' */


/* INCLUDE:  Including 'xsi/noding/IteratedNoder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__IteratedNoder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, precisionModel");
    {
	Sv	RETVAL;
	SV*	precisionModel = ST(1)
;
#line 5 "./xsi/noding/IteratedNoder.xsi"
    PrecisionModel& pm = xs::in(precisionModel);
    Object wrapped = xs::out(new IteratedNoder(&pm));
    wrapped.payload_attach(precisionModel, &payload_marker);
    RETVAL = wrapped.ref();
#line 9701 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IteratedNoder_setMaximumIterations) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, n");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	IteratedNoder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	n = (int)SvIV(ST(1))
;
#line 11 "./xsi/noding/IteratedNoder.xsi"
        THIS->setMaximumIterations(n);
#line 9739 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__IteratedNoder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 13 "./xsi/noding/IteratedNoder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9756 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/IteratedNoder.xsi' */


/* INCLUDE:  Including 'xsi/noding/ScaledNoder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__ScaledNoder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 3 || items > 5)
       croak_xs_usage(cv,  "SV*, noder, nScaleFactor, nOffsetX= 0.0, nOffsetY= 0.0");
    {
	Sv	RETVAL;
	SV*	noder = ST(1)
;
	double	nScaleFactor = (double)SvNV(ST(2))
;
	double	nOffsetX;
	double	nOffsetY;

	if (items < 4)
	    nOffsetX = 0.0;
	else {
	    nOffsetX = (double)SvNV(ST(3))
;
	}

	if (items < 5)
	    nOffsetY = 0.0;
	else {
	    nOffsetY = (double)SvNV(ST(4))
;
	}
#line 5 "./xsi/noding/ScaledNoder.xsi"
    Noder& n = xs::in(noder);
    Object wrapped = xs::out<>(new ScaledNoder(n, nScaleFactor, nOffsetX, nOffsetY));
    wrapped.payload_attach(SvRV(noder), &payload_marker);
    RETVAL = wrapped.ref();
#line 9802 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__ScaledNoder_isIntegerPrecision) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	ScaledNoder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 11 "./xsi/noding/ScaledNoder.xsi"
        RETVAL = THIS->isIntegerPrecision();
#line 9837 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__ScaledNoder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 13 "./xsi/noding/ScaledNoder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9854 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/ScaledNoder.xsi' */


/* INCLUDE:  Including 'xsi/noding/SinglePassNoder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SinglePassNoder_setSegmentIntersector) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newSegInt= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SinglePassNoder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV *	newSegInt;

	if (items < 2)
	    newSegInt = NULL;
	else {
	    newSegInt = ST(1)
;
	}
#line 5 "./xsi/noding/SinglePassNoder.xsi"
    Object self{ST(0)};

    SegmentIntersector* si = newSegInt ? xs::in(newSegInt) : NULL;
    if (si) {
        self.payload_attach(SvRV(newSegInt), &payload_marker);
    }
    else if (self.payload_exists(&payload_marker)) {
        self.payload_detach(&payload_marker);
    }

    THIS->setSegmentIntersector(si);
#line 9898 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SinglePassNoder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 19 "./xsi/noding/SinglePassNoder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9915 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SinglePassNoder.xsi' */


/* INCLUDE:  Including 'xsi/noding/SimpleNoder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SimpleNoder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "SV*, newSegInt= NULL");
    {
	Sv	RETVAL;
	SV *	newSegInt;

	if (items < 2)
	    newSegInt = NULL;
	else {
	    newSegInt = ST(1)
;
	}
#line 5 "./xsi/noding/SimpleNoder.xsi"
    SegmentIntersector* si = newSegInt ? xs::in(newSegInt) : NULL;
    Object self{xs::out(new SimpleNoder(si))};
    if (si) {
        self.payload_attach(SvRV(newSegInt), &payload_marker);
    }
    RETVAL = self.ref();
#line 9951 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SimpleNoder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 14 "./xsi/noding/SimpleNoder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 9984 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SimpleNoder.xsi' */


/* INCLUDE:  Including 'xsi/noding/SimpleSnapRounder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Noding__SimpleSnapRounder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, precisionModel");
    {
	Sv	RETVAL;
	SV*	precisionModel = ST(1)
;
#line 5 "./xsi/noding/SimpleSnapRounder.xsi"
    auto& pm = xs::in(precisionModel);
    Object wrapped = xs::out(new SimpleSnapRounder(pm));
    wrapped.payload_attach(precisionModel, &payload_marker);
    RETVAL = wrapped.ref();
#line 10012 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SimpleSnapRounder_computeVertexSnaps) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, edges");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SimpleSnapRounder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Array    edges = ST(1);
    if (!edges && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 12 "./xsi/noding/SimpleSnapRounder.xsi"
    std::vector v;
    v.reserve(edges.size());

    for(auto it: edges) {
        auto& ss = xs::in(it);
        v.push_back(&ss);
    }
    THIS->computeVertexSnaps(v);
#line 10058 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Noding__SimpleSnapRounder_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 23 "./xsi/noding/SimpleSnapRounder.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 10075 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/noding/SimpleSnapRounder.xsi' */


/* INCLUDE:  Including 'xsi/index/MonotoneChain.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 4)
       croak_xs_usage(cv,  "SV*, pts, start, end");
    {
	Sv	RETVAL;
	Array    pts = ST(1);
    if (!pts && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
	std::size_t	start = xs::in(ST(2));
;
	std::size_t	end = xs::in(ST(3));
;
#line 5 "./xsi/index/MonotoneChain.xsi"
    auto seq = Helper::convert_coords(pts);
    auto seq_ptr = seq.clone();
    auto payload = new MonotoneChain_payload();
    payload->seq.reset(seq_ptr);

    Object wrapped = xs::out<>(new MonotoneChain(*seq_ptr, start, end, NULL));
    wrapped.payload_attach(payload, &payload_marker_MonotoneChain);

    RETVAL = wrapped.ref();
#line 10113 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getChains) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "pts");
    {
	Array	RETVAL;
	Array    pts = ST(0);
    if (!pts && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 17 "./xsi/index/MonotoneChain.xsi"
    auto seq = Helper::convert_coords(pts);
    std::vector v;
    MonotoneChainBuilder::getChains(&seq, NULL, v);

    Array result = Array::create(v.size());
    for(auto mc: v) {
        result.push(xs::out(mc));
    }
    RETVAL = result;
#line 10157 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getEnvelope) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Envelope *	RETVAL;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 29 "./xsi/index/MonotoneChain.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new Envelope(THIS->getEnvelope());
#line 10184 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getStartIndex) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	size_t	RETVAL;
	dXSTARG;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 32 "./xsi/index/MonotoneChain.xsi"
        RETVAL = THIS->getStartIndex();
#line 10209 "Geos_xsgen.cc"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getEndIndex) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	size_t	RETVAL;
	dXSTARG;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 34 "./xsi/index/MonotoneChain.xsi"
        RETVAL = THIS->getEndIndex();
#line 10229 "Geos_xsgen.cc"
	XSprePUSH; PUSHu((UV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getLineSegment) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, index");
    {
	LineSegment *	RETVAL;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	std::size_t	index = xs::in(ST(1));
;
#line 37 "./xsi/index/MonotoneChain.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    LineSegment ls;
    THIS->getLineSegment(index, ls);
    RETVAL = new LineSegment(ls);
#line 10253 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getCoordinates) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Array	RETVAL;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 43 "./xsi/index/MonotoneChain.xsi"
    auto smart_ptr = THIS->getCoordinates();
    RETVAL = Helper::convert_copy(smart_ptr.get());
#line 10278 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_computeOverlaps) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, mc, mco");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	MonotoneChain &	mc = xs::in(ST(1));
;
	MonotoneChainOverlapAction &	mco = xs::in(ST(2));
;
#line 48 "./xsi/index/MonotoneChain.xsi"
    THIS->computeOverlaps(&mc, &mco);
#line 10309 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_setId) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, nId");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	int	nId = (int)SvIV(ST(1))
;
#line 51 "./xsi/index/MonotoneChain.xsi"
        THIS->setId(nId);
#line 10331 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChain_getId) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	MonotoneChain*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 53 "./xsi/index/MonotoneChain.xsi"
        RETVAL = THIS->getId();
#line 10351 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/index/MonotoneChain.xsi' */


/* INCLUDE:  Including 'xsi/index/MonotoneChainOverlapAction.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChainOverlapAction_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV*");
    {
	MonotoneChainOverlapAction *	RETVAL;
#line 4 "./xsi/index/MonotoneChainOverlapAction.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = new MonotoneChainOverlapAction();
#line 10375 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChainOverlapAction_overlap) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 3 || items > 5)
       croak_xs_usage(cv,  "THIS, arg1, arg2, arg3= NULL, arg4= NULL");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	MonotoneChainOverlapAction*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Object    arg1 = ST(1);
    if (!arg1 && SvOK(ST(1))) throw "arg is not a blessed reference"
;
	SV*	arg2 = ST(2)
;
	SV*	arg3;
	SV*	arg4;

	if (items < 4)
	    arg3 = NULL;
	else {
	    arg3 = ST(3)
;
	}

	if (items < 5)
	    arg4 = NULL;
	else {
	    arg4 = ST(4)
;
	}
#line 7 "./xsi/index/MonotoneChainOverlapAction.xsi"
    if (arg1.stash().name() == "Geo::Geos::LineSegment") {
        auto& ls1 = xs::in(arg1);
        auto& ls2 = xs::in(arg2);
        THIS->overlap(ls1, ls2);
    }
    else {
        if(!arg2) throw("undef not allowed");
        if(!arg4) throw("undef not allowed");
        auto& mc1 = xs::in(arg1);
        auto& mc2 = xs::in(arg3);
        std::size_t start1 = SvUV(arg2);
        std::size_t start2 = SvUV(arg4);
        THIS->overlap(mc1, start1, mc2, start2);
    }
#line 10434 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Index__MonotoneChainOverlapAction_tempEnv1) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "THIS, newval= NULL");
    {
	Envelope *	RETVAL;
	MonotoneChainOverlapAction*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	SV*	newval;

	if (items < 2)
	    newval = NULL;
	else {
	    newval = ST(1)
;
	}
#line 24 "./xsi/index/MonotoneChainOverlapAction.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    Envelope* val;
    switch (ix) {
        case 0:  val = &THIS->tempEnv1; break;
        default: val = &THIS->tempEnv2; break;
    }
    if (newval) {
        auto e = xs::in(newval);
        *val = *e;
    }
    RETVAL = new Envelope(*val);
#line 10472 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/index/MonotoneChainOverlapAction.xsi' */


/* INCLUDE:  Including 'xsi/index/SpatialIndex.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Index__SpatialIndex_query) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "THIS, env, arg= NULL");
    {
	Array	RETVAL;
	SpatialIndex*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope&	env = xs::in(ST(1));
;
	SV*	arg;

	if (items < 3)
	    arg = NULL;
	else {
	    arg = ST(2)
;
	}
#line 5 "./xsi/index/SpatialIndex.xsi"
    Object me {ST(0)};
    auto payload = me.payload(&payload_marker_SVs_map);
    auto real_payload = static_cast(payload.ptr);

    if (!arg) {
        std::vector v;
        THIS->query(&env, v);
        RETVAL = Helper::wrap_inc_SVs(&v, real_payload->map);
    }
    else {
        Sub visitor {arg};
        if (!visitor) throw "Unsupported argument";
        SubItemVisitor v{visitor, real_payload->map};
        THIS->query(&env, v);
        XSRETURN_UNDEF;
    }
#line 10527 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__SpatialIndex_insert) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, env, item");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SpatialIndex*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope&	env = xs::in(ST(1));
;
	SV*	item = ST(2)
;
#line 24 "./xsi/index/SpatialIndex.xsi"
    Object me{ST(0)};

    auto payload = me.payload(&payload_marker_SVs_map);
    auto real_payload = static_cast(payload.ptr);
    SV* value = Helper::store_sv(item, real_payload->map);
    THIS->insert(&env, value);
#line 10563 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Index__SpatialIndex_remove) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "THIS, env, item");
    {
	bool	RETVAL;
	SpatialIndex*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Envelope&	env = xs::in(ST(1));
;
	SV *	item = ST(2)
;
#line 33 "./xsi/index/SpatialIndex.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker_SVs_map);
    auto real_payload = static_cast(payload.ptr);

    SV* value = hv_delete_ent(real_payload->map, item, 0, 0);
    if (!value) throw "value is n/a in hash";

    RETVAL = THIS->remove(&env, value);
#line 10593 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/index/SpatialIndex.xsi' */


/* INCLUDE:  Including 'xsi/index/Quadtree.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Index__Quadtree_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "SV");
    {
	Sv	RETVAL;
#line 5 "./xsi/index/Quadtree.xsi"
    Object wrapped = xs::out(new quadtree::Quadtree());
    auto payload = new SVs_map_payload();
    wrapped.payload_attach(payload, &payload_marker_SVs_map);

    RETVAL = wrapped.ref();
#line 10620 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__Quadtree_depth) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	quadtree::Quadtree*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 12 "./xsi/index/Quadtree.xsi"
        RETVAL = THIS->depth();
#line 10656 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__Quadtree_size) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	int	RETVAL;
	dXSTARG;
	quadtree::Quadtree*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 14 "./xsi/index/Quadtree.xsi"
        RETVAL = THIS->size();
#line 10676 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__Quadtree_queryAll) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Array	RETVAL;
	quadtree::Quadtree*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 17 "./xsi/index/Quadtree.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker_SVs_map);
    auto real_payload = static_cast(payload.ptr);

    std::unique_ptr> holder {THIS->queryAll()};
    RETVAL = Helper::wrap_inc_SVs(holder.get(), real_payload->map);
#line 10700 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Index__Quadtree_toString) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1)
       croak_xs_usage(cv,  "THIS, ...");
    {
	std::string	RETVAL;
	dXSTARG;
	quadtree::Quadtree*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 25 "./xsi/index/Quadtree.xsi"
        RETVAL = THIS->toString();
#line 10727 "Geos_xsgen.cc"
	XSprePUSH; PUSHp(RETVAL.data(), RETVAL.length());
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/index/Quadtree.xsi' */


/* INCLUDE:  Including 'xsi/index/STRtree.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Index__STRtree_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 1 || items > 2)
       croak_xs_usage(cv,  "SV, nodeCapacity= 10");
    {
	Sv	RETVAL;
	std::size_t	nodeCapacity;

	if (items < 2)
	    nodeCapacity = 10;
	else {
	    nodeCapacity = xs::in(ST(1));
;
	}
#line 5 "./xsi/index/STRtree.xsi"
    Object wrapped = xs::out(new strtree::STRtree(nodeCapacity));
    auto payload = new SVs_map_payload();
    wrapped.payload_attach(payload, &payload_marker_SVs_map);

    RETVAL = wrapped.ref();
#line 10762 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/index/STRtree.xsi' */


/* INCLUDE:  Including 'xsi/precision.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Precision_signExpBits) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "num");
    {
	int64	RETVAL;
	int64	num = xs::in(ST(0));
;
#line 5 "./xsi/precision.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = CommonBits::signExpBits(num);
#line 10804 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_numCommonMostSigMantissaBits) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "num1, num2");
    {
	int	RETVAL;
	dXSTARG;
	int64	num1 = xs::in(ST(0));
;
	int64	num2 = xs::in(ST(1));
;
#line 9 "./xsi/precision.xsi"
    RETVAL = CommonBits::numCommonMostSigMantissaBits(num1, num2);
#line 10831 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_zeroLowerBits) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "bits, nBits");
    {
	int64	RETVAL;
	int64	bits = xs::in(ST(0));
;
	int	nBits = (int)SvIV(ST(1))
;
#line 13 "./xsi/precision.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    RETVAL = CommonBits::zeroLowerBits(bits, nBits);
#line 10853 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_getBit) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "bits, i");
    {
	int	RETVAL;
	dXSTARG;
	int64	bits = xs::in(ST(0));
;
	int	i = (int)SvIV(ST(1))
;
#line 17 "./xsi/precision.xsi"
    RETVAL = CommonBits::getBit (bits, i);
#line 10880 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_commonIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, g1, nReturnToOriginalPrecision= false");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	bool	nReturnToOriginalPrecision;

	if (items < 3)
	    nReturnToOriginalPrecision = false;
	else {
	    nReturnToOriginalPrecision = (bool)SvTRUE(ST(2))
;
	}
#line 21 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(CommonBitsOp(nReturnToOriginalPrecision).intersection(&g0, &g1));
#line 10909 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_commonUnion) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, g1, nReturnToOriginalPrecision= false");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	bool	nReturnToOriginalPrecision;

	if (items < 3)
	    nReturnToOriginalPrecision = false;
	else {
	    nReturnToOriginalPrecision = (bool)SvTRUE(ST(2))
;
	}
#line 25 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(CommonBitsOp(nReturnToOriginalPrecision).Union(&g0, &g1));
#line 10954 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_commonDifference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, g1, nReturnToOriginalPrecision= false");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	bool	nReturnToOriginalPrecision;

	if (items < 3)
	    nReturnToOriginalPrecision = false;
	else {
	    nReturnToOriginalPrecision = (bool)SvTRUE(ST(2))
;
	}
#line 29 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(CommonBitsOp(nReturnToOriginalPrecision).difference(&g0, &g1));
#line 10999 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_commonSymDifference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, g1, nReturnToOriginalPrecision= false");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	bool	nReturnToOriginalPrecision;

	if (items < 3)
	    nReturnToOriginalPrecision = false;
	else {
	    nReturnToOriginalPrecision = (bool)SvTRUE(ST(2))
;
	}
#line 33 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(CommonBitsOp(nReturnToOriginalPrecision).symDifference(&g0, &g1));
#line 11044 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_commonBuffer) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, distance, nReturnToOriginalPrecision= false");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	double	distance = (double)SvNV(ST(1))
;
	bool	nReturnToOriginalPrecision;

	if (items < 3)
	    nReturnToOriginalPrecision = false;
	else {
	    nReturnToOriginalPrecision = (bool)SvTRUE(ST(2))
;
	}
#line 37 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(CommonBitsOp(nReturnToOriginalPrecision).buffer(&g0, distance));
#line 11089 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_enhancedIntersection) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 41 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(EnhancedPrecisionOp().intersection(&g0, &g1));
#line 11126 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_enhancedUnion) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 45 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(EnhancedPrecisionOp().Union(&g0, &g1));
#line 11163 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_enhancedDifference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 49 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(EnhancedPrecisionOp().difference(&g0, &g1));
#line 11200 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_enhancedSymDifference) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 53 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(EnhancedPrecisionOp().symDifference(&g0, &g1));
#line 11237 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_enhancedBuffer) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g, distance");
    {
	Sv	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
	double	distance = (double)SvNV(ST(1))
;
#line 57 "./xsi/precision.xsi"
    RETVAL = Helper::uplift(EnhancedPrecisionOp().buffer(&g, distance));
#line 11274 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision_removeCommonBits) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    dXSI32;
    if (items != 2)
       croak_xs_usage(cv,  "target, sources");
    {
	Coordinate *	RETVAL;
	Geometry&	target = xs::in(ST(0));
;
	Array    sources = ST(1);
    if (!sources && SvOK(ST(1))) throw "arg is not a 'Array' reference"
;
#line 61 "./xsi/precision.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    CommonBitsRemover cbr;
    for(const auto& it: sources) {
        cbr.add(&xs::in(it));
    }

    switch (ix) {
        case 0:  cbr.removeCommonBits(&target); break;
        default: cbr.addCommonBits(&target); break;
    }
    RETVAL = new Coordinate(cbr.getCommonCoordinate());
#line 11323 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/precision.xsi' */


/* INCLUDE:  Including 'xsi/precision/GeometryPrecisionReducer.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Precision__GeometryPrecisionReducer_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, arg0");
    {
	Sv	RETVAL;
	SV*	arg0 = ST(1)
;
#line 5 "./xsi/precision/GeometryPrecisionReducer.xsi"
    GeometryPrecisionReducer* self;
    Object arg{arg0};
    if (arg.stash().name() == "Geo::Geos::PrecisionModel") {
        PrecisionModel& pm = xs::in(arg);
        self = new GeometryPrecisionReducer(pm);
    }
    else {
        GeometryFactory& gf = xs::in(arg);
        self = new GeometryPrecisionReducer(gf);
    }
    Object wrapped = xs::out(self);
    wrapped.payload_attach(SvRV(arg0), &payload_marker);
    RETVAL = wrapped.ref();
#line 11365 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__GeometryPrecisionReducer_setRemoveCollapsedComponents) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, remove");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	remove = (bool)SvTRUE(ST(1))
;
#line 20 "./xsi/precision/GeometryPrecisionReducer.xsi"
        THIS->setRemoveCollapsedComponents(remove);
#line 11403 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Precision__GeometryPrecisionReducer_setPointwise) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, pointwise");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	GeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	pointwise = (bool)SvTRUE(ST(1))
;
#line 22 "./xsi/precision/GeometryPrecisionReducer.xsi"
        THIS->setPointwise(pointwise);
#line 11425 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Precision__GeometryPrecisionReducer_reduce) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	Sv	RETVAL;
	GeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 25 "./xsi/precision/GeometryPrecisionReducer.xsi"
    auto ptr = THIS->reduce(g);
    RETVAL = Helper::uplift(ptr.release());
#line 11447 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__GeometryPrecisionReducer_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 29 "./xsi/precision/GeometryPrecisionReducer.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 11480 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/precision/GeometryPrecisionReducer.xsi' */


/* INCLUDE:  Including 'xsi/precision/SimpleGeometryPrecisionReducer.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "SV*, arg");
    {
	Sv	RETVAL;
	SV*	arg = ST(1)
;
#line 5 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
    PrecisionModel& pm = xs::in(arg);
    auto self = new SimpleGeometryPrecisionReducer(&pm);
    Object wrapped = xs::out(self);
    wrapped.payload_attach(SvRV(arg), &payload_marker);
    RETVAL = wrapped.ref();
#line 11509 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_getPrecisionModel) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	SimpleGeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 13 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
    (void)THIS;
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    Object obj { payload.obj };
    RETVAL = obj.ref();
#line 11548 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_setRemoveCollapsedComponents) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, nRemoveCollapsed");
    PERL_UNUSED_VAR(ax); /* -Wall */
    SP -= items;
    {
	SimpleGeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	bool	nRemoveCollapsed = (bool)SvTRUE(ST(1))
;
#line 20 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
        THIS->setRemoveCollapsedComponents(nRemoveCollapsed);
#line 11586 "Geos_xsgen.cc"
	PUTBACK;
	return;
    }
}); }



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_getRemoveCollapsed) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	bool	RETVAL;
	SimpleGeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 22 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
        RETVAL = THIS->getRemoveCollapsed();
#line 11605 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_reduce) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "THIS, g");
    {
	Sv	RETVAL;
	SimpleGeometryPrecisionReducer*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
	Geometry&	g = xs::in(ST(1));
;
#line 25 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
    RETVAL = Helper::uplift(THIS->reduce(&g));
#line 11626 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_CLONE_SKIP) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    PERL_UNUSED_VAR(cv); /* -W */
    {
	int	RETVAL;
	dXSTARG;
#line 28 "./xsi/precision/SimpleGeometryPrecisionReducer.xsi"
 PERL_UNUSED_VAR(items); RETVAL = 1;
#line 11659 "Geos_xsgen.cc"
	XSprePUSH; PUSHi((IV)RETVAL);
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/precision/SimpleGeometryPrecisionReducer.xsi' */


/* INCLUDE:  Including 'xsi/operation.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Operation_buffer) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 4)
       croak_xs_usage(cv,  "g, distance, quadrantSegments= NULL, endCapStyle= NULL");
    {
	Sv	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
	double	distance = (double)SvNV(ST(1))
;
	SV*	quadrantSegments;
	SV*	endCapStyle;

	if (items < 3)
	    quadrantSegments = NULL;
	else {
	    quadrantSegments = ST(2)
;
	}

	if (items < 4)
	    endCapStyle = NULL;
	else {
	    endCapStyle = ST(3)
;
	}
#line 5 "./xsi/operation.xsi"
    int vQuadrantSegments = quadrantSegments ? SvIV(quadrantSegments) : (int)BufferParameters::DEFAULT_QUADRANT_SEGMENTS;
    int vEndCapStyle = endCapStyle? SvIV(endCapStyle) : (int)BufferParameters::CAP_ROUND;
    Geometry* r = BufferOp::bufferOp(&g, distance, vQuadrantSegments, vEndCapStyle);
    RETVAL = Helper::uplift(r);
#line 11705 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_distance) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	double	RETVAL;
	dXSTARG;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 12 "./xsi/operation.xsi"
    RETVAL = DistanceOp::distance(&g0, &g1);
#line 11743 "Geos_xsgen.cc"
	XSprePUSH; PUSHn((double)RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_nearestPoints) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Array	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 16 "./xsi/operation.xsi"
    Array r;
    auto seq = DistanceOp::nearestPoints(&g0, &g1);
    if(seq) {
        auto seq_ptr = std::unique_ptr(seq);
        r = Helper::convert_copy(seq);
    }
    RETVAL = r;
#line 11770 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_closestPoints) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 2)
       croak_xs_usage(cv,  "g0, g1");
    {
	Array	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
#line 26 "./xsi/operation.xsi"
    Array r;
    auto seq = DistanceOp::closestPoints(&g0, &g1);
    if(seq) {
        auto seq_ptr = std::unique_ptr(seq);
        r = Helper::convert_copy(seq);
    }
    RETVAL = r;
#line 11804 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_overlayOp) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 3)
       croak_xs_usage(cv,  "g0, g1, opCode");
    {
	Sv	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	int	opCode = (int)SvIV(ST(2))
;
#line 36 "./xsi/operation.xsi"
    if (opCode > 4) throw "wrong opCode";
    OverlayOp::OpCode code = static_cast(opCode);
    Geometry* g = OverlayOp::overlayOp(&g0, &g1, code);
    RETVAL = Helper::uplift(g);
#line 11837 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_isValid) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "obj");
    {
	bool	RETVAL;
	Object    obj = ST(0);
    if (!obj && SvOK(ST(0))) throw "arg is not a blessed reference"
;
#line 43 "./xsi/operation.xsi"
    if (obj.stash().name() == "Geo::Geos::Coordinate") {
        auto& c = xs::in(obj);
        RETVAL = IsValidOp::isValid(c);
    }
    else {
        auto& g = xs::in(obj);
        RETVAL = IsValidOp::isValid(g);
    }
#line 11880 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_relate) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 2 || items > 3)
       croak_xs_usage(cv,  "g0, g1, boundaryNodeRule= NULL");
    {
	IntersectionMatrix *	RETVAL;
	Geometry&	g0 = xs::in(ST(0));
;
	Geometry&	g1 = xs::in(ST(1));
;
	SV*	boundaryNodeRule;

	if (items < 3)
	    boundaryNodeRule = NULL;
	else {
	    boundaryNodeRule = ST(2)
;
	}
#line 54 "./xsi/operation.xsi"
    xs::Sv PROTO; PERL_UNUSED_VAR(PROTO);
    if (!boundaryNodeRule) RETVAL = RelateOp::relate(&g0, &g1);
    else {
        const BoundaryNodeRule* rule;
        auto rule_id = SvIV(boundaryNodeRule);
        switch(rule_id) {
            case 0: rule = &BoundaryNodeRule::getBoundaryRuleMod2(); break;
            case 1: rule = &BoundaryNodeRule::getBoundaryEndPoint(); break;
            case 2: rule = &BoundaryNodeRule::getBoundaryMultivalentEndPoint(); break;
            case 3: rule = &BoundaryNodeRule::getBoundaryMonovalentEndPoint(); break;
            case 4: rule = &BoundaryNodeRule::getBoundaryOGCSFS(); break;
            default: throw("Wrong boundaryNodeRule");
        }
        RETVAL = RelateOp::relate(&g0, &g1, *rule);
    }
#line 11923 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
	    RETVALSV = xs::out(RETVAL, PROTO).detach();
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_mergeLines) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "in");
    {
	Array	RETVAL;
	Array    in = ST(0);
    if (!in && SvOK(ST(0))) throw "arg is not a 'Array' reference"
;
#line 71 "./xsi/operation.xsi"
    LineMerger lm;

    for(auto it: in) {
        lm.add(&xs::in(it));
    }

    auto v = lm.getMergedLineStrings();
    Array out = Array::create(v->size());
    for(LineString* it: *v) {
        auto wrapped = xs::out(it);
        out.push(wrapped);
    }
    RETVAL  = out;
    delete v;
#line 11961 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    RETVALSV = newRV_noinc(RETVAL.detach());
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_isSequenced) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	bool	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 88 "./xsi/operation.xsi"
    RETVAL = LineSequencer::isSequenced(&g);
#line 11987 "Geos_xsgen.cc"
	ST(0) = boolSV(RETVAL);
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Operation_sequence) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "g");
    {
	Sv	RETVAL;
	Geometry&	g = xs::in(ST(0));
;
#line 92 "./xsi/operation.xsi"
    RETVAL = Helper::uplift(LineSequencer::sequence(g));
#line 12006 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/operation.xsi' */


/* INCLUDE:  Including 'xsi/triangulate/DelaunayTriangulationBuilder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 3 || items > 4)
       croak_xs_usage(cv,  "SV*, geometry_factory, sites, tolerance= NULL");
    {
	Sv	RETVAL;
	SV*	geometry_factory = ST(1)
;
	Sv    sites = ST(2)
;
	SV*	tolerance;

	if (items < 4)
	    tolerance = NULL;
	else {
	    tolerance = ST(3)
;
	}
#line 5 "./xsi/triangulate/DelaunayTriangulationBuilder.xsi"
    auto builder = std::unique_ptr(new DelaunayTriangulationBuilder());
    GeometryFactory* factory = xs::in(geometry_factory);

    if (sites.is_array_ref()) {
        auto seq = std::unique_ptr(Helper::convert_copy(*factory, sites, 2));
        builder->setSites(*seq);
    }
    else {
        auto& g = xs::in(sites);
        builder->setSites(g);
    }

    if (tolerance) {
        builder->setTolerance(Simple(tolerance));
    }

    Object wrapped = xs::out(builder.release());
    wrapped.payload_attach(SvRV(geometry_factory), &payload_marker);
    RETVAL = wrapped.ref();
#line 12075 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_getEdges) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	DelaunayTriangulationBuilder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 27 "./xsi/triangulate/DelaunayTriangulationBuilder.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    GeometryFactory* factory = xs::in(payload.obj);
    auto edges = THIS->getEdges(*factory);
    RETVAL = Helper::uplift(edges.release());
#line 12114 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_getTriangles) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	DelaunayTriangulationBuilder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 35 "./xsi/triangulate/DelaunayTriangulationBuilder.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    GeometryFactory* factory = xs::in(payload.obj);
    auto edges = THIS->getTriangles(*factory);
    RETVAL = Helper::uplift(edges.release());
#line 12153 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/triangulate/DelaunayTriangulationBuilder.xsi' */


/* INCLUDE:  Including 'xsi/triangulate/VoronoiDiagramBuilder.xsi' from 'Geos.xs' */



XS_EUPXS(XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_new) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items < 3 || items > 5)
       croak_xs_usage(cv,  "SV*, geometry_factory, sites, tolerance= NULL, env= NULL");
    {
	Sv	RETVAL;
	SV*	geometry_factory = ST(1)
;
	Sv    sites = ST(2)
;
	SV*	tolerance;
	SV*	env;

	if (items < 4)
	    tolerance = NULL;
	else {
	    tolerance = ST(3)
;
	}

	if (items < 5)
	    env = NULL;
	else {
	    env = ST(4)
;
	}
#line 5 "./xsi/triangulate/VoronoiDiagramBuilder.xsi"
    auto builder = std::unique_ptr(new VoronoiDiagramBuilder());
    GeometryFactory* factory = xs::in(geometry_factory);

    if (sites.is_array_ref()) {
        auto seq = std::unique_ptr(Helper::convert_copy(*factory, sites, 2));
        builder->setSites(*seq);
    }
    else {
        auto& g = xs::in(sites);
        builder->setSites(g);
    }

    if (tolerance) {
        builder->setTolerance(Simple(tolerance));
    }

    if (env) {
        auto envelope = xs::in(env);
        builder->setClipEnvelope(envelope);
    }

    Object wrapped = xs::out(builder.release());
    wrapped.payload_attach(SvRV(geometry_factory), &payload_marker);
    RETVAL = wrapped.ref();
#line 12235 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_getDiagramEdges) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	VoronoiDiagramBuilder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 32 "./xsi/triangulate/VoronoiDiagramBuilder.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    GeometryFactory* factory = xs::in(payload.obj);
    auto edges = THIS->getDiagramEdges(*factory);
    RETVAL = Helper::uplift(edges.release());
#line 12274 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }



XS_EUPXS(XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_getDiagram) { xs::throw_guard(cv, [=]()
{
    dVAR; dXSARGS;
    if (items != 1)
       croak_xs_usage(cv,  "THIS");
    {
	Sv	RETVAL;
	VoronoiDiagramBuilder*	THIS = xs::in(ST(0)); if (!SvOK(ST(0))) throw "undef not allowed as THIS";
;
#line 40 "./xsi/triangulate/VoronoiDiagramBuilder.xsi"
    Object me{ST(0)};
    auto payload = me.payload(&payload_marker);
    GeometryFactory* factory = xs::in(payload.obj);
    auto edges = THIS->getDiagram(*factory);
    RETVAL = Helper::uplift(edges.release());
#line 12313 "Geos_xsgen.cc"
	{
	    SV * RETVALSV;
    RETVALSV = NULL;
    if (!RETVAL) XSRETURN_UNDEF;
    if (RETVAL.is_scalar()) RETVALSV = RETVAL.detach();
    else switch (RETVAL.type()) {
	    case SVt_PVAV: XSRETURN(xs::Array(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVHV: XSRETURN(xs::Hash(RETVAL.get()).push_on_stack(MARK));
	    case SVt_PVCV:
	    case SVt_PVIO:
		RETVALSV = newRV_noinc(RETVAL.detach());
		break;
	    default: throw "unknown type of Sv to return";
    }
	    RETVALSV = sv_2mortal(RETVALSV);
	    ST(0) = RETVALSV;
	}
    }
    XSRETURN(1);
}); }


/* INCLUDE: Returning to 'Geos.xs' from 'xsi/triangulate/VoronoiDiagramBuilder.xsi' */

#ifdef __cplusplus
extern "C"
#endif

XS_EXTERNAL(boot_Geo__Geos) { xs::throw_guard(cv, [=]() mutable
{
#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("Geo::Geos::Coordinate::getNull", XS_Geo__Geos__Coordinate_getNull);
        newXS_deffile("Geo::Geos::Coordinate::new", XS_Geo__Geos__Coordinate_new);
        cv = newXS_deffile("Geo::Geos::Coordinate::x", XS_Geo__Geos__Coordinate_x);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::Coordinate::y", XS_Geo__Geos__Coordinate_x);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Geo::Geos::Coordinate::z", XS_Geo__Geos__Coordinate_x);
        XSANY.any_i32 = 2;
        newXS_deffile("Geo::Geos::Coordinate::setNull", XS_Geo__Geos__Coordinate_setNull);
        newXS_deffile("Geo::Geos::Coordinate::isNull", XS_Geo__Geos__Coordinate_isNull);
        newXS_deffile("Geo::Geos::Coordinate::equals", XS_Geo__Geos__Coordinate_equals);
        newXS_deffile("Geo::Geos::Coordinate::equals2D", XS_Geo__Geos__Coordinate_equals2D);
        newXS_deffile("Geo::Geos::Coordinate::equals3D", XS_Geo__Geos__Coordinate_equals3D);
        newXS_deffile("Geo::Geos::Coordinate::compareTo", XS_Geo__Geos__Coordinate_compareTo);
        newXS_deffile("Geo::Geos::Coordinate::eq", XS_Geo__Geos__Coordinate_eq);
        newXS_deffile("Geo::Geos::Coordinate::toString", XS_Geo__Geos__Coordinate_toString);
        newXS_deffile("Geo::Geos::Coordinate::distance", XS_Geo__Geos__Coordinate_distance);
        newXS_deffile("Geo::Geos::Coordinate::hashCode", XS_Geo__Geos__Coordinate_hashCode);
        newXS_deffile("Geo::Geos::Coordinate::CLONE_SKIP", XS_Geo__Geos__Coordinate_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Dimension::toDimensionSymbol", XS_Geo__Geos__Dimension_toDimensionSymbol);
        newXS_deffile("Geo::Geos::Dimension::toDimensionValue", XS_Geo__Geos__Dimension_toDimensionValue);
        newXS_deffile("Geo::Geos::Envelope::new", XS_Geo__Geos__Envelope_new);
        newXS_deffile("Geo::Geos::Envelope::init", XS_Geo__Geos__Envelope_init);
        newXS_deffile("Geo::Geos::Envelope::setToNull", XS_Geo__Geos__Envelope_setToNull);
        newXS_deffile("Geo::Geos::Envelope::getArea", XS_Geo__Geos__Envelope_getArea);
        newXS_deffile("Geo::Geos::Envelope::getMaxY", XS_Geo__Geos__Envelope_getMaxY);
        newXS_deffile("Geo::Geos::Envelope::getMaxX", XS_Geo__Geos__Envelope_getMaxX);
        newXS_deffile("Geo::Geos::Envelope::getMinY", XS_Geo__Geos__Envelope_getMinY);
        newXS_deffile("Geo::Geos::Envelope::getMinX", XS_Geo__Geos__Envelope_getMinX);
        newXS_deffile("Geo::Geos::Envelope::getWidth", XS_Geo__Geos__Envelope_getWidth);
        newXS_deffile("Geo::Geos::Envelope::getHeight", XS_Geo__Geos__Envelope_getHeight);
        newXS_deffile("Geo::Geos::Envelope::isNull", XS_Geo__Geos__Envelope_isNull);
        newXS_deffile("Geo::Geos::Envelope::hashCode", XS_Geo__Geos__Envelope_hashCode);
        newXS_deffile("Geo::Geos::Envelope::toString", XS_Geo__Geos__Envelope_toString);
        newXS_deffile("Geo::Geos::Envelope::eq", XS_Geo__Geos__Envelope_eq);
        newXS_deffile("Geo::Geos::Envelope::centre", XS_Geo__Geos__Envelope_centre);
        newXS_deffile("Geo::Geos::Envelope::contains", XS_Geo__Geos__Envelope_contains);
        newXS_deffile("Geo::Geos::Envelope::covers", XS_Geo__Geos__Envelope_covers);
        newXS_deffile("Geo::Geos::Envelope::intersects", XS_Geo__Geos__Envelope_intersects);
        newXS_deffile("Geo::Geos::Envelope::expandToInclude", XS_Geo__Geos__Envelope_expandToInclude);
        newXS_deffile("Geo::Geos::Envelope::distance", XS_Geo__Geos__Envelope_distance);
        newXS_deffile("Geo::Geos::Envelope::translate", XS_Geo__Geos__Envelope_translate);
        newXS_deffile("Geo::Geos::Envelope::expandBy", XS_Geo__Geos__Envelope_expandBy);
        newXS_deffile("Geo::Geos::Envelope::intersection", XS_Geo__Geos__Envelope_intersection);
        newXS_deffile("Geo::Geos::Envelope::CLONE_SKIP", XS_Geo__Geos__Envelope_CLONE_SKIP);
        newXS_deffile("Geo::Geos::PrecisionModel::new", XS_Geo__Geos__PrecisionModel_new);
        newXS_deffile("Geo::Geos::PrecisionModel::getScale", XS_Geo__Geos__PrecisionModel_getScale);
        newXS_deffile("Geo::Geos::PrecisionModel::getOffsetX", XS_Geo__Geos__PrecisionModel_getOffsetX);
        newXS_deffile("Geo::Geos::PrecisionModel::getOffsetY", XS_Geo__Geos__PrecisionModel_getOffsetY);
        newXS_deffile("Geo::Geos::PrecisionModel::isFloating", XS_Geo__Geos__PrecisionModel_isFloating);
        newXS_deffile("Geo::Geos::PrecisionModel::getMaximumSignificantDigits", XS_Geo__Geos__PrecisionModel_getMaximumSignificantDigits);
        newXS_deffile("Geo::Geos::PrecisionModel::getType", XS_Geo__Geos__PrecisionModel_getType);
        newXS_deffile("Geo::Geos::PrecisionModel::makePrecise", XS_Geo__Geos__PrecisionModel_makePrecise);
        newXS_deffile("Geo::Geos::PrecisionModel::toString", XS_Geo__Geos__PrecisionModel_toString);
        newXS_deffile("Geo::Geos::PrecisionModel::compareTo", XS_Geo__Geos__PrecisionModel_compareTo);
        newXS_deffile("Geo::Geos::IntersectionMatrix::new", XS_Geo__Geos__IntersectionMatrix_new);
        newXS_deffile("Geo::Geos::IntersectionMatrix::matches", XS_Geo__Geos__IntersectionMatrix_matches);
        newXS_deffile("Geo::Geos::IntersectionMatrix::add", XS_Geo__Geos__IntersectionMatrix_add);
        newXS_deffile("Geo::Geos::IntersectionMatrix::set", XS_Geo__Geos__IntersectionMatrix_set);
        newXS_deffile("Geo::Geos::IntersectionMatrix::setAtLeast", XS_Geo__Geos__IntersectionMatrix_setAtLeast);
        newXS_deffile("Geo::Geos::IntersectionMatrix::setAll", XS_Geo__Geos__IntersectionMatrix_setAll);
        newXS_deffile("Geo::Geos::IntersectionMatrix::setAtLeastIfValid", XS_Geo__Geos__IntersectionMatrix_setAtLeastIfValid);
        newXS_deffile("Geo::Geos::IntersectionMatrix::get", XS_Geo__Geos__IntersectionMatrix_get);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isDisjoint", XS_Geo__Geos__IntersectionMatrix_isDisjoint);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isIntersects", XS_Geo__Geos__IntersectionMatrix_isIntersects);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isWithin", XS_Geo__Geos__IntersectionMatrix_isWithin);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isContains", XS_Geo__Geos__IntersectionMatrix_isContains);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isCovers", XS_Geo__Geos__IntersectionMatrix_isCovers);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isCoveredBy", XS_Geo__Geos__IntersectionMatrix_isCoveredBy);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isTouches", XS_Geo__Geos__IntersectionMatrix_isTouches);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isCrosses", XS_Geo__Geos__IntersectionMatrix_isCrosses);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isEquals", XS_Geo__Geos__IntersectionMatrix_isEquals);
        newXS_deffile("Geo::Geos::IntersectionMatrix::isOverlaps", XS_Geo__Geos__IntersectionMatrix_isOverlaps);
        newXS_deffile("Geo::Geos::IntersectionMatrix::transpose", XS_Geo__Geos__IntersectionMatrix_transpose);
        newXS_deffile("Geo::Geos::IntersectionMatrix::toString", XS_Geo__Geos__IntersectionMatrix_toString);
        newXS_deffile("Geo::Geos::IntersectionMatrix::CLONE_SKIP", XS_Geo__Geos__IntersectionMatrix_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Triangle::new", XS_Geo__Geos__Triangle_new);
        cv = newXS_deffile("Geo::Geos::Triangle::p0", XS_Geo__Geos__Triangle_p0);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::Triangle::p1", XS_Geo__Geos__Triangle_p0);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Geo::Geos::Triangle::p2", XS_Geo__Geos__Triangle_p0);
        XSANY.any_i32 = 2;
        newXS_deffile("Geo::Geos::Triangle::inCentre", XS_Geo__Geos__Triangle_inCentre);
        newXS_deffile("Geo::Geos::Triangle::circumcentre", XS_Geo__Geos__Triangle_circumcentre);
        cv = newXS_deffile("Geo::Geos::Triangle::isInCircleNonRobust", XS_Geo__Geos__Triangle_isInCircleNonRobust);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::Triangle::isInCircleNormalized", XS_Geo__Geos__Triangle_isInCircleNonRobust);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Geo::Geos::Triangle::isInCircleRobust", XS_Geo__Geos__Triangle_isInCircleNonRobust);
        XSANY.any_i32 = 2;
        newXS_deffile("Geo::Geos::Triangle::CLONE_SKIP", XS_Geo__Geos__Triangle_CLONE_SKIP);
        newXS_deffile("Geo::Geos::LineSegment::new", XS_Geo__Geos__LineSegment_new);
        newXS_deffile("Geo::Geos::LineSegment::getLength", XS_Geo__Geos__LineSegment_getLength);
        newXS_deffile("Geo::Geos::LineSegment::isHorizontal", XS_Geo__Geos__LineSegment_isHorizontal);
        newXS_deffile("Geo::Geos::LineSegment::isVertical", XS_Geo__Geos__LineSegment_isVertical);
        newXS_deffile("Geo::Geos::LineSegment::setCoordinates", XS_Geo__Geos__LineSegment_setCoordinates);
        newXS_deffile("Geo::Geos::LineSegment::orientationIndex", XS_Geo__Geos__LineSegment_orientationIndex);
        newXS_deffile("Geo::Geos::LineSegment::reverse", XS_Geo__Geos__LineSegment_reverse);
        newXS_deffile("Geo::Geos::LineSegment::normalize", XS_Geo__Geos__LineSegment_normalize);
        newXS_deffile("Geo::Geos::LineSegment::angle", XS_Geo__Geos__LineSegment_angle);
        newXS_deffile("Geo::Geos::LineSegment::midPoint", XS_Geo__Geos__LineSegment_midPoint);
        newXS_deffile("Geo::Geos::LineSegment::distance", XS_Geo__Geos__LineSegment_distance);
        newXS_deffile("Geo::Geos::LineSegment::distancePerpendicular", XS_Geo__Geos__LineSegment_distancePerpendicular);
        newXS_deffile("Geo::Geos::LineSegment::pointAlong", XS_Geo__Geos__LineSegment_pointAlong);
        newXS_deffile("Geo::Geos::LineSegment::pointAlongOffset", XS_Geo__Geos__LineSegment_pointAlongOffset);
        newXS_deffile("Geo::Geos::LineSegment::projectionFactor", XS_Geo__Geos__LineSegment_projectionFactor);
        newXS_deffile("Geo::Geos::LineSegment::segmentFraction", XS_Geo__Geos__LineSegment_segmentFraction);
        newXS_deffile("Geo::Geos::LineSegment::project", XS_Geo__Geos__LineSegment_project);
        newXS_deffile("Geo::Geos::LineSegment::closestPoint", XS_Geo__Geos__LineSegment_closestPoint);
        newXS_deffile("Geo::Geos::LineSegment::compareTo", XS_Geo__Geos__LineSegment_compareTo);
        newXS_deffile("Geo::Geos::LineSegment::equalsTopo", XS_Geo__Geos__LineSegment_equalsTopo);
        newXS_deffile("Geo::Geos::LineSegment::closestPoints", XS_Geo__Geos__LineSegment_closestPoints);
        newXS_deffile("Geo::Geos::LineSegment::intersection", XS_Geo__Geos__LineSegment_intersection);
        newXS_deffile("Geo::Geos::LineSegment::lineIntersection", XS_Geo__Geos__LineSegment_lineIntersection);
        newXS_deffile("Geo::Geos::LineSegment::toGeometry", XS_Geo__Geos__LineSegment_toGeometry);
        newXS_deffile("Geo::Geos::LineSegment::toString", XS_Geo__Geos__LineSegment_toString);
        cv = newXS_deffile("Geo::Geos::LineSegment::p0", XS_Geo__Geos__LineSegment_p0);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::LineSegment::p1", XS_Geo__Geos__LineSegment_p0);
        XSANY.any_i32 = 1;
        newXS_deffile("Geo::Geos::LineSegment::CLONE_SKIP", XS_Geo__Geos__LineSegment_CLONE_SKIP);
        newXS_deffile("Geo::Geos::GeometryFactory::create", XS_Geo__Geos__GeometryFactory_create);
        newXS_deffile("Geo::Geos::GeometryFactory::getPrecisionModel", XS_Geo__Geos__GeometryFactory_getPrecisionModel);
        newXS_deffile("Geo::Geos::GeometryFactory::getSRID", XS_Geo__Geos__GeometryFactory_getSRID);
        newXS_deffile("Geo::Geos::GeometryFactory::createGeometryCollection", XS_Geo__Geos__GeometryFactory_createGeometryCollection);
        newXS_deffile("Geo::Geos::GeometryFactory::createPoint", XS_Geo__Geos__GeometryFactory_createPoint);
        newXS_deffile("Geo::Geos::GeometryFactory::createMultiPoint", XS_Geo__Geos__GeometryFactory_createMultiPoint);
        newXS_deffile("Geo::Geos::GeometryFactory::createLineString", XS_Geo__Geos__GeometryFactory_createLineString);
        newXS_deffile("Geo::Geos::GeometryFactory::createMultiLineString", XS_Geo__Geos__GeometryFactory_createMultiLineString);
        newXS_deffile("Geo::Geos::GeometryFactory::createLinearRing", XS_Geo__Geos__GeometryFactory_createLinearRing);
        newXS_deffile("Geo::Geos::GeometryFactory::createPolygon", XS_Geo__Geos__GeometryFactory_createPolygon);
        newXS_deffile("Geo::Geos::GeometryFactory::createMultiPolygon", XS_Geo__Geos__GeometryFactory_createMultiPolygon);
        newXS_deffile("Geo::Geos::GeometryFactory::toGeometry", XS_Geo__Geos__GeometryFactory_toGeometry);
        newXS_deffile("Geo::Geos::GeometryFactory::createEmptyGeometry", XS_Geo__Geos__GeometryFactory_createEmptyGeometry);
        newXS_deffile("Geo::Geos::GeometryFactory::CLONE_SKIP", XS_Geo__Geos__GeometryFactory_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Geometry::getSRID", XS_Geo__Geos__Geometry_getSRID);
        newXS_deffile("Geo::Geos::Geometry::setSRID", XS_Geo__Geos__Geometry_setSRID);
        newXS_deffile("Geo::Geos::Geometry::isEmpty", XS_Geo__Geos__Geometry_isEmpty);
        newXS_deffile("Geo::Geos::Geometry::isSimple", XS_Geo__Geos__Geometry_isSimple);
        newXS_deffile("Geo::Geos::Geometry::isRectangle", XS_Geo__Geos__Geometry_isRectangle);
        newXS_deffile("Geo::Geos::Geometry::isValid", XS_Geo__Geos__Geometry_isValid);
        newXS_deffile("Geo::Geos::Geometry::getNumPoints", XS_Geo__Geos__Geometry_getNumPoints);
        newXS_deffile("Geo::Geos::Geometry::getDimension", XS_Geo__Geos__Geometry_getDimension);
        newXS_deffile("Geo::Geos::Geometry::getCoordinateDimension", XS_Geo__Geos__Geometry_getCoordinateDimension);
        newXS_deffile("Geo::Geos::Geometry::getBoundaryDimension", XS_Geo__Geos__Geometry_getBoundaryDimension);
        newXS_deffile("Geo::Geos::Geometry::getNumGeometries", XS_Geo__Geos__Geometry_getNumGeometries);
        newXS_deffile("Geo::Geos::Geometry::reverse", XS_Geo__Geos__Geometry_reverse);
        newXS_deffile("Geo::Geos::Geometry::getGeometryN", XS_Geo__Geos__Geometry_getGeometryN);
        newXS_deffile("Geo::Geos::Geometry::getCoordinate", XS_Geo__Geos__Geometry_getCoordinate);
        newXS_deffile("Geo::Geos::Geometry::getGeometryType", XS_Geo__Geos__Geometry_getGeometryType);
        newXS_deffile("Geo::Geos::Geometry::getGeometryTypeId", XS_Geo__Geos__Geometry_getGeometryTypeId);
        newXS_deffile("Geo::Geos::Geometry::toString", XS_Geo__Geos__Geometry_toString);
        newXS_deffile("Geo::Geos::Geometry::toText", XS_Geo__Geos__Geometry_toText);
        newXS_deffile("Geo::Geos::Geometry::equalsExact", XS_Geo__Geos__Geometry_equalsExact);
        newXS_deffile("Geo::Geos::Geometry::equals", XS_Geo__Geos__Geometry_equals);
        newXS_deffile("Geo::Geos::Geometry::compareTo", XS_Geo__Geos__Geometry_compareTo);
        newXS_deffile("Geo::Geos::Geometry::getBoundary", XS_Geo__Geos__Geometry_getBoundary);
        newXS_deffile("Geo::Geos::Geometry::getArea", XS_Geo__Geos__Geometry_getArea);
        newXS_deffile("Geo::Geos::Geometry::getLength", XS_Geo__Geos__Geometry_getLength);
        newXS_deffile("Geo::Geos::Geometry::distance", XS_Geo__Geos__Geometry_distance);
        newXS_deffile("Geo::Geos::Geometry::isWithinDistance", XS_Geo__Geos__Geometry_isWithinDistance);
        newXS_deffile("Geo::Geos::Geometry::getCentroid", XS_Geo__Geos__Geometry_getCentroid);
        newXS_deffile("Geo::Geos::Geometry::getInteriorPoint", XS_Geo__Geos__Geometry_getInteriorPoint);
        newXS_deffile("Geo::Geos::Geometry::symDifference", XS_Geo__Geos__Geometry_symDifference);
        newXS_deffile("Geo::Geos::Geometry::difference", XS_Geo__Geos__Geometry_difference);
        newXS_deffile("Geo::Geos::Geometry::Union", XS_Geo__Geos__Geometry_Union);
        newXS_deffile("Geo::Geos::Geometry::intersection", XS_Geo__Geos__Geometry_intersection);
        newXS_deffile("Geo::Geos::Geometry::convexHull", XS_Geo__Geos__Geometry_convexHull);
        newXS_deffile("Geo::Geos::Geometry::buffer", XS_Geo__Geos__Geometry_buffer);
        newXS_deffile("Geo::Geos::Geometry::coveredBy", XS_Geo__Geos__Geometry_coveredBy);
        newXS_deffile("Geo::Geos::Geometry::covers", XS_Geo__Geos__Geometry_covers);
        newXS_deffile("Geo::Geos::Geometry::overlaps", XS_Geo__Geos__Geometry_overlaps);
        newXS_deffile("Geo::Geos::Geometry::contains", XS_Geo__Geos__Geometry_contains);
        newXS_deffile("Geo::Geos::Geometry::within", XS_Geo__Geos__Geometry_within);
        newXS_deffile("Geo::Geos::Geometry::crosses", XS_Geo__Geos__Geometry_crosses);
        newXS_deffile("Geo::Geos::Geometry::intersects", XS_Geo__Geos__Geometry_intersects);
        newXS_deffile("Geo::Geos::Geometry::touches", XS_Geo__Geos__Geometry_touches);
        newXS_deffile("Geo::Geos::Geometry::disjoint", XS_Geo__Geos__Geometry_disjoint);
        newXS_deffile("Geo::Geos::Geometry::getEnvelope", XS_Geo__Geos__Geometry_getEnvelope);
        newXS_deffile("Geo::Geos::Geometry::clone", XS_Geo__Geos__Geometry_clone);
        newXS_deffile("Geo::Geos::Geometry::getPrecisionModel", XS_Geo__Geos__Geometry_getPrecisionModel);
        newXS_deffile("Geo::Geos::Geometry::getCoordinates", XS_Geo__Geos__Geometry_getCoordinates);
        newXS_deffile("Geo::Geos::Geometry::relate", XS_Geo__Geos__Geometry_relate);
        newXS_deffile("Geo::Geos::Geometry::normalize", XS_Geo__Geos__Geometry_normalize);
        newXS_deffile("Geo::Geos::Geometry::CLONE_SKIP", XS_Geo__Geos__Geometry_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Geometry::HOOK_CLONE", XS_Geo__Geos__Geometry_HOOK_CLONE);
        newXS_deffile("Geo::Geos::GeometryCollection::CLONE_SKIP", XS_Geo__Geos__GeometryCollection_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Point::getX", XS_Geo__Geos__Point_getX);
        newXS_deffile("Geo::Geos::Point::getY", XS_Geo__Geos__Point_getY);
        newXS_deffile("Geo::Geos::Point::reverse", XS_Geo__Geos__Point_reverse);
        newXS_deffile("Geo::Geos::MultiPoint::CLONE_SKIP", XS_Geo__Geos__MultiPoint_CLONE_SKIP);
        newXS_deffile("Geo::Geos::LineString::getPointN", XS_Geo__Geos__LineString_getPointN);
        newXS_deffile("Geo::Geos::LineString::getStartPoint", XS_Geo__Geos__LineString_getStartPoint);
        newXS_deffile("Geo::Geos::LineString::getEndPoint", XS_Geo__Geos__LineString_getEndPoint);
        newXS_deffile("Geo::Geos::LineString::isClosed", XS_Geo__Geos__LineString_isClosed);
        newXS_deffile("Geo::Geos::LineString::isRing", XS_Geo__Geos__LineString_isRing);
        newXS_deffile("Geo::Geos::MultiLineString::isClosed", XS_Geo__Geos__MultiLineString_isClosed);
        newXS_deffile("Geo::Geos::LinearRing::reverse", XS_Geo__Geos__LinearRing_reverse);
        newXS_deffile("Geo::Geos::Polygon::getExteriorRing", XS_Geo__Geos__Polygon_getExteriorRing);
        newXS_deffile("Geo::Geos::Polygon::getInteriorRingN", XS_Geo__Geos__Polygon_getInteriorRingN);
        newXS_deffile("Geo::Geos::Polygon::getNumInteriorRing", XS_Geo__Geos__Polygon_getNumInteriorRing);
        newXS_deffile("Geo::Geos::Polygon::tesselate", XS_Geo__Geos__Polygon_tesselate);
        newXS_deffile("Geo::Geos::Polygon::CLONE_SKIP", XS_Geo__Geos__Polygon_CLONE_SKIP);
        newXS_deffile("Geo::Geos::MultiPolygon::CLONE_SKIP", XS_Geo__Geos__MultiPolygon_CLONE_SKIP);
        newXS_deffile("Geo::Geos::WKBConstants::CLONE_SKIP", XS_Geo__Geos__WKBConstants_CLONE_SKIP);
        newXS_deffile("Geo::Geos::WKBWriter::new", XS_Geo__Geos__WKBWriter_new);
        newXS_deffile("Geo::Geos::WKBWriter::getOutputDimension", XS_Geo__Geos__WKBWriter_getOutputDimension);
        newXS_deffile("Geo::Geos::WKBWriter::setOutputDimension", XS_Geo__Geos__WKBWriter_setOutputDimension);
        newXS_deffile("Geo::Geos::WKBWriter::getByteOrder", XS_Geo__Geos__WKBWriter_getByteOrder);
        newXS_deffile("Geo::Geos::WKBWriter::setByteOrder", XS_Geo__Geos__WKBWriter_setByteOrder);
        newXS_deffile("Geo::Geos::WKBWriter::getIncludeSRID", XS_Geo__Geos__WKBWriter_getIncludeSRID);
        newXS_deffile("Geo::Geos::WKBWriter::setIncludeSRID", XS_Geo__Geos__WKBWriter_setIncludeSRID);
        newXS_deffile("Geo::Geos::WKBWriter::write", XS_Geo__Geos__WKBWriter_write);
        newXS_deffile("Geo::Geos::WKBWriter::writeHEX", XS_Geo__Geos__WKBWriter_writeHEX);
        newXS_deffile("Geo::Geos::WKBWriter::CLONE_SKIP", XS_Geo__Geos__WKBWriter_CLONE_SKIP);
        newXS_deffile("Geo::Geos::WKBReader::read", XS_Geo__Geos__WKBReader_read);
        newXS_deffile("Geo::Geos::WKBReader::readHEX", XS_Geo__Geos__WKBReader_readHEX);
        newXS_deffile("Geo::Geos::WKTWriter::new", XS_Geo__Geos__WKTWriter_new);
        newXS_deffile("Geo::Geos::WKTWriter::setTrim", XS_Geo__Geos__WKTWriter_setTrim);
        newXS_deffile("Geo::Geos::WKTWriter::setRoundingPrecision", XS_Geo__Geos__WKTWriter_setRoundingPrecision);
        newXS_deffile("Geo::Geos::WKTWriter::write", XS_Geo__Geos__WKTWriter_write);
        newXS_deffile("Geo::Geos::WKTWriter::CLONE_SKIP", XS_Geo__Geos__WKTWriter_CLONE_SKIP);
        newXS_deffile("Geo::Geos::WKTReader::read", XS_Geo__Geos__WKTReader_read);
        newXS_deffile("Geo::Geos::Prep::Geometry::getGeometry", XS_Geo__Geos__Prep__Geometry_getGeometry);
        newXS_deffile("Geo::Geos::Prep::Geometry::contains", XS_Geo__Geos__Prep__Geometry_contains);
        newXS_deffile("Geo::Geos::Prep::Geometry::containsProperly", XS_Geo__Geos__Prep__Geometry_containsProperly);
        newXS_deffile("Geo::Geos::Prep::Geometry::coveredBy", XS_Geo__Geos__Prep__Geometry_coveredBy);
        newXS_deffile("Geo::Geos::Prep::Geometry::covers", XS_Geo__Geos__Prep__Geometry_covers);
        newXS_deffile("Geo::Geos::Prep::Geometry::crosses", XS_Geo__Geos__Prep__Geometry_crosses);
        newXS_deffile("Geo::Geos::Prep::Geometry::disjoint", XS_Geo__Geos__Prep__Geometry_disjoint);
        newXS_deffile("Geo::Geos::Prep::Geometry::intersects", XS_Geo__Geos__Prep__Geometry_intersects);
        newXS_deffile("Geo::Geos::Prep::Geometry::overlaps", XS_Geo__Geos__Prep__Geometry_overlaps);
        newXS_deffile("Geo::Geos::Prep::Geometry::touches", XS_Geo__Geos__Prep__Geometry_touches);
        newXS_deffile("Geo::Geos::Prep::Geometry::within", XS_Geo__Geos__Prep__Geometry_within);
        newXS_deffile("Geo::Geos::Prep::Geometry::toString", XS_Geo__Geos__Prep__Geometry_toString);
        newXS_deffile("Geo::Geos::Prep::Geometry::CLONE_SKIP", XS_Geo__Geos__Prep__Geometry_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Prep::GeometryFactory::prepare", XS_Geo__Geos__Prep__GeometryFactory_prepare);
        newXS_deffile("Geo::Geos::Algorithm::toDegrees", XS_Geo__Geos__Algorithm_toDegrees);
        newXS_deffile("Geo::Geos::Algorithm::toRadians", XS_Geo__Geos__Algorithm_toRadians);
        newXS_deffile("Geo::Geos::Algorithm::angle", XS_Geo__Geos__Algorithm_angle);
        newXS_deffile("Geo::Geos::Algorithm::isAcute", XS_Geo__Geos__Algorithm_isAcute);
        newXS_deffile("Geo::Geos::Algorithm::isObtuse", XS_Geo__Geos__Algorithm_isObtuse);
        newXS_deffile("Geo::Geos::Algorithm::angleBetween", XS_Geo__Geos__Algorithm_angleBetween);
        newXS_deffile("Geo::Geos::Algorithm::angleBetweenOriented", XS_Geo__Geos__Algorithm_angleBetweenOriented);
        newXS_deffile("Geo::Geos::Algorithm::interiorAngle", XS_Geo__Geos__Algorithm_interiorAngle);
        newXS_deffile("Geo::Geos::Algorithm::getTurn", XS_Geo__Geos__Algorithm_getTurn);
        newXS_deffile("Geo::Geos::Algorithm::normalize", XS_Geo__Geos__Algorithm_normalize);
        newXS_deffile("Geo::Geos::Algorithm::normalizePositive", XS_Geo__Geos__Algorithm_normalizePositive);
        newXS_deffile("Geo::Geos::Algorithm::diff", XS_Geo__Geos__Algorithm_diff);
        newXS_deffile("Geo::Geos::Algorithm::centroid", XS_Geo__Geos__Algorithm_centroid);
        newXS_deffile("Geo::Geos::Algorithm::centroidArea", XS_Geo__Geos__Algorithm_centroidArea);
        newXS_deffile("Geo::Geos::Algorithm::centroidLine", XS_Geo__Geos__Algorithm_centroidLine);
        newXS_deffile("Geo::Geos::Algorithm::centroidPoint", XS_Geo__Geos__Algorithm_centroidPoint);
        newXS_deffile("Geo::Geos::Algorithm::isPointInRing", XS_Geo__Geos__Algorithm_isPointInRing);
        newXS_deffile("Geo::Geos::Algorithm::locatePointInRing", XS_Geo__Geos__Algorithm_locatePointInRing);
        newXS_deffile("Geo::Geos::Algorithm::isOnLine", XS_Geo__Geos__Algorithm_isOnLine);
        newXS_deffile("Geo::Geos::Algorithm::isCCW", XS_Geo__Geos__Algorithm_isCCW);
        newXS_deffile("Geo::Geos::Algorithm::computeOrientation", XS_Geo__Geos__Algorithm_computeOrientation);
        newXS_deffile("Geo::Geos::Algorithm::distancePointLine", XS_Geo__Geos__Algorithm_distancePointLine);
        newXS_deffile("Geo::Geos::Algorithm::distancePointLinePerpendicular", XS_Geo__Geos__Algorithm_distancePointLinePerpendicular);
        newXS_deffile("Geo::Geos::Algorithm::distanceLineLine", XS_Geo__Geos__Algorithm_distanceLineLine);
        newXS_deffile("Geo::Geos::Algorithm::signedArea", XS_Geo__Geos__Algorithm_signedArea);
        newXS_deffile("Geo::Geos::Algorithm::length", XS_Geo__Geos__Algorithm_length);
        newXS_deffile("Geo::Geos::Algorithm::orientationIndex", XS_Geo__Geos__Algorithm_orientationIndex);
        newXS_deffile("Geo::Geos::Algorithm::getIntersection", XS_Geo__Geos__Algorithm_getIntersection);
        newXS_deffile("Geo::Geos::Algorithm::convexHull", XS_Geo__Geos__Algorithm_convexHull);
        newXS_deffile("Geo::Geos::Algorithm::interiorPointArea", XS_Geo__Geos__Algorithm_interiorPointArea);
        newXS_deffile("Geo::Geos::Algorithm::interiorPointLine", XS_Geo__Geos__Algorithm_interiorPointLine);
        newXS_deffile("Geo::Geos::Algorithm::interiorPointPoint", XS_Geo__Geos__Algorithm_interiorPointPoint);
        newXS_deffile("Geo::Geos::Algorithm::locate", XS_Geo__Geos__Algorithm_locate);
        newXS_deffile("Geo::Geos::Algorithm::intersects", XS_Geo__Geos__Algorithm_intersects);
        newXS_deffile("Geo::Geos::Algorithm::signOfDet2x2", XS_Geo__Geos__Algorithm_signOfDet2x2);
        newXS_deffile("Geo::Geos::Algorithm::locateIndexedPointInArea", XS_Geo__Geos__Algorithm_locateIndexedPointInArea);
        newXS_deffile("Geo::Geos::Algorithm::locateSimplePointInArea", XS_Geo__Geos__Algorithm_locateSimplePointInArea);
        newXS_deffile("Geo::Geos::Algorithm::HCoordinate::new", XS_Geo__Geos__Algorithm__HCoordinate_new);
        cv = newXS_deffile("Geo::Geos::Algorithm::HCoordinate::w", XS_Geo__Geos__Algorithm__HCoordinate_x);
        XSANY.any_i32 = 2;
        cv = newXS_deffile("Geo::Geos::Algorithm::HCoordinate::x", XS_Geo__Geos__Algorithm__HCoordinate_x);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::Algorithm::HCoordinate::y", XS_Geo__Geos__Algorithm__HCoordinate_x);
        XSANY.any_i32 = 1;
        newXS_deffile("Geo::Geos::Algorithm::HCoordinate::getCoordinate", XS_Geo__Geos__Algorithm__HCoordinate_getCoordinate);
        newXS_deffile("Geo::Geos::Algorithm::HCoordinate::intersection", XS_Geo__Geos__Algorithm__HCoordinate_intersection);
        newXS_deffile("Geo::Geos::Algorithm::HCoordinate::toString", XS_Geo__Geos__Algorithm__HCoordinate_toString);
        newXS_deffile("Geo::Geos::Algorithm::HCoordinate::CLONE_SKIP", XS_Geo__Geos__Algorithm__HCoordinate_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::new", XS_Geo__Geos__Algorithm__MinimumDiameter_new);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getMinimumRectangle", XS_Geo__Geos__Algorithm__MinimumDiameter_getMinimumRectangle);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getMinimumDiameter", XS_Geo__Geos__Algorithm__MinimumDiameter_getMinimumDiameter);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getLength", XS_Geo__Geos__Algorithm__MinimumDiameter_getLength);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getWidthCoordinate", XS_Geo__Geos__Algorithm__MinimumDiameter_getWidthCoordinate);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getSupportingSegment", XS_Geo__Geos__Algorithm__MinimumDiameter_getSupportingSegment);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::getDiameter", XS_Geo__Geos__Algorithm__MinimumDiameter_getDiameter);
        newXS_deffile("Geo::Geos::Algorithm::MinimumDiameter::CLONE_SKIP", XS_Geo__Geos__Algorithm__MinimumDiameter_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::new", XS_Geo__Geos__Algorithm__LineIntersector_new);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::interpolateZ", XS_Geo__Geos__Algorithm__LineIntersector_interpolateZ);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::computeEdgeDistance", XS_Geo__Geos__Algorithm__LineIntersector_computeEdgeDistance);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::isSameSignAndNonZero", XS_Geo__Geos__Algorithm__LineIntersector_isSameSignAndNonZero);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::hasIntersection", XS_Geo__Geos__Algorithm__LineIntersector_hasIntersection);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::isInteriorIntersection", XS_Geo__Geos__Algorithm__LineIntersector_isInteriorIntersection);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::setPrecisionModel", XS_Geo__Geos__Algorithm__LineIntersector_setPrecisionModel);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::computeIntersection", XS_Geo__Geos__Algorithm__LineIntersector_computeIntersection);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::toString", XS_Geo__Geos__Algorithm__LineIntersector_toString);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::getIntersectionNum", XS_Geo__Geos__Algorithm__LineIntersector_getIntersectionNum);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::isProper", XS_Geo__Geos__Algorithm__LineIntersector_isProper);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::getIndexAlongSegment", XS_Geo__Geos__Algorithm__LineIntersector_getIndexAlongSegment);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::getEdgeDistance", XS_Geo__Geos__Algorithm__LineIntersector_getEdgeDistance);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::getIntersectionAlongSegment", XS_Geo__Geos__Algorithm__LineIntersector_getIntersectionAlongSegment);
        newXS_deffile("Geo::Geos::Algorithm::LineIntersector::CLONE_SKIP", XS_Geo__Geos__Algorithm__LineIntersector_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::compareOrientedCoordinateArray", XS_Geo__Geos__Noding_compareOrientedCoordinateArray);
        newXS_deffile("Geo::Geos::Noding::octant", XS_Geo__Geos__Noding_octant);
        newXS_deffile("Geo::Geos::Noding::checkNodingValid", XS_Geo__Geos__Noding_checkNodingValid);
        newXS_deffile("Geo::Geos::Noding::fastCheckNodingValid", XS_Geo__Geos__Noding_fastCheckNodingValid);
        newXS_deffile("Geo::Geos::Noding::compareSegmentPoints", XS_Geo__Geos__Noding_compareSegmentPoints);
        newXS_deffile("Geo::Geos::Noding::extractSegmentStrings", XS_Geo__Geos__Noding_extractSegmentStrings);
        newXS_deffile("Geo::Geos::Noding::intersects", XS_Geo__Geos__Noding_intersects);
        newXS_deffile("Geo::Geos::Noding::SegmentString::size", XS_Geo__Geos__Noding__SegmentString_size);
        newXS_deffile("Geo::Geos::Noding::SegmentString::getCoordinate", XS_Geo__Geos__Noding__SegmentString_getCoordinate);
        newXS_deffile("Geo::Geos::Noding::SegmentString::getCoordinates", XS_Geo__Geos__Noding__SegmentString_getCoordinates);
        newXS_deffile("Geo::Geos::Noding::SegmentString::isClosed", XS_Geo__Geos__Noding__SegmentString_isClosed);
        newXS_deffile("Geo::Geos::Noding::SegmentString::toString", XS_Geo__Geos__Noding__SegmentString_toString);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::isInterior", XS_Geo__Geos__Noding__SegmentNode_isInterior);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::isEndPoint", XS_Geo__Geos__Noding__SegmentNode_isEndPoint);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::compareTo", XS_Geo__Geos__Noding__SegmentNode_compareTo);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::toString", XS_Geo__Geos__Noding__SegmentNode_toString);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::coord", XS_Geo__Geos__Noding__SegmentNode_coord);
        newXS_deffile("Geo::Geos::Noding::SegmentNode::segmentIndex", XS_Geo__Geos__Noding__SegmentNode_segmentIndex);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::new", XS_Geo__Geos__Noding__NodedSegmentString_new);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::addIntersectionNode", XS_Geo__Geos__Noding__NodedSegmentString_addIntersectionNode);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::getSegmentOctant", XS_Geo__Geos__Noding__NodedSegmentString_getSegmentOctant);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::addIntersections", XS_Geo__Geos__Noding__NodedSegmentString_addIntersections);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::addIntersection", XS_Geo__Geos__Noding__NodedSegmentString_addIntersection);
        newXS_deffile("Geo::Geos::Noding::NodedSegmentString::CLONE_SKIP", XS_Geo__Geos__Noding__NodedSegmentString_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::BasicSegmentString::new", XS_Geo__Geos__Noding__BasicSegmentString_new);
        newXS_deffile("Geo::Geos::Noding::BasicSegmentString::DESTROY", XS_Geo__Geos__Noding__BasicSegmentString_DESTROY);
        newXS_deffile("Geo::Geos::Noding::BasicSegmentString::getSegmentOctant", XS_Geo__Geos__Noding__BasicSegmentString_getSegmentOctant);
        newXS_deffile("Geo::Geos::Noding::BasicSegmentString::CLONE_SKIP", XS_Geo__Geos__Noding__BasicSegmentString_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersector::processIntersections", XS_Geo__Geos__Noding__SegmentIntersector_processIntersections);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersector::isDone", XS_Geo__Geos__Noding__SegmentIntersector_isDone);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::new", XS_Geo__Geos__Noding__SegmentIntersectionDetector_new);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::hasIntersection", XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasIntersection);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::hasProperIntersection", XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasProperIntersection);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::hasNonProperIntersection", XS_Geo__Geos__Noding__SegmentIntersectionDetector_hasNonProperIntersection);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::setFindProper", XS_Geo__Geos__Noding__SegmentIntersectionDetector_setFindProper);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::setFindAllIntersectionTypes", XS_Geo__Geos__Noding__SegmentIntersectionDetector_setFindAllIntersectionTypes);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::getIntersectionSegments", XS_Geo__Geos__Noding__SegmentIntersectionDetector_getIntersectionSegments);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::getIntersection", XS_Geo__Geos__Noding__SegmentIntersectionDetector_getIntersection);
        newXS_deffile("Geo::Geos::Noding::SegmentIntersectionDetector::CLONE_SKIP", XS_Geo__Geos__Noding__SegmentIntersectionDetector_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::SingleInteriorIntersectionFinder::new", XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_new);
        newXS_deffile("Geo::Geos::Noding::SingleInteriorIntersectionFinder::hasIntersection", XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_hasIntersection);
        newXS_deffile("Geo::Geos::Noding::SingleInteriorIntersectionFinder::getInteriorIntersection", XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_getInteriorIntersection);
        newXS_deffile("Geo::Geos::Noding::SingleInteriorIntersectionFinder::getIntersectionSegments", XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_getIntersectionSegments);
        newXS_deffile("Geo::Geos::Noding::SingleInteriorIntersectionFinder::CLONE_SKIP", XS_Geo__Geos__Noding__SingleInteriorIntersectionFinder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::new", XS_Geo__Geos__Noding__IntersectionAdder_new);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::getLineIntersector", XS_Geo__Geos__Noding__IntersectionAdder_getLineIntersector);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::hasIntersection", XS_Geo__Geos__Noding__IntersectionAdder_hasIntersection);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::hasProperIntersection", XS_Geo__Geos__Noding__IntersectionAdder_hasProperIntersection);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::hasProperInteriorIntersection", XS_Geo__Geos__Noding__IntersectionAdder_hasProperInteriorIntersection);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::hasInteriorIntersection", XS_Geo__Geos__Noding__IntersectionAdder_hasInteriorIntersection);
        newXS_deffile("Geo::Geos::Noding::IntersectionAdder::CLONE_SKIP", XS_Geo__Geos__Noding__IntersectionAdder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::IntersectionFinderAdder::new", XS_Geo__Geos__Noding__IntersectionFinderAdder_new);
        newXS_deffile("Geo::Geos::Noding::IntersectionFinderAdder::getInteriorIntersections", XS_Geo__Geos__Noding__IntersectionFinderAdder_getInteriorIntersections);
        newXS_deffile("Geo::Geos::Noding::IntersectionFinderAdder::CLONE_SKIP", XS_Geo__Geos__Noding__IntersectionFinderAdder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::Noder::computeNodes", XS_Geo__Geos__Noding__Noder_computeNodes);
        newXS_deffile("Geo::Geos::Noding::Noder::getNodedSubstrings", XS_Geo__Geos__Noding__Noder_getNodedSubstrings);
        newXS_deffile("Geo::Geos::Noding::IteratedNoder::new", XS_Geo__Geos__Noding__IteratedNoder_new);
        newXS_deffile("Geo::Geos::Noding::IteratedNoder::setMaximumIterations", XS_Geo__Geos__Noding__IteratedNoder_setMaximumIterations);
        newXS_deffile("Geo::Geos::Noding::IteratedNoder::CLONE_SKIP", XS_Geo__Geos__Noding__IteratedNoder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::ScaledNoder::new", XS_Geo__Geos__Noding__ScaledNoder_new);
        newXS_deffile("Geo::Geos::Noding::ScaledNoder::isIntegerPrecision", XS_Geo__Geos__Noding__ScaledNoder_isIntegerPrecision);
        newXS_deffile("Geo::Geos::Noding::ScaledNoder::CLONE_SKIP", XS_Geo__Geos__Noding__ScaledNoder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::SinglePassNoder::setSegmentIntersector", XS_Geo__Geos__Noding__SinglePassNoder_setSegmentIntersector);
        newXS_deffile("Geo::Geos::Noding::SinglePassNoder::CLONE_SKIP", XS_Geo__Geos__Noding__SinglePassNoder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::SimpleNoder::new", XS_Geo__Geos__Noding__SimpleNoder_new);
        newXS_deffile("Geo::Geos::Noding::SimpleNoder::CLONE_SKIP", XS_Geo__Geos__Noding__SimpleNoder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Noding::SimpleSnapRounder::new", XS_Geo__Geos__Noding__SimpleSnapRounder_new);
        newXS_deffile("Geo::Geos::Noding::SimpleSnapRounder::computeVertexSnaps", XS_Geo__Geos__Noding__SimpleSnapRounder_computeVertexSnaps);
        newXS_deffile("Geo::Geos::Noding::SimpleSnapRounder::CLONE_SKIP", XS_Geo__Geos__Noding__SimpleSnapRounder_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::new", XS_Geo__Geos__Index__MonotoneChain_new);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getChains", XS_Geo__Geos__Index__MonotoneChain_getChains);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getEnvelope", XS_Geo__Geos__Index__MonotoneChain_getEnvelope);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getStartIndex", XS_Geo__Geos__Index__MonotoneChain_getStartIndex);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getEndIndex", XS_Geo__Geos__Index__MonotoneChain_getEndIndex);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getLineSegment", XS_Geo__Geos__Index__MonotoneChain_getLineSegment);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getCoordinates", XS_Geo__Geos__Index__MonotoneChain_getCoordinates);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::computeOverlaps", XS_Geo__Geos__Index__MonotoneChain_computeOverlaps);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::setId", XS_Geo__Geos__Index__MonotoneChain_setId);
        newXS_deffile("Geo::Geos::Index::MonotoneChain::getId", XS_Geo__Geos__Index__MonotoneChain_getId);
        newXS_deffile("Geo::Geos::Index::MonotoneChainOverlapAction::new", XS_Geo__Geos__Index__MonotoneChainOverlapAction_new);
        newXS_deffile("Geo::Geos::Index::MonotoneChainOverlapAction::overlap", XS_Geo__Geos__Index__MonotoneChainOverlapAction_overlap);
        cv = newXS_deffile("Geo::Geos::Index::MonotoneChainOverlapAction::tempEnv1", XS_Geo__Geos__Index__MonotoneChainOverlapAction_tempEnv1);
        XSANY.any_i32 = 0;
        cv = newXS_deffile("Geo::Geos::Index::MonotoneChainOverlapAction::tempEnv2", XS_Geo__Geos__Index__MonotoneChainOverlapAction_tempEnv1);
        XSANY.any_i32 = 1;
        newXS_deffile("Geo::Geos::Index::SpatialIndex::query", XS_Geo__Geos__Index__SpatialIndex_query);
        newXS_deffile("Geo::Geos::Index::SpatialIndex::insert", XS_Geo__Geos__Index__SpatialIndex_insert);
        newXS_deffile("Geo::Geos::Index::SpatialIndex::remove", XS_Geo__Geos__Index__SpatialIndex_remove);
        newXS_deffile("Geo::Geos::Index::Quadtree::new", XS_Geo__Geos__Index__Quadtree_new);
        newXS_deffile("Geo::Geos::Index::Quadtree::depth", XS_Geo__Geos__Index__Quadtree_depth);
        newXS_deffile("Geo::Geos::Index::Quadtree::size", XS_Geo__Geos__Index__Quadtree_size);
        newXS_deffile("Geo::Geos::Index::Quadtree::queryAll", XS_Geo__Geos__Index__Quadtree_queryAll);
        newXS_deffile("Geo::Geos::Index::Quadtree::toString", XS_Geo__Geos__Index__Quadtree_toString);
        newXS_deffile("Geo::Geos::Index::STRtree::new", XS_Geo__Geos__Index__STRtree_new);
        newXS_deffile("Geo::Geos::Precision::signExpBits", XS_Geo__Geos__Precision_signExpBits);
        newXS_deffile("Geo::Geos::Precision::numCommonMostSigMantissaBits", XS_Geo__Geos__Precision_numCommonMostSigMantissaBits);
        newXS_deffile("Geo::Geos::Precision::zeroLowerBits", XS_Geo__Geos__Precision_zeroLowerBits);
        newXS_deffile("Geo::Geos::Precision::getBit", XS_Geo__Geos__Precision_getBit);
        newXS_deffile("Geo::Geos::Precision::commonIntersection", XS_Geo__Geos__Precision_commonIntersection);
        newXS_deffile("Geo::Geos::Precision::commonUnion", XS_Geo__Geos__Precision_commonUnion);
        newXS_deffile("Geo::Geos::Precision::commonDifference", XS_Geo__Geos__Precision_commonDifference);
        newXS_deffile("Geo::Geos::Precision::commonSymDifference", XS_Geo__Geos__Precision_commonSymDifference);
        newXS_deffile("Geo::Geos::Precision::commonBuffer", XS_Geo__Geos__Precision_commonBuffer);
        newXS_deffile("Geo::Geos::Precision::enhancedIntersection", XS_Geo__Geos__Precision_enhancedIntersection);
        newXS_deffile("Geo::Geos::Precision::enhancedUnion", XS_Geo__Geos__Precision_enhancedUnion);
        newXS_deffile("Geo::Geos::Precision::enhancedDifference", XS_Geo__Geos__Precision_enhancedDifference);
        newXS_deffile("Geo::Geos::Precision::enhancedSymDifference", XS_Geo__Geos__Precision_enhancedSymDifference);
        newXS_deffile("Geo::Geos::Precision::enhancedBuffer", XS_Geo__Geos__Precision_enhancedBuffer);
        cv = newXS_deffile("Geo::Geos::Precision::addCommonBits", XS_Geo__Geos__Precision_removeCommonBits);
        XSANY.any_i32 = 1;
        cv = newXS_deffile("Geo::Geos::Precision::removeCommonBits", XS_Geo__Geos__Precision_removeCommonBits);
        XSANY.any_i32 = 0;
        newXS_deffile("Geo::Geos::Precision::GeometryPrecisionReducer::new", XS_Geo__Geos__Precision__GeometryPrecisionReducer_new);
        newXS_deffile("Geo::Geos::Precision::GeometryPrecisionReducer::setRemoveCollapsedComponents", XS_Geo__Geos__Precision__GeometryPrecisionReducer_setRemoveCollapsedComponents);
        newXS_deffile("Geo::Geos::Precision::GeometryPrecisionReducer::setPointwise", XS_Geo__Geos__Precision__GeometryPrecisionReducer_setPointwise);
        newXS_deffile("Geo::Geos::Precision::GeometryPrecisionReducer::reduce", XS_Geo__Geos__Precision__GeometryPrecisionReducer_reduce);
        newXS_deffile("Geo::Geos::Precision::GeometryPrecisionReducer::CLONE_SKIP", XS_Geo__Geos__Precision__GeometryPrecisionReducer_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::new", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_new);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::getPrecisionModel", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_getPrecisionModel);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::setRemoveCollapsedComponents", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_setRemoveCollapsedComponents);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::getRemoveCollapsed", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_getRemoveCollapsed);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::reduce", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_reduce);
        newXS_deffile("Geo::Geos::Precision::SimpleGeometryPrecisionReducer::CLONE_SKIP", XS_Geo__Geos__Precision__SimpleGeometryPrecisionReducer_CLONE_SKIP);
        newXS_deffile("Geo::Geos::Operation::buffer", XS_Geo__Geos__Operation_buffer);
        newXS_deffile("Geo::Geos::Operation::distance", XS_Geo__Geos__Operation_distance);
        newXS_deffile("Geo::Geos::Operation::nearestPoints", XS_Geo__Geos__Operation_nearestPoints);
        newXS_deffile("Geo::Geos::Operation::closestPoints", XS_Geo__Geos__Operation_closestPoints);
        newXS_deffile("Geo::Geos::Operation::overlayOp", XS_Geo__Geos__Operation_overlayOp);
        newXS_deffile("Geo::Geos::Operation::isValid", XS_Geo__Geos__Operation_isValid);
        newXS_deffile("Geo::Geos::Operation::relate", XS_Geo__Geos__Operation_relate);
        newXS_deffile("Geo::Geos::Operation::mergeLines", XS_Geo__Geos__Operation_mergeLines);
        newXS_deffile("Geo::Geos::Operation::isSequenced", XS_Geo__Geos__Operation_isSequenced);
        newXS_deffile("Geo::Geos::Operation::sequence", XS_Geo__Geos__Operation_sequence);
        newXS_deffile("Geo::Geos::Triangulate::DelaunayTriangulationBuilder::new", XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_new);
        newXS_deffile("Geo::Geos::Triangulate::DelaunayTriangulationBuilder::getEdges", XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_getEdges);
        newXS_deffile("Geo::Geos::Triangulate::DelaunayTriangulationBuilder::getTriangles", XS_Geo__Geos__Triangulate__DelaunayTriangulationBuilder_getTriangles);
        newXS_deffile("Geo::Geos::Triangulate::VoronoiDiagramBuilder::new", XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_new);
        newXS_deffile("Geo::Geos::Triangulate::VoronoiDiagramBuilder::getDiagramEdges", XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_getDiagramEdges);
        newXS_deffile("Geo::Geos::Triangulate::VoronoiDiagramBuilder::getDiagram", XS_Geo__Geos__Triangulate__VoronoiDiagramBuilder_getDiagram);

    /* Initialisation Section */

#line 14 "./xsi/Dimension.xsi"
    {
    auto this_stash = Stash("Geo::Geos::Dimension");
    xs::exp::create_constants(this_stash, {
        {"TYPE_DONTCARE", Dimension::DimensionType::DONTCARE},
        {"TYPE_True", Dimension::DimensionType::True},
        {"TYPE_False", Dimension::DimensionType::False},
        {"TYPE_P", Dimension::DimensionType::P},
        {"TYPE_L", Dimension::DimensionType::L},
        {"TYPE_A", Dimension::DimensionType::A}
    });
    xs::exp::autoexport(this_stash);
    }

#line 42 "./xsi/PrecisionModel.xsi"
    {
    auto this_stash = Stash("Geo::Geos::PrecisionModel");
    xs::exp::create_constants(this_stash, {
        {"TYPE_FIXED",              PrecisionModel::Type::FIXED},
        {"TYPE_FLOATING",           PrecisionModel::Type::FLOATING},
        {"TYPE_FLOATING_SINGLE",    PrecisionModel::Type::FLOATING_SINGLE}
    });
    xs::exp::autoexport(this_stash);
    }

#line 42 "./xsi/Triangle.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Triangle"));
    }

#line 123 "./xsi/GeometryFactory.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::GeometryFactory"));
    }

#line 139 "./xsi/Geometry.xsi"
    {
    auto this_stash = Stash("Geo::Geos::Geometry");
    xs::exp::create_constants(this_stash, {
        {"TYPE_GEOS_POINT",              GeometryTypeId::GEOS_POINT},
        {"TYPE_GEOS_LINESTRING",         GeometryTypeId::GEOS_LINESTRING},
        {"TYPE_GEOS_LINEARRING",         GeometryTypeId::GEOS_LINEARRING},
        {"TYPE_GEOS_POLYGON",            GeometryTypeId::GEOS_POLYGON},
        {"TYPE_GEOS_MULTIPOINT",         GeometryTypeId::GEOS_MULTIPOINT},
        {"TYPE_GEOS_MULTILINESTRING",    GeometryTypeId::GEOS_MULTILINESTRING},
        {"TYPE_GEOS_MULTIPOLYGON",       GeometryTypeId::GEOS_MULTIPOLYGON},
        {"TYPE_GEOS_GEOMETRYCOLLECTION", GeometryTypeId::GEOS_GEOMETRYCOLLECTION},

        {"TYPE_CAP_ROUND",  geos::operation::buffer::BufferParameters::CAP_ROUND},
        {"TYPE_CAP_FLAT",   geos::operation::buffer::BufferParameters::CAP_FLAT},
        {"TYPE_CAP_SQUARE", geos::operation::buffer::BufferParameters::CAP_SQUARE}
    });
    xs::exp::autoexport(this_stash);

    Stash("Geo::Geos::GeometryCollection").inherit("Geo::Geos::Geometry");

    Stash("Geo::Geos::Puntal", GV_ADD).mark_as_loaded("Geo::Geos");
    Stash("Geo::Geos::Puntal").inherit("Geo::Geos::Geometry");

    Stash("Geo::Geos::Lineal", GV_ADD).mark_as_loaded("Geo::Geos");
    Stash("Geo::Geos::Lineal").inherit("Geo::Geos::Geometry");

    Stash("Geo::Geos::Polygonal", GV_ADD).mark_as_loaded("Geo::Geos");
    Stash("Geo::Geos::Polygonal").inherit("Geo::Geos::Geometry");
    }

#line 6 "./xsi/GeometryCollection.xsi"
    {
    Stash("Geo::Geos::GeometryCollection").inherit("Geo::Geos::Geometry");
    }

#line 10 "./xsi/Point.xsi"
    {
    Stash("Geo::Geos::Point").inherit("Geo::Geos::Puntal");
    }

#line 6 "./xsi/MultiPoint.xsi"
    {
    Stash("Geo::Geos::MultiPoint").inherit("Geo::Geos::Puntal");
    Stash("Geo::Geos::MultiPoint").inherit("Geo::Geos::GeometryCollection");
    }

#line 14 "./xsi/LineString.xsi"
    {
    Stash("Geo::Geos::LineString").inherit("Geo::Geos::Lineal");
    }

#line 6 "./xsi/MultiLineString.xsi"
    {
    Stash("Geo::Geos::MultiLineString").inherit("Geo::Geos::Lineal");
    Stash("Geo::Geos::MultiLineString").inherit("Geo::Geos::GeometryCollection");
    }

#line 6 "./xsi/LinearRing.xsi"
    {
    Stash("Geo::Geos::LinearRing").inherit("Geo::Geos::LineString");
    }

#line 23 "./xsi/Polygon.xsi"
    {
    Stash("Geo::Geos::Polygon").inherit("Geo::Geos::Polygonal");
    }

#line 6 "./xsi/MultiPolygon.xsi"
    {
    Stash("Geo::Geos::MultiPolygon").inherit("Geo::Geos::Polygonal");
    Stash("Geo::Geos::MultiPolygon").inherit("Geo::Geos::GeometryCollection");
    }

#line 6 "./xsi/WKBConstants.xsi"
    {
    auto this_stash = Stash("Geo::Geos::WKBConstants");
    xs::exp::create_constants(this_stash, {
        //{"TYPE_BYTEORDER_BE", WKBConstants::wkbXDR},
        //{"TYPE_BYTEORDER_LE", WKBConstants::wkbNDR},
        {"TYPE_BYTEORDER_BE", 0},
        {"TYPE_BYTEORDER_LE", 1},

        {"TYPE_WKB_POINT",              WKBConstants::wkbPoint},
        {"TYPE_WKB_LINESTRING",         WKBConstants::wkbLineString},
        {"TYPE_WKB_POLYGON",            WKBConstants::wkbPolygon},
        {"TYPE_WKB_MULTIPOINT",         WKBConstants::wkbMultiPoint},
        {"TYPE_WKB_MULTILINESTRING",    WKBConstants::wkbMultiLineString},
        {"TYPE_WKB_MULTIPOLYGON",       WKBConstants::wkbMultiPolygon},
        {"TYPE_WKB_GEOMETRYCOLLECTION", WKBConstants::wkbGeometryCollection}
    });
    xs::exp::autoexport(this_stash);
    }

#line 202 "./xsi/algorithm.xsi"
    {
    auto this_stash = Stash("Geo::Geos::Algorithm");
    xs::exp::create_constants(this_stash, {
        {"TYPE_TURN_CLOCKWISE",        CGAlgorithms::CLOCKWISE},
        {"TYPE_TURN_COLLINEAR",        CGAlgorithms::COLLINEAR},
        {"TYPE_TURN_COUNTERCLOCKWISE", CGAlgorithms::COUNTERCLOCKWISE},

        {"TYPE_ORIENT_RIGHT",    CGAlgorithms::RIGHT},
        {"TYPE_ORIENT_LEFT" ,    CGAlgorithms::LEFT},
        {"TYPE_ORIENT_STRAIGHT", CGAlgorithms::STRAIGHT}
    });
    xs::exp::autoexport(this_stash);
    }

#line 73 "./xsi/algorithm/HCoordinate.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Algorithm::HCoordinate"));
    }

#line 46 "./xsi/algorithm/MinimumDiameter.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Algorithm::MinimumDiameter"));
    }

#line 70 "./xsi/algorithm/LineIntersector.xsi"
    {
    auto this_stash = Stash("Geo::Geos::Algorithm::LineIntersector");
    xs::exp::create_constants(this_stash, {
        {"TYPE_NO_INTERSECTION",        LineIntersector::NO_INTERSECTION},
        {"TYPE_POINT_INTERSECTION",     LineIntersector::POINT_INTERSECTION},
        {"TYPE_COLLINEAR_INTERSECTION", LineIntersector::COLLINEAR_INTERSECTION}
    });
    xs::exp::autoexport(this_stash);
    }

#line 88 "./xsi/noding.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Noding"));
    }

#line 39 "./xsi/noding/NodedSegmentString.xsi"
    {
    Stash("Geo::Geos::Noding::NodedSegmentString").inherit("Geo::Geos::Noding::SegmentString");
    }

#line 19 "./xsi/noding/BasicSegmentString.xsi"
    {
    Stash("Geo::Geos::Noding::BasicSegmentString").inherit("Geo::Geos::Noding::SegmentString");
    }

#line 35 "./xsi/noding/SegmentIntersectionDetector.xsi"
    {
    Stash("Geo::Geos::Noding::SegmentIntersectionDetector").inherit("Geo::Geos::Noding::SegmentIntersector");
    }

#line 31 "./xsi/noding/SingleInteriorIntersectionFinder.xsi"
    {
    Stash("Geo::Geos::Noding::SingleInteriorIntersectionFinder").inherit("Geo::Geos::Noding::SegmentIntersector");
    }

#line 29 "./xsi/noding/IntersectionAdder.xsi"
    {
    Stash("Geo::Geos::Noding::IntersectionAdder").inherit("Geo::Geos::Noding::SegmentIntersector");
    }

#line 37 "./xsi/noding/IntersectionFinderAdder.xsi"
    {
    payload_marker_IntersectionFinderAdder.svt_free = payload_marker_IntersectionFinderAdder_free;
    Stash("Geo::Geos::Noding::IntersectionFinderAdder").inherit("Geo::Geos::Noding::SegmentIntersector");
    }

#line 37 "./xsi/noding/Noder.xsi"
    {
    payload_marker_Noder.svt_free = payload_marker_Noder_free;
    }

#line 15 "./xsi/noding/IteratedNoder.xsi"
    {
    Stash("Geo::Geos::Noding::IteratedNoder").inherit("Geo::Geos::Noding::Noder");
    }

#line 15 "./xsi/noding/ScaledNoder.xsi"
    {
    Stash("Geo::Geos::Noding::ScaledNoder").inherit("Geo::Geos::Noding::Noder");
    }

#line 21 "./xsi/noding/SinglePassNoder.xsi"
    {
    Stash("Geo::Geos::Noding::SinglePassNoder").inherit("Geo::Geos::Noding::Noder");
    }

#line 16 "./xsi/noding/SimpleNoder.xsi"
    {
    Stash("Geo::Geos::Noding::SimpleNoder").inherit("Geo::Geos::Noding::SinglePassNoder");
    }

#line 25 "./xsi/noding/SimpleSnapRounder.xsi"
    {
    Stash("Geo::Geos::Noding::SimpleSnapRounder").inherit("Geo::Geos::Noding::Noder");
    }

#line 55 "./xsi/index/MonotoneChain.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Index::MonotoneChain"));
    payload_marker_MonotoneChain.svt_free = payload_marker_MonotoneChain_free;
    }

#line 43 "./xsi/index/SpatialIndex.xsi"
    {
    payload_marker_SVs_map.svt_free = payload_marker_SVs_map_free;
    }

#line 27 "./xsi/index/Quadtree.xsi"
    {
    Stash("Geo::Geos::Index::Quadtree").inherit("Geo::Geos::Index::SpatialIndex");
    }

#line 12 "./xsi/index/STRtree.xsi"
    {
    Stash("Geo::Geos::Index::STRtree").inherit("Geo::Geos::Index::SpatialIndex");
    }

#line 73 "./xsi/precision.xsi"
    {
    xs::exp::autoexport(Stash("Geo::Geos::Precision"));
    }

#line 95 "./xsi/operation.xsi"
    {
    auto this_stash = Stash("Geo::Geos::Operation");
    xs::exp::create_constants(this_stash, {
        {"TYPE_OP_INTERSECTION",         OverlayOp::OpCode::opINTERSECTION},
        {"TYPE_OP_UNION",                OverlayOp::OpCode::opUNION},
        {"TYPE_OP_DIFFERENCE",           OverlayOp::OpCode::opDIFFERENCE},
        {"TYPE_OP_SYMDIFFERENCE",        OverlayOp::OpCode::opSYMDIFFERENCE},

        {"TYPE_BOUNDARY_NODE_RULE_MOD2",            0},
        {"TYPE_BOUNDARY_ENDPOINT",                  1},
        {"TYPE_BOUNDARY_MULTIVALENT_ENDPOINT",      2},
        {"TYPE_BOUNDARY_MONOVALENT_ENDPOINT",       3},
        {"TYPE_BOUNDARY_OGCSFS",                    4}
    });
    xs::exp::autoexport(this_stash);
    }

#line 13092 "Geos_xsgen.cc"

    /* 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
}); }